1 /* Remote debugging interface for Hitachi HMS Monitor Version 1.0
2 Copyright 1992, 1993, 1994 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Steve Chamberlain
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
37 /* External data declarations */
38 extern int stop_soon_quietly
; /* for wait_for_inferior */
40 /* Forward data declarations */
41 extern struct target_ops hms_ops
; /* Forward declaration */
43 /* Forward function declarations */
44 static void hms_fetch_registers ();
45 static int hms_store_registers ();
46 static void hms_close ();
47 static int hms_clear_breakpoints ();
49 extern struct target_ops hms_ops
;
50 static void hms_drain ();
51 static void add_commands ();
52 static void remove_commands ();
54 static int quiet
= 1; /* FIXME - can be removed after Dec '94 */
59 /***********************************************************************/
60 /* Caching stuff stolen from remote-nindy.c */
62 /* The data cache records all the data read from the remote machine
63 since the last time it stopped.
65 Each cache block holds LINE_SIZE bytes of data
66 starting at a multiple-of-LINE_SIZE address. */
68 #define LINE_SIZE_POWER 4
69 #define LINE_SIZE (1<<LINE_SIZE_POWER) /* eg 1<<3 == 8 */
70 #define LINE_SIZE_MASK ((LINE_SIZE-1)) /* eg 7*2+1= 111*/
71 #define DCACHE_SIZE 64 /* Number of cache blocks */
72 #define XFORM(x) ((x&LINE_SIZE_MASK)>>2)
75 struct dcache_block
*next
, *last
;
76 unsigned int addr
; /* Address for which data is recorded. */
77 int data
[LINE_SIZE
/ sizeof (int)];
80 struct dcache_block dcache_free
, dcache_valid
;
82 /* Free all the data cache blocks, thus discarding all cached data. */
87 register struct dcache_block
*db
;
89 while ((db
= dcache_valid
.next
) != &dcache_valid
)
92 insque (db
, &dcache_free
);
97 * If addr is present in the dcache, return the address of the block
101 struct dcache_block
*
105 register struct dcache_block
*db
;
110 /* Search all cache blocks for one that is at this address. */
111 db
= dcache_valid
.next
;
112 while (db
!= &dcache_valid
)
114 if ((addr
& ~LINE_SIZE_MASK
) == db
->addr
)
121 /* Return the int data at address ADDR in dcache block DC. */
124 dcache_value (db
, addr
)
125 struct dcache_block
*db
;
130 return (db
->data
[XFORM (addr
)]);
133 /* Get a free cache block, put or keep it on the valid list,
134 and return its address. The caller should store into the block
135 the address and data that it describes, then remque it from the
136 free list and insert it into the valid list. This procedure
137 prevents errors from creeping in if a ninMemGet is interrupted
138 (which used to put garbage blocks in the valid list...). */
140 struct dcache_block
*
143 register struct dcache_block
*db
;
145 if ((db
= dcache_free
.next
) == &dcache_free
)
147 /* If we can't get one from the free list, take last valid and put
148 it on the free list. */
149 db
= dcache_valid
.last
;
151 insque (db
, &dcache_free
);
155 insque (db
, &dcache_valid
);
159 /* Return the contents of the word at address ADDR in the remote machine,
160 using the data cache. */
166 register struct dcache_block
*db
;
168 db
= dcache_hit (addr
);
171 db
= dcache_alloc ();
173 hms_read_inferior_memory (addr
& ~LINE_SIZE_MASK
, (unsigned char *) db
->data
, LINE_SIZE
);
175 db
->addr
= addr
& ~LINE_SIZE_MASK
;
176 remque (db
); /* Off the free list */
177 insque (db
, &dcache_valid
); /* On the valid list */
179 return (dcache_value (db
, addr
));
182 /* Write the word at ADDR both in the data cache and in the remote machine. */
184 dcache_poke (addr
, data
)
188 register struct dcache_block
*db
;
190 /* First make sure the word is IN the cache. DB is its cache block. */
191 db
= dcache_hit (addr
);
194 db
= dcache_alloc ();
196 hms_write_inferior_memory (addr
& ~LINE_SIZE_MASK
, (unsigned char *) db
->data
, LINE_SIZE
);
198 db
->addr
= addr
& ~LINE_SIZE_MASK
;
199 remque (db
); /* Off the free list */
200 insque (db
, &dcache_valid
); /* On the valid list */
203 /* Modify the word in the cache. */
204 db
->data
[XFORM (addr
)] = data
;
206 /* Send the changed word. */
208 hms_write_inferior_memory (addr
, (unsigned char *) &data
, 4);
212 /* The cache itself. */
213 struct dcache_block the_cache
[DCACHE_SIZE
];
215 /* Initialize the data cache. */
220 register struct dcache_block
*db
;
223 dcache_free
.next
= dcache_free
.last
= &dcache_free
;
224 dcache_valid
.next
= dcache_valid
.last
= &dcache_valid
;
225 for (i
= 0; i
< DCACHE_SIZE
; i
++, db
++)
226 insque (db
, &dcache_free
);
229 /***********************************************************************
230 * I/O stuff stolen from remote-eb.c
231 ***********************************************************************/
233 static int timeout
= 2;
235 static const char *dev_name
;
237 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
238 hms_open knows that we don't have a file open when the program
241 static int before
= 0xdead;
242 static int is_open
= 0;
243 static int after
= 0xdead;
252 error ("remote device not open");
259 /* Read a character from the remote system, doing all the fancy
266 buf
= SERIAL_READCHAR (desc
, timeout
);
268 if (buf
== SERIAL_TIMEOUT
)
270 hms_write (".\r\n", 3);
271 error ("Timeout reading from remote system.");
273 if (buf
== SERIAL_ERROR
)
275 error ("Serial port error!");
278 if (!quiet
|| remote_debug
)
279 printf_unfiltered ("%c", buf
);
288 int b
= SERIAL_READCHAR (desc
, 0);
289 if (b
== SERIAL_TIMEOUT
)
299 buf
= SERIAL_READCHAR (desc
, timeout
);
300 if (buf
== SERIAL_TIMEOUT
)
302 if (!quiet
|| remote_debug
)
303 printf_unfiltered ("%c", buf
);
309 /* Keep discarding input from the remote system, until STRING is found.
310 Let the user break out immediately. */
339 /* Keep discarding input until we see the hms prompt.
341 The convention for dealing with the prompt is that you
343 o *then* wait for the prompt.
345 Thus the last thing that a procedure does with the serial line
346 will be an expect_prompt(). Exception: hms_resume does not
347 wait for the prompt, because the terminal is being handed over
348 to the inferior. However, the next thing which happens after that
349 is a hms_wait which does wait for the prompt.
350 Note that this includes abnormal exit, e.g. error(). This is
351 necessary to prevent getting into states from which we can't
359 /* Get a hex digit from the remote system & return its value.
360 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
362 get_hex_digit (ignore_space
)
370 if (ch
>= '0' && ch
<= '9')
372 else if (ch
>= 'A' && ch
<= 'F')
373 return ch
- 'A' + 10;
374 else if (ch
>= 'a' && ch
<= 'f')
375 return ch
- 'a' + 10;
376 else if (ch
== ' ' && ignore_space
)
381 error ("Invalid hex digit from remote system.");
386 /* Get a byte from hms_desc and put it in *BYT. Accept any number
394 val
= get_hex_digit (1) << 4;
395 val
|= get_hex_digit (0);
399 /* Read a 32-bit hex word from the hms, preceded by a space */
407 for (j
= 0; j
< 8; j
++)
408 val
= (val
<< 4) + get_hex_digit (j
== 0);
412 /* Called when SIGALRM signal sent due to alarm() timeout. */
414 /* Number of SIGTRAPs we need to simulate. That is, the next
415 NEED_ARTIFICIAL_TRAP calls to hms_wait should just return
416 SIGTRAP without actually waiting for anything. */
418 static int need_artificial_trap
= 0;
421 hms_kill (arg
, from_tty
)
429 * Download a file specified in 'args', to the hms.
432 hms_load (args
, fromtty
)
445 abfd
= bfd_openr (args
, gnutarget
);
448 printf_filtered ("Unable to open file %s\n", args
);
452 if (bfd_check_format (abfd
, bfd_object
) == 0)
454 printf_filtered ("File is not an object file\n");
459 while (s
!= (asection
*) NULL
)
461 if (s
->flags
& SEC_LOAD
)
466 char *buffer
= xmalloc (DELTA
);
468 printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s
->name
, s
->vma
, s
->vma
+ s
->_raw_size
);
469 for (i
= 0; i
< s
->_raw_size
; i
+= DELTA
)
473 if (delta
> s
->_raw_size
- i
)
474 delta
= s
->_raw_size
- i
;
476 bfd_get_section_contents (abfd
, s
, buffer
, i
, delta
);
477 hms_write_inferior_memory (s
->vma
+ i
, buffer
, delta
);
478 printf_filtered ("*");
479 gdb_flush (gdb_stdout
);
481 printf_filtered ("\n");
486 sprintf (buffer
, "r PC=%x", abfd
->start_address
);
487 hms_write_cr (buffer
);
489 /* Turn off all breakpoints */
490 hms_write_cr ("b -");
494 /* This is called not only when we first attach, but also when the
495 user types "run" after having attached. */
497 hms_create_inferior (execfile
, args
, env
)
506 error ("Can't pass arguments to remote hms process.");
508 if (execfile
== 0 || exec_bfd
== 0)
509 error ("No exec file specified");
511 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
514 hms_kill (NULL
, NULL
);
515 hms_clear_breakpoints ();
516 init_wait_for_inferior ();
520 insert_breakpoints (); /* Needed to get correct instruction in cache */
521 proceed (entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
524 /* Open a connection to a remote debugger.
525 NAME is the filename used for communication, then a space,
533 while (*s
&& !isspace (*s
))
554 while (*s
&& !isspace (*s
))
560 copy
= xmalloc (len
+ 1);
561 memcpy (copy
, word
, len
);
567 static int baudrate
= 9600;
574 /* Put this port into NORMAL mode, send the 'normal' character */
576 hms_write ("\001", 1); /* Control A */
577 hms_write ("\r\n", 2); /* Cr */
581 ok
= SERIAL_READCHAR (desc
, timeout
);
588 if (readchar_nofail () == 'r')
591 /* Not the right baudrate, or the board's not on */
597 if (!SERIAL_SETBAUDRATE (desc
, baudrate
))
598 error ("Can't set baudrate");
603 hms_open (name
, from_tty
)
616 dev_name
= strdup (name
);
618 if (!(desc
= SERIAL_OPEN (dev_name
)))
619 perror_with_name ((char *) dev_name
);
623 push_target (&hms_ops
);
626 /* Hello? Are you there? */
627 SERIAL_WRITE (desc
, "\r\n", 2);
630 /* Clear any break points */
631 hms_clear_breakpoints ();
633 printf_filtered ("Connected to remote board running HMS monitor.\n");
638 /* Close out all files and local state before this target loses control. */
644 /* Clear any break points */
646 hms_clear_breakpoints ();
647 sleep (1); /* Let any output make it all the way back */
650 SERIAL_WRITE (desc
, "R\r\n", 3);
656 /* Terminate the open connection to the remote debugger. Use this
657 when you want to detach and do something else with your gdb. */ void
658 hms_detach (args
, from_tty
)
664 hms_clear_breakpoints ();
667 pop_target (); /* calls hms_close to do the real work
670 printf_filtered ("Ending remote %s debugging\n",
674 /* Tell the remote machine to resume. */
677 hms_resume (pid
, step
, sig
)
689 /* Force the next hms_wait to return a trap. Not doing anything
690 about I/O from the target means that the user has to type "continue"
691 to see any. FIXME, this should be fixed. */
692 need_artificial_trap
= 1;
701 /* Wait until the remote machine stops, then return, storing status in
702 STATUS just as `wait' would. */
705 hms_wait (pid
, status
)
707 struct target_waitstatus
*status
;
709 /* Strings to look for. '?' means match any single character. Note
710 that with the algorithm we use, the initial character of the string
711 cannot recur in the string, or we will not find some cases of the
712 string in the input. */
714 static char bpt
[] = "At breakpoint:";
716 /* It would be tempting to look for "\n[__exit + 0x8]\n" but that
717 requires loading symbols with "yc i" and even if we did do that we
718 don't know that the file has symbols. */
719 static char exitmsg
[] = "HMS>";
723 /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars.
727 /* Current position in swallowed. */
728 char *swallowed_p
= swallowed
;
732 int old_timeout
= timeout
;
734 old_immediate_quit
= immediate_quit
;
735 int swallowed_cr
= 0;
737 status
->kind
= TARGET_WAITKIND_EXITED
;
738 status
->value
.integer
= 0;
740 if (need_artificial_trap
!= 0)
743 TARGET_WAITKIND_STOPPED
;
744 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
745 need_artificial_trap
--;
749 timeout
= 5; /* Don't time out for a while - user program is running.
751 immediate_quit
= 1; /* Helps ability to QUIT */
754 QUIT
; /* Let user quit and leave process running */
771 (ch
== *ep
|| *ep
== '?')
791 /* Print out any characters which have been swallowed. */
792 for (p
= swallowed
; p
< swallowed_p
; ++p
)
793 putc_unfiltered (*p
);
794 swallowed_p
= swallowed
;
796 if ((ch
!= '\r' && ch
!= '\n') || swallowed_cr
> 10)
798 putc_unfiltered (ch
);
807 status
->kind
= TARGET_WAITKIND_STOPPED
;
808 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
813 status
->kind
= TARGET_WAITKIND_EXITED
;
814 status
->value
.integer
=
818 timeout
= old_timeout
;
819 immediate_quit
= old_immediate_quit
;
824 /* Return the name of register number REGNO in the form input and
827 Returns a pointer to a static buffer containing the answer. */
838 /* Read the remote registers. */
841 gethex (length
, start
, ok
)
851 if (*start
>= 'a' && *start
<= 'f')
853 result
+= *start
- 'a' + 10;
855 else if (*start
>= 'A' &&
858 result
+= *start
- 'A' + 10;
861 (*start
>= '0' && *start
<= '9')
863 result
+= *start
- '0';
873 timed_read (buf
, n
, timeout
)
900 SERIAL_WRITE (desc
, a
, l
);
902 if (!quiet
|| remote_debug
)
904 printf_unfiltered ("<");
905 for (i
= 0; i
< l
; i
++)
907 printf_unfiltered ("%c", a
[i
]);
909 printf_unfiltered (">");
916 hms_write (s
, strlen (s
));
917 hms_write ("\r\n", 2);
920 #ifdef GDB_TARGET_IS_H8500
922 /* H8/500 monitor reg dump looks like:
925 PC:8000 SR:070C .7NZ.. CP:00 DP:00 EP:00 TP:00 BR:00
926 R0-R7: FF5A 0001 F4FE F500 0000 F528 F528 F4EE
932 supply_val (n
, size
, ptr
, segptr
)
943 raw
[0] = gethex (2, ptr
, &ok
);
944 raw
[1] = gethex (2, ptr
+ 2, &ok
);
945 supply_register (n
, raw
);
948 raw
[0] = gethex (2, ptr
, &ok
);
949 supply_register (n
, raw
);
953 int v
= gethex (4, ptr
, &ok
);
954 v
|= gethex (2, segptr
, &ok
) << 16;
956 raw
[1] = (v
>> 16) & 0xff;
957 raw
[2] = (v
>> 8) & 0xff;
958 raw
[3] = (v
>> 0) & 0xff;
959 supply_register (n
, raw
);
965 hms_fetch_register (dummy
)
968 #define REGREPLY_SIZE 108
969 char linebuf
[REGREPLY_SIZE
+ 1];
974 LONGEST reg
[NUM_REGS
];
982 s
= timed_read (linebuf
+ 1, REGREPLY_SIZE
, 1);
984 linebuf
[REGREPLY_SIZE
] = 0;
986 if (linebuf
[3] == 'P' &&
989 linebuf
[105] == 'H' &&
990 linebuf
[106] == 'M' &&
997 -------1---------2---------3---------4---------5-----
998 345678901234567890123456789012345678901234567890123456
999 PC:8000 SR:070C .7NZ.. CP:00 DP:00 EP:00 TP:00 BR:00**
1000 ---6---------7---------8---------9--------10----
1001 789012345678901234567890123456789012345678901234
1002 R0-R7: FF5A 0001 F4FE F500 0000 F528 F528 F4EE**
1010 supply_val (PC_REGNUM
, 4, linebuf
+ 6, linebuf
+ 29);
1012 supply_val (CCR_REGNUM
, 2, linebuf
+ 14);
1013 supply_val (SEG_C_REGNUM
, 1, linebuf
+ 29);
1014 supply_val (SEG_D_REGNUM
, 1, linebuf
+ 35);
1015 supply_val (SEG_E_REGNUM
, 1, linebuf
+ 41);
1016 supply_val (SEG_T_REGNUM
, 1, linebuf
+ 47);
1017 for (i
= 0; i
< 8; i
++)
1024 char *src
= linebuf
+ 64 + 5 * i
;
1025 char *segsrc
= linebuf
+ sr
[i
];
1026 supply_val (R0_REGNUM
+ i
, 2, src
);
1027 supply_val (PR0_REGNUM
+ i
, 4, src
, segsrc
);
1040 #ifdef GDB_TARGET_IS_H8300
1042 hms_fetch_register (dummy
)
1045 #define REGREPLY_SIZE 79
1046 char linebuf
[REGREPLY_SIZE
+ 1];
1051 unsigned LONGEST reg
[NUM_REGS
];
1059 s
= timed_read (linebuf
, 1, 1);
1061 while (linebuf
[0] != 'r')
1062 s
= timed_read (linebuf
, 1, 1);
1064 s
= timed_read (linebuf
+ 1, REGREPLY_SIZE
- 1, 1);
1066 linebuf
[REGREPLY_SIZE
] = 0;
1068 if (linebuf
[0] == 'r' &&
1069 linebuf
[3] == 'P' &&
1070 linebuf
[4] == 'C' &&
1071 linebuf
[5] == '=' &&
1072 linebuf
[75] == 'H' &&
1073 linebuf
[76] == 'M' &&
1077 PC=XXXX CCR=XX:XXXXXXXX R0-R7= XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX
1078 5436789012345678901234567890123456789012345678901234567890123456789012
1083 reg
[PC_REGNUM
] = gethex (4, linebuf
+ 6, &gottok
);
1084 reg
[CCR_REGNUM
] = gethex (2, linebuf
+ 15, &gottok
);
1085 for (i
= 0; i
< 8; i
++)
1087 reg
[i
] = gethex (4, linebuf
+ 34 + 5 * i
, &gottok
);
1092 for (i
= 0; i
< NUM_REGS
; i
++)
1096 swapped
[1] = reg
[i
];
1097 swapped
[0] = (reg
[i
]) >> 8;
1099 supply_register (i
, swapped
);
1103 /* Store register REGNO, or all if REGNO == -1.
1104 Return errno value. */
1106 hms_store_register (regno
)
1111 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1113 hms_store_register (regno
);
1118 char *name
= get_reg_name (regno
);
1120 /* Some regs dont really exist */
1121 if (!(name
[0] == 'p' && name
[1] == 'r')
1122 && !(name
[0] == 'c' && name
[1] == 'y')
1123 && !(name
[0] == 't' && name
[1] == 'i')
1124 && !(name
[0] == 'i' && name
[1] == 'n'))
1126 sprintf (buffer
, "r %s=%x", name
, read_register (regno
));
1127 hms_write_cr (buffer
);
1134 /* Get ready to modify the registers array. On machines which store
1135 individual registers, this doesn't need to do anything. On machines
1136 which store all the registers in one fell swoop, this makes sure
1137 that registers contains all the registers from the program being
1141 hms_prepare_to_store ()
1143 /* Do nothing, since we can store individual regs */
1147 translate_addr (addr
)
1155 /* Read a word from remote address ADDR and return it.
1156 * This goes through the data cache.
1159 hms_fetch_word (addr
)
1162 return dcache_fetch (addr
);
1165 /* Write a word WORD into remote address ADDR.
1166 This goes through the data cache. */
1169 hms_store_word (addr
, word
)
1173 dcache_poke (addr
, word
);
1177 hms_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
1182 struct target_ops
*target
; /* ignored */
1186 /* Round starting address down to longword boundary. */
1187 register CORE_ADDR addr
;
1189 /* Round ending address up; get number of longwords that makes. */
1192 /* Allocate buffer of that many longwords. */
1193 register int *buffer
;
1196 addr
= memaddr
& -sizeof (int);
1197 count
= (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
1199 buffer
= (int *) alloca (count
* sizeof (int));
1203 /* Fill start and end extra bytes of buffer with existing memory data. */
1205 if (addr
!= memaddr
|| len
< (int) sizeof (int))
1207 /* Need part of initial word -- fetch it. */
1208 buffer
[0] = hms_fetch_word (addr
);
1211 if (count
> 1) /* FIXME, avoid if even boundary */
1214 = hms_fetch_word (addr
+ (count
- 1) * sizeof (int));
1217 /* Copy data to be written over corresponding part of buffer */
1219 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
1221 /* Write the entire buffer. */
1223 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
1226 hms_store_word (addr
, buffer
[i
]);
1236 /* Read all the longwords */
1237 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
1240 buffer
[i
] = hms_fetch_word (addr
);
1248 /* Copy appropriate bytes out of the buffer. */
1249 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
1256 hms_write_inferior_memory (memaddr
, myaddr
, len
)
1258 unsigned char *myaddr
;
1274 thisgo
= len
- done
;
1278 sprintf (ptr
, "M.B %4x =", memaddr
+ done
);
1280 for (idx
= 0; idx
< thisgo
; idx
++)
1282 sprintf (ptr
, "%2x ", myaddr
[idx
+ done
]);
1285 hms_write_cr (buffer
);
1294 char *file
= "nothing";
1297 file
= bfd_get_filename (exec_bfd
);
1301 printf_filtered ("\tAttached to DOS asynctsr and running program %s\n", file
);
1303 printf_filtered ("\tAttached to %s at %d baud and running program %s\n", dev_name
, baudrate
, file
);
1305 printf_filtered ("\ton an H8/300 processor.\n");
1308 /* Copy LEN bytes of data from debugger memory at MYADDR
1309 to inferior's memory at MEMADDR. Returns errno value.
1310 * sb/sh instructions don't work on unaligned addresses, when TU=1.
1313 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
1314 at debugger address MYADDR. Returns errno value. */
1316 hms_read_inferior_memory (memaddr
, myaddr
, len
)
1321 /* Align to nearest low 16 bits */
1324 CORE_ADDR start
= memaddr
;
1325 CORE_ADDR end
= memaddr
+ len
- 1;
1330 AAAA: XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX '................'
1331 012345678901234567890123456789012345678901234567890123456789012345
1341 sprintf (buffer
, "m %4x %4x", start
& 0xffff, end
& 0xffff);
1344 hms_write_cr (buffer
);
1345 /* drop the echo and newline*/
1346 for (i
= 0; i
< 13; i
++)
1349 /* Grab the lines as they come out and fill the area */
1360 buffer
[0] = readchar ();
1361 while (buffer
[0] == '\r'
1362 || buffer
[0] == '\n')
1363 buffer
[0] = readchar ();
1365 if (buffer
[0] == 'M')
1368 for (i
= 1; i
< 50; i
++) {
1369 buffer
[i
] = readchar ();
1371 /* sometimes we loose characters in the ascii representation of the
1372 data. I don't know where. So just scan for the end of line */
1374 while (i
!= '\n' && i
!= '\r')
1377 /* Now parse the line */
1379 addr
= gethex (4, buffer
, &ok
);
1381 for (p
= 0; p
< 16; p
+= 2)
1383 byte
[p
] = gethex (2, buffer
+ idx
, &ok
);
1384 byte
[p
+ 1] = gethex (2, buffer
+ idx
+ 2, &ok
);
1388 for (p
= 0; p
< 16; p
++)
1390 if (addr
+ p
>= memaddr
&&
1391 addr
+ p
< memaddr
+ len
)
1393 myaddr
[(addr
+ p
) - memaddr
] = byte
[p
];
1399 #ifdef GDB_TARGET_IS_H8500
1402 #ifdef GDB_TARGET_IS_H8300
1413 #define MAX_BREAKS 16
1414 static int num_brkpts
= 0;
1416 hms_insert_breakpoint (addr
, save
)
1418 char *save
; /* Throw away, let hms save instructions */
1422 if (num_brkpts
< MAX_BREAKS
)
1427 sprintf (buffer
, "b %x", addr
& 0xffff);
1428 hms_write_cr (buffer
);
1434 fprintf_filtered (gdb_stderr
,
1435 "Too many break points, break point not installed\n");
1441 hms_remove_breakpoint (addr
, save
)
1443 char *save
; /* Throw away, let hms save instructions */
1450 sprintf (buffer
, "b - %x", addr
& 0xffff);
1451 hms_write_cr (buffer
);
1458 /* Clear the hmss notion of what the break points are */
1460 hms_clear_breakpoints ()
1465 hms_write_cr ("b -");
1473 hms_clear_breakpoints ();
1474 unpush_target (&hms_ops
);
1475 generic_mourn_inferior ();
1478 /* Put a command string, in args, out to the hms. The hms is assumed to
1479 be in raw mode, all writing/reading done through desc.
1480 Ouput from the hms is placed on the users terminal until the
1481 prompt from the hms is seen.
1482 FIXME: Can't handle commands that take input. */
1485 hms_com (args
, fromtty
)
1494 /* Clear all input so only command relative output is displayed */
1496 hms_write_cr (args
);
1497 /* hms_write ("\030", 1);*/
1501 /* Define the target subroutine names */
1503 struct target_ops hms_ops
=
1505 "hms", "Remote HMS monitor",
1506 "Use the H8 evaluation board running the HMS monitor connected\n\
1509 hms_open
, hms_close
,
1510 0, hms_detach
, hms_resume
, hms_wait
, /* attach */
1511 hms_fetch_register
, hms_store_register
,
1512 hms_prepare_to_store
,
1513 hms_xfer_inferior_memory
,
1515 hms_insert_breakpoint
, hms_remove_breakpoint
, /* Breakpoints */
1516 0, 0, 0, 0, 0, /* Terminal handling */
1517 hms_kill
, /* FIXME, kill */
1519 0, /* lookup_symbol */
1520 hms_create_inferior
, /* create_inferior */
1521 hms_mourn
, /* mourn_inferior FIXME */
1523 0, /* notice_signals */
1525 process_stratum
, 0, /* next */
1526 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
1527 0, 0, /* Section pointers */
1528 OPS_MAGIC
, /* Always the last thing */
1531 hms_quiet () /* FIXME - this routine can be removed after Dec '94 */
1535 printf_filtered ("Snoop disabled\n");
1537 printf_filtered ("Snoop enabled\n");
1539 printf_filtered("`snoop' is obsolete, please use `set remotedebug'.\n");
1547 dev_name
= get_word (&s
);
1560 int newrate
= atoi (s
);
1563 if (SERIAL_SETBAUDRATE (desc
, newrate
))
1564 error ("Can't use %d baud\n", newrate
);
1566 printf_filtered ("Checking target is in sync\n");
1568 printf_filtered ("Sending commands to set target to %d\n",
1571 sprintf (buffer
, "tm %d. N 8 1", baudrate
);
1572 hms_write_cr (buffer
);
1576 /***********************************************************************/
1579 hms_drain (args
, fromtty
)
1586 c
= SERIAL_READCHAR (desc
, 1);
1587 if (c
== SERIAL_TIMEOUT
)
1589 if (c
== SERIAL_ERROR
)
1591 if (c
> ' ' && c
< 127)
1592 printf ("%c", c
& 0xff);
1594 printf ("<%x>", c
& 0xff);
1602 add_com ("hms_drain", class_obscure
, hms_drain
,
1603 "Drain pending hms text buffers.");
1609 extern struct cmd_list_element
*cmdlist
;
1610 delete_cmd ("hms-drain", &cmdlist
);
1614 _initialize_remote_hms ()
1616 add_target (&hms_ops
);
1618 add_com ("hms <command>", class_obscure
, hms_com
,
1619 "Send a command to the HMS monitor.");
1621 /* FIXME - hms_quiet and `snoop' can be removed after Dec '94 */
1622 add_com ("snoop", class_obscure
, hms_quiet
,
1623 "Show what commands are going to the monitor (OBSOLETE - see 'set remotedebug')");
1625 add_com ("device", class_obscure
, hms_device
,
1626 "Set the terminal line for HMS communications");
1628 add_com ("speed", class_obscure
, hms_speed
,
1629 "Set the terminal line speed for HMS communications");
This page took 0.062392 seconds and 4 git commands to generate.