1 /* Remote debugging interface for Hitachi HMS Monitor Version 1.0
2 Copyright 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 static void hms_open
PARAMS ((char *args
, int from_tty
));
30 hms_supply_register (regname
, regnamelen
, val
, vallen
)
40 if (regname
[0] != 'P')
42 /* We scan off all the registers in one go */
44 val
= monitor_supply_register (PC_REGNUM
, val
);
45 /* Skip the ccr string */
46 while (*val
!= '=' && *val
)
49 val
= monitor_supply_register (CCR_REGNUM
, val
+ 1);
51 /* Skip up to rest of regs */
52 while (*val
!= '=' && *val
)
55 for (regno
= 0; regno
< 7; regno
++)
57 val
= monitor_supply_register (regno
, val
+ 1);
62 * This array of registers needs to match the indexes used by GDB. The
63 * whole reason this exists is because the various ROM monitors use
64 * different names than GDB does, and don't support all the
65 * registers either. So, typing "info reg sp" becomes a "r30".
68 static char *hms_regnames
[NUM_REGS
] =
70 "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", "CCR", "PC"
74 * Define the monitor command strings. Since these are passed directly
75 * through to a printf style function, we need can include formatting
76 * strings. We also need a CR or LF on the end.
79 static struct target_ops hms_ops
;
81 static char *hms_inits
[] =
82 {"\003", /* Resets the prompt, and clears repeated cmds */
85 static struct monitor_ops hms_cmds
;
90 hms_cmds
.flags
= MO_CLR_BREAK_USES_ADDR
| MO_FILL_USES_ADDR
| MO_GETMEM_NEEDS_RANGE
;
91 hms_cmds
.init
= hms_inits
; /* Init strings */
92 hms_cmds
.cont
= "g\r"; /* continue command */
93 hms_cmds
.step
= "s\r"; /* single step */
94 hms_cmds
.stop
= "\003"; /* ^C interrupts the program */
95 hms_cmds
.set_break
= "b %x\r"; /* set a breakpoint */
96 hms_cmds
.clr_break
= "b - %x\r"; /* clear a breakpoint */
97 hms_cmds
.clr_all_break
= "b -\r"; /* clear all breakpoints */
98 hms_cmds
.fill
= "f %x %x %x\r"; /* fill (start end val) */
99 hms_cmds
.setmem
.cmdb
= "m.b %x=%x\r"; /* setmem.cmdb (addr, value) */
100 hms_cmds
.setmem
.cmdw
= "m.w %x=%x\r"; /* setmem.cmdw (addr, value) */
101 hms_cmds
.setmem
.cmdl
= NULL
; /* setmem.cmdl (addr, value) */
102 hms_cmds
.setmem
.cmdll
= NULL
; /* setmem.cmdll (addr, value) */
103 hms_cmds
.setmem
.resp_delim
= NULL
;/* setreg.resp_delim */
104 hms_cmds
.setmem
.term
= NULL
; /* setreg.term */
105 hms_cmds
.setmem
.term_cmd
= NULL
; /* setreg.term_cmd */
106 hms_cmds
.getmem
.cmdb
= "m.b %x %x\r"; /* getmem.cmdb (addr, addr) */
107 hms_cmds
.getmem
.cmdw
= "m.w %x %x\r"; /* getmem.cmdw (addr, addr) */
108 hms_cmds
.getmem
.cmdl
= NULL
; /* getmem.cmdl (addr, addr) */
109 hms_cmds
.getmem
.cmdll
= NULL
; /* getmem.cmdll (addr, addr) */
110 hms_cmds
.getmem
.resp_delim
= ": ";/* getmem.resp_delim */
111 hms_cmds
.getmem
.term
= ">"; /* getmem.term */
112 hms_cmds
.getmem
.term_cmd
= "\003";/* getmem.term_cmd */
113 hms_cmds
.setreg
.cmd
= "r %s=%x\r";/* setreg.cmd (name, value) */
114 hms_cmds
.setreg
.resp_delim
= NULL
;/* setreg.resp_delim */
115 hms_cmds
.setreg
.term
= NULL
; /* setreg.term */
116 hms_cmds
.setreg
.term_cmd
= NULL
; /* setreg.term_cmd */
117 hms_cmds
.getreg
.cmd
= "r %s\r"; /* getreg.cmd (name) */
118 hms_cmds
.getreg
.resp_delim
= " (";/* getreg.resp_delim */
119 hms_cmds
.getreg
.term
= ":"; /* getreg.term */
120 hms_cmds
.getreg
.term_cmd
= "\003";/* getreg.term_cmd */
121 hms_cmds
.dump_registers
= "r\r"; /* dump_registers */
122 hms_cmds
.register_pattern
= "\\(\\w+\\)=\\([0-9a-fA-F]+\\)"; /* register_pattern */
123 hms_cmds
.supply_register
= hms_supply_register
; /* supply_register */
124 hms_cmds
.load_routine
= NULL
; /* load_routine (defaults to SRECs) */
125 hms_cmds
.load
= "tl\r"; /* download command */
126 hms_cmds
.loadresp
= NULL
; /* load response */
127 hms_cmds
.prompt
= ">"; /* monitor command prompt */
128 hms_cmds
.line_term
= "\r"; /* end-of-command delimitor */
129 hms_cmds
.cmd_end
= NULL
; /* optional command terminator */
130 hms_cmds
.target
= &hms_ops
; /* target operations */
131 hms_cmds
.stopbits
= SERIAL_1_STOPBITS
;/* number of stop bits */
132 hms_cmds
.regnames
= hms_regnames
; /* registers names */
133 hms_cmds
.magic
= MONITOR_OPS_MAGIC
; /* magic */
134 } /* init_hms-cmds */
137 hms_open (args
, from_tty
)
141 monitor_open (args
, &hms_cmds
, from_tty
);
144 int write_dos_tick_delay
;
147 _initialize_remote_hms ()
150 init_monitor_ops (&hms_ops
);
152 hms_ops
.to_shortname
= "hms";
153 hms_ops
.to_longname
= "Hitachi Microsystems H8/300 debug monitor";
154 hms_ops
.to_doc
= "Debug via the HMS monitor.\n\
155 Specify the serial device it is connected to (e.g. /dev/ttya).";
156 hms_ops
.to_open
= hms_open
;
157 /* By trial and error I've found that this delay doesn't break things */
158 write_dos_tick_delay
= 1;
159 add_target (&hms_ops
);
163 /* This is kept here because we used to support the H8/500 in this module,
164 and I haven't done the H8/500 yet */
166 #include "inferior.h"
169 #include "gdb_string.h"
175 #include "terminal.h"
179 #include "remote-utils.h"
180 /* External data declarations */
181 extern int stop_soon_quietly
; /* for wait_for_inferior */
183 /* Forward data declarations */
184 extern struct target_ops hms_ops
; /* Forward declaration */
186 /* Forward function declarations */
187 static void hms_fetch_registers ();
188 static int hms_store_registers ();
189 static void hms_close ();
190 static int hms_clear_breakpoints ();
192 extern struct target_ops hms_ops
;
193 static void hms_drain ();
194 static void add_commands ();
195 static void remove_commands ();
197 static int quiet
= 1; /* FIXME - can be removed after Dec '94 */
201 /***********************************************************************
202 * I/O stuff stolen from remote-eb.c
203 ***********************************************************************/
205 static int timeout
= 2;
207 static const char *dev_name
;
209 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
210 hms_open knows that we don't have a file open when the program
213 static int before
= 0xdead;
214 static int is_open
= 0;
215 static int after
= 0xdead;
221 printf ("OUTCH! \n");
224 error ("remote device not open");
231 /* Read a character from the remote system, doing all the fancy
238 buf
= SERIAL_READCHAR (desc
, timeout
);
240 if (buf
== SERIAL_TIMEOUT
)
242 hms_write (".\r\n", 3);
243 error ("Timeout reading from remote system.");
245 if (buf
== SERIAL_ERROR
)
247 error ("Serial port error!");
250 if (!quiet
|| remote_debug
)
251 printf_unfiltered ("%c", buf
);
261 int b
= SERIAL_READCHAR (desc
, 0);
262 if (b
== SERIAL_TIMEOUT
)
272 buf
= SERIAL_READCHAR (desc
, timeout
);
273 if (buf
== SERIAL_TIMEOUT
)
275 if (!quiet
|| remote_debug
)
276 printf_unfiltered ("%c", buf
);
282 /* Keep discarding input from the remote system, until STRING is found.
283 Let the user break out immediately. */
312 /* Keep discarding input until we see the hms prompt.
314 The convention for dealing with the prompt is that you
316 o *then* wait for the prompt.
318 Thus the last thing that a procedure does with the serial line
319 will be an expect_prompt(). Exception: hms_resume does not
320 wait for the prompt, because the terminal is being handed over
321 to the inferior. However, the next thing which happens after that
322 is a hms_wait which does wait for the prompt.
323 Note that this includes abnormal exit, e.g. error(). This is
324 necessary to prevent getting into states from which we can't
332 /* Get a hex digit from the remote system & return its value.
333 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
335 get_hex_digit (ignore_space
)
343 if (ch
>= '0' && ch
<= '9')
345 else if (ch
>= 'A' && ch
<= 'F')
346 return ch
- 'A' + 10;
347 else if (ch
>= 'a' && ch
<= 'f')
348 return ch
- 'a' + 10;
349 else if (ch
== ' ' && ignore_space
)
354 error ("Invalid hex digit from remote system.");
359 /* Get a byte from hms_desc and put it in *BYT. Accept any number
367 val
= get_hex_digit (1) << 4;
368 val
|= get_hex_digit (0);
372 /* Read a 32-bit hex word from the hms, preceded by a space */
380 for (j
= 0; j
< 8; j
++)
381 val
= (val
<< 4) + get_hex_digit (j
== 0);
385 /* Called when SIGALRM signal sent due to alarm() timeout. */
387 /* Number of SIGTRAPs we need to simulate. That is, the next
388 NEED_ARTIFICIAL_TRAP calls to hms_wait should just return
389 SIGTRAP without actually waiting for anything. */
391 static int need_artificial_trap
= 0;
394 hms_kill (arg
, from_tty
)
401 /* This is called not only when we first attach, but also when the
402 user types "run" after having attached. */
404 hms_create_inferior (execfile
, args
, env
)
413 error ("Can't pass arguments to remote hms process.");
415 if (execfile
== 0 || exec_bfd
== 0)
416 error ("No executable file specified");
418 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
421 hms_kill (NULL
, NULL
);
422 hms_clear_breakpoints ();
423 init_wait_for_inferior ();
427 insert_breakpoints (); /* Needed to get correct instruction in cache */
428 proceed (entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
431 /* Open a connection to a remote debugger.
432 NAME is the filename used for communication, then a space,
440 while (*s
&& !isspace (*s
))
461 while (*s
&& !isspace (*s
))
467 copy
= xmalloc (len
+ 1);
468 memcpy (copy
, word
, len
);
474 static int baudrate
= 9600;
481 /* Put this port into NORMAL mode, send the 'normal' character */
483 hms_write ("\001", 1); /* Control A */
484 hms_write ("\r\n", 2); /* Cr */
488 ok
= SERIAL_READCHAR (desc
, timeout
);
495 if (readchar_nofail () == 'r')
498 /* Not the right baudrate, or the board's not on */
504 if (!SERIAL_SETBAUDRATE (desc
, baudrate
))
505 error ("Can't set baudrate");
510 /* Close out all files and local state before this target loses control. */
516 /* Clear any break points */
518 hms_clear_breakpoints ();
519 sleep (1); /* Let any output make it all the way back */
522 SERIAL_WRITE (desc
, "R\r\n", 3);
528 /* Terminate the open connection to the remote debugger. Use this
529 when you want to detach and do something else with your gdb. */ void
530 hms_detach (args
, from_tty
)
536 hms_clear_breakpoints ();
539 pop_target (); /* calls hms_close to do the real work
542 printf_filtered ("Ending remote %s debugging\n",
546 /* Tell the remote machine to resume. */
549 hms_resume (pid
, step
, sig
)
559 /* Force the next hms_wait to return a trap. Not doing anything
560 about I/O from the target means that the user has to type "continue"
561 to see any. FIXME, this should be fixed. */
562 need_artificial_trap
= 1;
571 /* Wait until the remote machine stops, then return, storing status in
572 STATUS just as `wait' would. */
575 hms_wait (pid
, status
)
577 struct target_waitstatus
*status
;
579 /* Strings to look for. '?' means match any single character. Note
580 that with the algorithm we use, the initial character of the string
581 cannot recur in the string, or we will not find some cases of the
582 string in the input. */
584 static char bpt
[] = "At breakpoint:";
586 /* It would be tempting to look for "\n[__exit + 0x8]\n" but that
587 requires loading symbols with "yc i" and even if we did do that we
588 don't know that the file has symbols. */
589 static char exitmsg
[] = "HMS>";
593 /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars.
597 /* Current position in swallowed. */
598 char *swallowed_p
= swallowed
;
602 int old_timeout
= timeout
;
604 old_immediate_quit
= immediate_quit
;
605 int swallowed_cr
= 0;
607 status
->kind
= TARGET_WAITKIND_EXITED
;
608 status
->value
.integer
= 0;
610 if (need_artificial_trap
!= 0)
613 TARGET_WAITKIND_STOPPED
;
614 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
615 need_artificial_trap
--;
619 timeout
= 5; /* Don't time out for a while - user program is running.
621 immediate_quit
= 1; /* Helps ability to QUIT */
624 QUIT
; /* Let user quit and leave process running */
641 (ch
== *ep
|| *ep
== '?')
661 /* Print out any characters which have been swallowed. */
662 for (p
= swallowed
; p
< swallowed_p
; ++p
)
663 putchar_unfiltered (*p
);
664 swallowed_p
= swallowed
;
666 if ((ch
!= '\r' && ch
!= '\n') || swallowed_cr
> 10)
668 putchar_unfiltered (ch
);
677 status
->kind
= TARGET_WAITKIND_STOPPED
;
678 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
683 status
->kind
= TARGET_WAITKIND_EXITED
;
684 status
->value
.integer
=
688 timeout
= old_timeout
;
689 immediate_quit
= old_immediate_quit
;
694 /* Return the name of register number REGNO in the form input and
697 Returns a pointer to a static buffer containing the answer. */
708 /* Read the remote registers. */
711 gethex (length
, start
, ok
)
721 if (*start
>= 'a' && *start
<= 'f')
723 result
+= *start
- 'a' + 10;
725 else if (*start
>= 'A' &&
728 result
+= *start
- 'A' + 10;
731 (*start
>= '0' && *start
<= '9')
733 result
+= *start
- '0';
743 timed_read (buf
, n
, timeout
)
770 SERIAL_WRITE (desc
, a
, l
);
772 if (!quiet
|| remote_debug
)
774 printf_unfiltered ("<");
775 for (i
= 0; i
< l
; i
++)
777 printf_unfiltered ("%c", a
[i
]);
779 printf_unfiltered (">");
786 hms_write (s
, strlen (s
));
787 hms_write ("\r\n", 2);
790 #ifdef GDB_TARGET_IS_H8500
792 /* H8/500 monitor reg dump looks like:
795 PC:8000 SR:070C .7NZ.. CP:00 DP:00 EP:00 TP:00 BR:00
796 R0-R7: FF5A 0001 F4FE F500 0000 F528 F528 F4EE
802 supply_val (n
, size
, ptr
, segptr
)
813 raw
[0] = gethex (2, ptr
, &ok
);
814 raw
[1] = gethex (2, ptr
+ 2, &ok
);
815 supply_register (n
, raw
);
818 raw
[0] = gethex (2, ptr
, &ok
);
819 supply_register (n
, raw
);
823 int v
= gethex (4, ptr
, &ok
);
824 v
|= gethex (2, segptr
, &ok
) << 16;
826 raw
[1] = (v
>> 16) & 0xff;
827 raw
[2] = (v
>> 8) & 0xff;
828 raw
[3] = (v
>> 0) & 0xff;
829 supply_register (n
, raw
);
835 hms_fetch_register (dummy
)
838 #define REGREPLY_SIZE 108
839 char linebuf
[REGREPLY_SIZE
+ 1];
844 LONGEST reg
[NUM_REGS
];
852 s
= timed_read (linebuf
+ 1, REGREPLY_SIZE
, 1);
854 linebuf
[REGREPLY_SIZE
] = 0;
856 if (linebuf
[3] == 'P' &&
859 linebuf
[105] == 'H' &&
860 linebuf
[106] == 'M' &&
867 -------1---------2---------3---------4---------5-----
868 345678901234567890123456789012345678901234567890123456
869 PC:8000 SR:070C .7NZ.. CP:00 DP:00 EP:00 TP:00 BR:00**
870 ---6---------7---------8---------9--------10----
871 789012345678901234567890123456789012345678901234
872 R0-R7: FF5A 0001 F4FE F500 0000 F528 F528 F4EE**
880 supply_val (PC_REGNUM
, 4, linebuf
+ 6, linebuf
+ 29);
882 supply_val (CCR_REGNUM
, 2, linebuf
+ 14);
883 supply_val (SEG_C_REGNUM
, 1, linebuf
+ 29);
884 supply_val (SEG_D_REGNUM
, 1, linebuf
+ 35);
885 supply_val (SEG_E_REGNUM
, 1, linebuf
+ 41);
886 supply_val (SEG_T_REGNUM
, 1, linebuf
+ 47);
887 for (i
= 0; i
< 8; i
++)
894 char *src
= linebuf
+ 64 + 5 * i
;
895 char *segsrc
= linebuf
+ sr
[i
];
896 supply_val (R0_REGNUM
+ i
, 2, src
);
897 supply_val (PR0_REGNUM
+ i
, 4, src
, segsrc
);
910 #ifdef GDB_TARGET_IS_H8300
912 hms_fetch_register (dummy
)
915 #define REGREPLY_SIZE 79
916 char linebuf
[REGREPLY_SIZE
+ 1];
921 ULONGEST reg
[NUM_REGS
];
929 s
= timed_read (linebuf
, 1, 1);
931 while (linebuf
[0] != 'r')
932 s
= timed_read (linebuf
, 1, 1);
934 s
= timed_read (linebuf
+ 1, REGREPLY_SIZE
- 1, 1);
936 linebuf
[REGREPLY_SIZE
] = 0;
938 if (linebuf
[0] == 'r' &&
942 linebuf
[75] == 'H' &&
943 linebuf
[76] == 'M' &&
947 PC=XXXX CCR=XX:XXXXXXXX R0-R7= XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX
948 5436789012345678901234567890123456789012345678901234567890123456789012
953 reg
[PC_REGNUM
] = gethex (4, linebuf
+ 6, &gottok
);
954 reg
[CCR_REGNUM
] = gethex (2, linebuf
+ 15, &gottok
);
955 for (i
= 0; i
< 8; i
++)
957 reg
[i
] = gethex (4, linebuf
+ 34 + 5 * i
, &gottok
);
962 for (i
= 0; i
< NUM_REGS
; i
++)
967 swapped
[0] = (reg
[i
]) >> 8;
969 supply_register (i
, swapped
);
973 /* Store register REGNO, or all if REGNO == -1.
974 Return errno value. */
976 hms_store_register (regno
)
981 for (regno
= 0; regno
< NUM_REGS
; regno
++)
983 hms_store_register (regno
);
988 char *name
= get_reg_name (regno
);
990 /* Some regs dont really exist */
991 if (!(name
[0] == 'p' && name
[1] == 'r')
992 && !(name
[0] == 'c' && name
[1] == 'y')
993 && !(name
[0] == 't' && name
[1] == 'i')
994 && !(name
[0] == 'i' && name
[1] == 'n'))
996 sprintf (buffer
, "r %s=%x", name
, read_register (regno
));
997 hms_write_cr (buffer
);
1004 /* Get ready to modify the registers array. On machines which store
1005 individual registers, this doesn't need to do anything. On machines
1006 which store all the registers in one fell swoop, this makes sure
1007 that registers contains all the registers from the program being
1011 hms_prepare_to_store ()
1013 /* Do nothing, since we can store individual regs */
1017 translate_addr (addr
)
1027 hms_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
1032 struct target_ops
*target
; /* ignored */
1039 hms_write_inferior_memory (memaddr
, myaddr
, len
)
1041 unsigned char *myaddr
;
1057 thisgo
= len
- done
;
1061 sprintf (ptr
, "M.B %4x =", memaddr
+ done
);
1063 for (idx
= 0; idx
< thisgo
; idx
++)
1065 sprintf (ptr
, "%2x ", myaddr
[idx
+ done
]);
1068 hms_write_cr (buffer
);
1077 char *file
= "nothing";
1080 file
= bfd_get_filename (exec_bfd
);
1084 printf_filtered ("\tAttached to DOS asynctsr and running program %s\n", file
);
1086 printf_filtered ("\tAttached to %s at %d baud and running program %s\n", dev_name
, baudrate
, file
);
1088 printf_filtered ("\ton an H8/300 processor.\n");
1091 /* Copy LEN bytes of data from debugger memory at MYADDR
1092 to inferior's memory at MEMADDR. Returns errno value.
1093 * sb/sh instructions don't work on unaligned addresses, when TU=1.
1096 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
1097 at debugger address MYADDR. Returns errno value. */
1099 hms_read_inferior_memory (memaddr
, myaddr
, len
)
1104 /* Align to nearest low 16 bits */
1107 CORE_ADDR start
= memaddr
;
1108 CORE_ADDR end
= memaddr
+ len
- 1;
1113 AAAA: XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX '................'
1114 012345678901234567890123456789012345678901234567890123456789012345
1124 sprintf (buffer
, "m %4x %4x", start
& 0xffff, end
& 0xffff);
1127 hms_write_cr (buffer
);
1128 /* drop the echo and newline */
1129 for (i
= 0; i
< 13; i
++)
1132 /* Grab the lines as they come out and fill the area */
1143 buffer
[0] = readchar ();
1144 while (buffer
[0] == '\r'
1145 || buffer
[0] == '\n')
1146 buffer
[0] = readchar ();
1148 if (buffer
[0] == 'M')
1151 for (i
= 1; i
< 50; i
++)
1153 buffer
[i
] = readchar ();
1155 /* sometimes we loose characters in the ascii representation of the
1156 data. I don't know where. So just scan for the end of line */
1158 while (i
!= '\n' && i
!= '\r')
1161 /* Now parse the line */
1163 addr
= gethex (4, buffer
, &ok
);
1165 for (p
= 0; p
< 16; p
+= 2)
1167 byte
[p
] = gethex (2, buffer
+ idx
, &ok
);
1168 byte
[p
+ 1] = gethex (2, buffer
+ idx
+ 2, &ok
);
1172 for (p
= 0; p
< 16; p
++)
1174 if (addr
+ p
>= memaddr
&&
1175 addr
+ p
< memaddr
+ len
)
1177 myaddr
[(addr
+ p
) - memaddr
] = byte
[p
];
1183 #ifdef GDB_TARGET_IS_H8500
1186 #ifdef GDB_TARGET_IS_H8300
1197 #define MAX_BREAKS 16
1198 static int num_brkpts
= 0;
1200 hms_insert_breakpoint (addr
, save
)
1202 char *save
; /* Throw away, let hms save instructions */
1206 if (num_brkpts
< MAX_BREAKS
)
1211 sprintf (buffer
, "b %x", addr
& 0xffff);
1212 hms_write_cr (buffer
);
1218 fprintf_filtered (gdb_stderr
,
1219 "Too many break points, break point not installed\n");
1225 hms_remove_breakpoint (addr
, save
)
1227 char *save
; /* Throw away, let hms save instructions */
1234 sprintf (buffer
, "b - %x", addr
& 0xffff);
1235 hms_write_cr (buffer
);
1242 /* Clear the hmss notion of what the break points are */
1244 hms_clear_breakpoints ()
1249 hms_write_cr ("b -");
1257 hms_clear_breakpoints ();
1258 unpush_target (&hms_ops
);
1259 generic_mourn_inferior ();
1262 /* Put a command string, in args, out to the hms. The hms is assumed to
1263 be in raw mode, all writing/reading done through desc.
1264 Ouput from the hms is placed on the users terminal until the
1265 prompt from the hms is seen.
1266 FIXME: Can't handle commands that take input. */
1269 hms_com (args
, fromtty
)
1278 /* Clear all input so only command relative output is displayed */
1280 hms_write_cr (args
);
1281 /* hms_write ("\030", 1); */
1286 hms_open (name
, from_tty
)
1299 dev_name
= strdup (name
);
1301 if (!(desc
= SERIAL_OPEN (dev_name
)))
1302 perror_with_name ((char *) dev_name
);
1306 push_target (&hms_ops
);
1307 dcache_ptr
= dcache_init (hms_read_inferior_memory
,
1308 hms_write_inferior_memory
);
1310 /* Hello? Are you there? */
1311 SERIAL_WRITE (desc
, "\r\n", 2);
1314 /* Clear any break points */
1315 hms_clear_breakpoints ();
1317 printf_filtered ("Connected to remote board running HMS monitor.\n");
1322 /* Define the target subroutine names */
1324 struct target_ops hms_ops
;
1329 hms_ops
.to_shortname
= "hms";
1330 hms_ops
.to_longname
= "Remote HMS monitor";
1331 hms_ops
.to_doc
= "Use the H8 evaluation board running the HMS monitor connected\n\
1333 hms_ops
.to_open
= hms_open
;
1334 hms_ops
.to_close
= hms_close
;
1335 hms_ops
.to_attach
= 0;
1336 hms_ops
.to_post_attach
= NULL
;
1337 hms_ops
.to_require_attach
= NULL
;
1338 hms_ops
.to_detach
= hms_detach
;
1339 hms_ops
.to_require_detach
= NULL
;
1340 hms_ops
.to_resume
= hms_resume
;
1341 hms_ops
.to_wait
= hms_wait
;
1342 hms_ops
.to_post_wait
= NULL
;
1343 hms_ops
.to_fetch_registers
= hms_fetch_register
;
1344 hms_ops
.to_store_registers
= hms_store_register
;
1345 hms_ops
.to_prepare_to_store
= hms_prepare_to_store
;
1346 hms_ops
.to_xfer_memory
= hms_xfer_inferior_memory
;
1347 hms_ops
.to_files_info
= hms_files_info
;
1348 hms_ops
.to_insert_breakpoint
= hms_insert_breakpoint
;
1349 hms_ops
.to_remove_breakpoint
= hms_remove_breakpoint
;
1350 hms_ops
.to_terminal_init
= 0;
1351 hms_ops
.to_terminal_inferior
= 0;
1352 hms_ops
.to_terminal_ours_for_output
= 0;
1353 hms_ops
.to_terminal_ours
= 0;
1354 hms_ops
.to_terminal_info
= 0;
1355 hms_ops
.to_kill
= hms_kill
;
1356 hms_ops
.to_load
= generic_load
;
1357 hms_ops
.to_lookup_symbol
= 0;
1358 hms_ops
.to_create_inferior
= hms_create_inferior
;
1359 hms_ops
.to_post_startup_inferior
= NULL
;
1360 hms_ops
.to_acknowledge_created_inferior
= NULL
;
1361 hms_ops
.to_clone_and_follow_inferior
= NULL
;
1362 hms_ops
.to_post_follow_inferior_by_clone
= NULL
;
1363 hms_ops
.to_insert_fork_catchpoint
= NULL
;
1364 hms_ops
.to_remove_fork_catchpoint
= NULL
;
1365 hms_ops
.to_insert_vfork_catchpoint
= NULL
;
1366 hms_ops
.to_remove_vfork_catchpoint
= NULL
;
1367 hms_ops
.to_has_forked
= NULL
;
1368 hms_ops
.to_has_vforked
= NULL
;
1369 hms_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
1370 hms_ops
.to_post_follow_vfork
= NULL
;
1371 hms_ops
.to_insert_exec_catchpoint
= NULL
;
1372 hms_ops
.to_remove_exec_catchpoint
= NULL
;
1373 hms_ops
.to_has_execd
= NULL
;
1374 hms_ops
.to_reported_exec_events_per_exec_call
= NULL
;
1375 hms_ops
.to_has_exited
= NULL
;
1376 hms_ops
.to_mourn_inferior
= hms_mourn
;
1377 hms_ops
.to_can_run
= 0;
1378 hms_ops
.to_notice_signals
= 0;
1379 hms_ops
.to_thread_alive
= 0;
1380 hms_ops
.to_stop
= 0;
1381 hms_ops
.to_pid_to_exec_file
= NULL
;
1382 hms_ops
.to_core_file_to_sym_file
= NULL
;
1383 hms_ops
.to_stratum
= process_stratum
;
1384 hms_ops
.DONT_USE
= 0;
1385 hms_ops
.to_has_all_memory
= 1;
1386 hms_ops
.to_has_memory
= 1;
1387 hms_ops
.to_has_stack
= 1;
1388 hms_ops
.to_has_registers
= 1;
1389 hms_ops
.to_has_execution
= 1;
1390 hms_ops
.to_sections
= 0;
1391 hms_ops
.to_sections_end
= 0;
1392 hms_ops
.to_magic
= OPS_MAGIC
;
1395 hms_quiet () /* FIXME - this routine can be removed after Dec '94 */
1399 printf_filtered ("Snoop disabled\n");
1401 printf_filtered ("Snoop enabled\n");
1403 printf_filtered ("`snoop' is obsolete, please use `set remotedebug'.\n");
1411 dev_name
= get_word (&s
);
1424 int newrate
= atoi (s
);
1427 if (SERIAL_SETBAUDRATE (desc
, newrate
))
1428 error ("Can't use %d baud\n", newrate
);
1430 printf_filtered ("Checking target is in sync\n");
1432 printf_filtered ("Sending commands to set target to %d\n",
1435 sprintf (buffer
, "tm %d. N 8 1", baudrate
);
1436 hms_write_cr (buffer
);
1440 /***********************************************************************/
1443 hms_drain (args
, fromtty
)
1450 c
= SERIAL_READCHAR (desc
, 1);
1451 if (c
== SERIAL_TIMEOUT
)
1453 if (c
== SERIAL_ERROR
)
1455 if (c
> ' ' && c
< 127)
1456 printf ("%c", c
& 0xff);
1458 printf ("<%x>", c
& 0xff);
1466 add_com ("hms_drain", class_obscure
, hms_drain
,
1467 "Drain pending hms text buffers.");
1473 extern struct cmd_list_element
*cmdlist
;
1474 delete_cmd ("hms-drain", &cmdlist
);
1479 _initialize_remote_hms ()
1482 add_target (&hms_ops
);
1484 add_com ("hms <command>", class_obscure
, hms_com
,
1485 "Send a command to the HMS monitor.");
1487 /* FIXME - hms_quiet and `snoop' can be removed after Dec '94 */
1488 add_com ("snoop", class_obscure
, hms_quiet
,
1489 "Show what commands are going to the monitor (OBSOLETE - see 'set remotedebug')");
1491 add_com ("device", class_obscure
, hms_device
,
1492 "Set the terminal line for HMS communications");
1494 add_com ("speed", class_obscure
, hms_speed
,
1495 "Set the terminal line speed for HMS communications");