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
;
86 static void init_hms_cmds(void)
88 hms_cmds
.flags
= MO_CLR_BREAK_USES_ADDR
| MO_FILL_USES_ADDR
| MO_GETMEM_NEEDS_RANGE
;
89 hms_cmds
.init
= hms_inits
; /* Init strings */
90 hms_cmds
.cont
= "g\r"; /* continue command */
91 hms_cmds
.step
= "s\r"; /* single step */
92 hms_cmds
.stop
= "\003"; /* ^C interrupts the program */
93 hms_cmds
.set_break
= "b %x\r"; /* set a breakpoint */
94 hms_cmds
.clr_break
= "b - %x\r"; /* clear a breakpoint */
95 hms_cmds
.clr_all_break
= "b -\r"; /* clear all breakpoints */
96 hms_cmds
.fill
= "f %x %x %x\r"; /* fill (start end val) */
97 hms_cmds
.setmem
.cmdb
= "m.b %x=%x\r"; /* setmem.cmdb (addr, value) */
98 hms_cmds
.setmem
.cmdw
= "m.w %x=%x\r"; /* setmem.cmdw (addr, value) */
99 hms_cmds
.setmem
.cmdl
= NULL
; /* setmem.cmdl (addr, value) */
100 hms_cmds
.setmem
.cmdll
= NULL
; /* setmem.cmdll (addr, value) */
101 hms_cmds
.setmem
.resp_delim
= NULL
;/* setreg.resp_delim */
102 hms_cmds
.setmem
.term
= NULL
; /* setreg.term */
103 hms_cmds
.setmem
.term_cmd
= NULL
; /* setreg.term_cmd */
104 hms_cmds
.getmem
.cmdb
= "m.b %x %x\r"; /* getmem.cmdb (addr, addr) */
105 hms_cmds
.getmem
.cmdw
= "m.w %x %x\r"; /* getmem.cmdw (addr, addr) */
106 hms_cmds
.getmem
.cmdl
= NULL
; /* getmem.cmdl (addr, addr) */
107 hms_cmds
.getmem
.cmdll
= NULL
; /* getmem.cmdll (addr, addr) */
108 hms_cmds
.getmem
.resp_delim
= ": ";/* getmem.resp_delim */
109 hms_cmds
.getmem
.term
= ">"; /* getmem.term */
110 hms_cmds
.getmem
.term_cmd
= "\003";/* getmem.term_cmd */
111 hms_cmds
.setreg
.cmd
= "r %s=%x\r";/* setreg.cmd (name, value) */
112 hms_cmds
.setreg
.resp_delim
= NULL
;/* setreg.resp_delim */
113 hms_cmds
.setreg
.term
= NULL
; /* setreg.term */
114 hms_cmds
.setreg
.term_cmd
= NULL
; /* setreg.term_cmd */
115 hms_cmds
.getreg
.cmd
= "r %s\r"; /* getreg.cmd (name) */
116 hms_cmds
.getreg
.resp_delim
= " (";/* getreg.resp_delim */
117 hms_cmds
.getreg
.term
= ":"; /* getreg.term */
118 hms_cmds
.getreg
.term_cmd
= "\003";/* getreg.term_cmd */
119 hms_cmds
.dump_registers
= "r\r"; /* dump_registers */
120 hms_cmds
.register_pattern
= "\\(\\w+\\)=\\([0-9a-fA-F]+\\)"; /* register_pattern */
121 hms_cmds
.supply_register
= hms_supply_register
; /* supply_register */
122 hms_cmds
.load_routine
= NULL
; /* load_routine (defaults to SRECs) */
123 hms_cmds
.load
= "tl\r"; /* download command */
124 hms_cmds
.loadresp
= NULL
; /* load response */
125 hms_cmds
.prompt
= ">"; /* monitor command prompt */
126 hms_cmds
.line_term
= "\r"; /* end-of-command delimitor */
127 hms_cmds
.cmd_end
= NULL
; /* optional command terminator */
128 hms_cmds
.target
= &hms_ops
; /* target operations */
129 hms_cmds
.stopbits
= SERIAL_1_STOPBITS
;/* number of stop bits */
130 hms_cmds
.regnames
= hms_regnames
; /* registers names */
131 hms_cmds
.magic
= MONITOR_OPS_MAGIC
; /* magic */
132 } /* init_hms-cmds */
135 hms_open (args
, from_tty
)
139 monitor_open (args
, &hms_cmds
, from_tty
);
142 int write_dos_tick_delay
;
145 _initialize_remote_hms ()
148 init_monitor_ops (&hms_ops
);
150 hms_ops
.to_shortname
= "hms";
151 hms_ops
.to_longname
= "Hitachi Microsystems H8/300 debug monitor";
152 hms_ops
.to_doc
= "Debug via the HMS monitor.\n\
153 Specify the serial device it is connected to (e.g. /dev/ttya).";
154 hms_ops
.to_open
= hms_open
;
155 /* By trial and error I've found that this delay doesn't break things */
156 write_dos_tick_delay
= 1;
157 add_target (&hms_ops
);
161 /* This is kept here because we used to support the H8/500 in this module,
162 and I haven't done the H8/500 yet */
164 #include "inferior.h"
167 #include "gdb_string.h"
173 #include "terminal.h"
177 #include "remote-utils.h"
178 /* External data declarations */
179 extern int stop_soon_quietly
; /* for wait_for_inferior */
181 /* Forward data declarations */
182 extern struct target_ops hms_ops
; /* Forward declaration */
184 /* Forward function declarations */
185 static void hms_fetch_registers ();
186 static int hms_store_registers ();
187 static void hms_close ();
188 static int hms_clear_breakpoints ();
190 extern struct target_ops hms_ops
;
191 static void hms_drain ();
192 static void add_commands ();
193 static void remove_commands ();
195 static int quiet
= 1; /* FIXME - can be removed after Dec '94 */
199 /***********************************************************************
200 * I/O stuff stolen from remote-eb.c
201 ***********************************************************************/
203 static int timeout
= 2;
205 static const char *dev_name
;
207 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
208 hms_open knows that we don't have a file open when the program
211 static int before
= 0xdead;
212 static int is_open
= 0;
213 static int after
= 0xdead;
219 printf ("OUTCH! \n");
222 error ("remote device not open");
229 /* Read a character from the remote system, doing all the fancy
236 buf
= SERIAL_READCHAR (desc
, timeout
);
238 if (buf
== SERIAL_TIMEOUT
)
240 hms_write (".\r\n", 3);
241 error ("Timeout reading from remote system.");
243 if (buf
== SERIAL_ERROR
)
245 error ("Serial port error!");
248 if (!quiet
|| remote_debug
)
249 printf_unfiltered ("%c", buf
);
259 int b
= SERIAL_READCHAR (desc
, 0);
260 if (b
== SERIAL_TIMEOUT
)
270 buf
= SERIAL_READCHAR (desc
, timeout
);
271 if (buf
== SERIAL_TIMEOUT
)
273 if (!quiet
|| remote_debug
)
274 printf_unfiltered ("%c", buf
);
280 /* Keep discarding input from the remote system, until STRING is found.
281 Let the user break out immediately. */
310 /* Keep discarding input until we see the hms prompt.
312 The convention for dealing with the prompt is that you
314 o *then* wait for the prompt.
316 Thus the last thing that a procedure does with the serial line
317 will be an expect_prompt(). Exception: hms_resume does not
318 wait for the prompt, because the terminal is being handed over
319 to the inferior. However, the next thing which happens after that
320 is a hms_wait which does wait for the prompt.
321 Note that this includes abnormal exit, e.g. error(). This is
322 necessary to prevent getting into states from which we can't
330 /* Get a hex digit from the remote system & return its value.
331 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
333 get_hex_digit (ignore_space
)
341 if (ch
>= '0' && ch
<= '9')
343 else if (ch
>= 'A' && ch
<= 'F')
344 return ch
- 'A' + 10;
345 else if (ch
>= 'a' && ch
<= 'f')
346 return ch
- 'a' + 10;
347 else if (ch
== ' ' && ignore_space
)
352 error ("Invalid hex digit from remote system.");
357 /* Get a byte from hms_desc and put it in *BYT. Accept any number
365 val
= get_hex_digit (1) << 4;
366 val
|= get_hex_digit (0);
370 /* Read a 32-bit hex word from the hms, preceded by a space */
378 for (j
= 0; j
< 8; j
++)
379 val
= (val
<< 4) + get_hex_digit (j
== 0);
383 /* Called when SIGALRM signal sent due to alarm() timeout. */
385 /* Number of SIGTRAPs we need to simulate. That is, the next
386 NEED_ARTIFICIAL_TRAP calls to hms_wait should just return
387 SIGTRAP without actually waiting for anything. */
389 static int need_artificial_trap
= 0;
392 hms_kill (arg
, from_tty
)
399 /* This is called not only when we first attach, but also when the
400 user types "run" after having attached. */
402 hms_create_inferior (execfile
, args
, env
)
411 error ("Can't pass arguments to remote hms process.");
413 if (execfile
== 0 || exec_bfd
== 0)
414 error ("No executable file specified");
416 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
419 hms_kill (NULL
, NULL
);
420 hms_clear_breakpoints ();
421 init_wait_for_inferior ();
425 insert_breakpoints (); /* Needed to get correct instruction in cache */
426 proceed (entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
429 /* Open a connection to a remote debugger.
430 NAME is the filename used for communication, then a space,
438 while (*s
&& !isspace (*s
))
459 while (*s
&& !isspace (*s
))
465 copy
= xmalloc (len
+ 1);
466 memcpy (copy
, word
, len
);
472 static int baudrate
= 9600;
479 /* Put this port into NORMAL mode, send the 'normal' character */
481 hms_write ("\001", 1); /* Control A */
482 hms_write ("\r\n", 2); /* Cr */
486 ok
= SERIAL_READCHAR (desc
, timeout
);
493 if (readchar_nofail () == 'r')
496 /* Not the right baudrate, or the board's not on */
502 if (!SERIAL_SETBAUDRATE (desc
, baudrate
))
503 error ("Can't set baudrate");
508 /* Close out all files and local state before this target loses control. */
514 /* Clear any break points */
516 hms_clear_breakpoints ();
517 sleep (1); /* Let any output make it all the way back */
520 SERIAL_WRITE (desc
, "R\r\n", 3);
526 /* Terminate the open connection to the remote debugger. Use this
527 when you want to detach and do something else with your gdb. */ void
528 hms_detach (args
, from_tty
)
534 hms_clear_breakpoints ();
537 pop_target (); /* calls hms_close to do the real work
540 printf_filtered ("Ending remote %s debugging\n",
544 /* Tell the remote machine to resume. */
547 hms_resume (pid
, step
, sig
)
557 /* Force the next hms_wait to return a trap. Not doing anything
558 about I/O from the target means that the user has to type "continue"
559 to see any. FIXME, this should be fixed. */
560 need_artificial_trap
= 1;
569 /* Wait until the remote machine stops, then return, storing status in
570 STATUS just as `wait' would. */
573 hms_wait (pid
, status
)
575 struct target_waitstatus
*status
;
577 /* Strings to look for. '?' means match any single character. Note
578 that with the algorithm we use, the initial character of the string
579 cannot recur in the string, or we will not find some cases of the
580 string in the input. */
582 static char bpt
[] = "At breakpoint:";
584 /* It would be tempting to look for "\n[__exit + 0x8]\n" but that
585 requires loading symbols with "yc i" and even if we did do that we
586 don't know that the file has symbols. */
587 static char exitmsg
[] = "HMS>";
591 /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars.
595 /* Current position in swallowed. */
596 char *swallowed_p
= swallowed
;
600 int old_timeout
= timeout
;
602 old_immediate_quit
= immediate_quit
;
603 int swallowed_cr
= 0;
605 status
->kind
= TARGET_WAITKIND_EXITED
;
606 status
->value
.integer
= 0;
608 if (need_artificial_trap
!= 0)
611 TARGET_WAITKIND_STOPPED
;
612 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
613 need_artificial_trap
--;
617 timeout
= 5; /* Don't time out for a while - user program is running.
619 immediate_quit
= 1; /* Helps ability to QUIT */
622 QUIT
; /* Let user quit and leave process running */
639 (ch
== *ep
|| *ep
== '?')
659 /* Print out any characters which have been swallowed. */
660 for (p
= swallowed
; p
< swallowed_p
; ++p
)
661 putchar_unfiltered (*p
);
662 swallowed_p
= swallowed
;
664 if ((ch
!= '\r' && ch
!= '\n') || swallowed_cr
> 10)
666 putchar_unfiltered (ch
);
675 status
->kind
= TARGET_WAITKIND_STOPPED
;
676 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
681 status
->kind
= TARGET_WAITKIND_EXITED
;
682 status
->value
.integer
=
686 timeout
= old_timeout
;
687 immediate_quit
= old_immediate_quit
;
692 /* Return the name of register number REGNO in the form input and
695 Returns a pointer to a static buffer containing the answer. */
706 /* Read the remote registers. */
709 gethex (length
, start
, ok
)
719 if (*start
>= 'a' && *start
<= 'f')
721 result
+= *start
- 'a' + 10;
723 else if (*start
>= 'A' &&
726 result
+= *start
- 'A' + 10;
729 (*start
>= '0' && *start
<= '9')
731 result
+= *start
- '0';
741 timed_read (buf
, n
, timeout
)
768 SERIAL_WRITE (desc
, a
, l
);
770 if (!quiet
|| remote_debug
)
772 printf_unfiltered ("<");
773 for (i
= 0; i
< l
; i
++)
775 printf_unfiltered ("%c", a
[i
]);
777 printf_unfiltered (">");
784 hms_write (s
, strlen (s
));
785 hms_write ("\r\n", 2);
788 #ifdef GDB_TARGET_IS_H8500
790 /* H8/500 monitor reg dump looks like:
793 PC:8000 SR:070C .7NZ.. CP:00 DP:00 EP:00 TP:00 BR:00
794 R0-R7: FF5A 0001 F4FE F500 0000 F528 F528 F4EE
800 supply_val (n
, size
, ptr
, segptr
)
811 raw
[0] = gethex (2, ptr
, &ok
);
812 raw
[1] = gethex (2, ptr
+ 2, &ok
);
813 supply_register (n
, raw
);
816 raw
[0] = gethex (2, ptr
, &ok
);
817 supply_register (n
, raw
);
821 int v
= gethex (4, ptr
, &ok
);
822 v
|= gethex (2, segptr
, &ok
) << 16;
824 raw
[1] = (v
>> 16) & 0xff;
825 raw
[2] = (v
>> 8) & 0xff;
826 raw
[3] = (v
>> 0) & 0xff;
827 supply_register (n
, raw
);
833 hms_fetch_register (dummy
)
836 #define REGREPLY_SIZE 108
837 char linebuf
[REGREPLY_SIZE
+ 1];
842 LONGEST reg
[NUM_REGS
];
850 s
= timed_read (linebuf
+ 1, REGREPLY_SIZE
, 1);
852 linebuf
[REGREPLY_SIZE
] = 0;
854 if (linebuf
[3] == 'P' &&
857 linebuf
[105] == 'H' &&
858 linebuf
[106] == 'M' &&
865 -------1---------2---------3---------4---------5-----
866 345678901234567890123456789012345678901234567890123456
867 PC:8000 SR:070C .7NZ.. CP:00 DP:00 EP:00 TP:00 BR:00**
868 ---6---------7---------8---------9--------10----
869 789012345678901234567890123456789012345678901234
870 R0-R7: FF5A 0001 F4FE F500 0000 F528 F528 F4EE**
878 supply_val (PC_REGNUM
, 4, linebuf
+ 6, linebuf
+ 29);
880 supply_val (CCR_REGNUM
, 2, linebuf
+ 14);
881 supply_val (SEG_C_REGNUM
, 1, linebuf
+ 29);
882 supply_val (SEG_D_REGNUM
, 1, linebuf
+ 35);
883 supply_val (SEG_E_REGNUM
, 1, linebuf
+ 41);
884 supply_val (SEG_T_REGNUM
, 1, linebuf
+ 47);
885 for (i
= 0; i
< 8; i
++)
892 char *src
= linebuf
+ 64 + 5 * i
;
893 char *segsrc
= linebuf
+ sr
[i
];
894 supply_val (R0_REGNUM
+ i
, 2, src
);
895 supply_val (PR0_REGNUM
+ i
, 4, src
, segsrc
);
908 #ifdef GDB_TARGET_IS_H8300
910 hms_fetch_register (dummy
)
913 #define REGREPLY_SIZE 79
914 char linebuf
[REGREPLY_SIZE
+ 1];
919 ULONGEST reg
[NUM_REGS
];
927 s
= timed_read (linebuf
, 1, 1);
929 while (linebuf
[0] != 'r')
930 s
= timed_read (linebuf
, 1, 1);
932 s
= timed_read (linebuf
+ 1, REGREPLY_SIZE
- 1, 1);
934 linebuf
[REGREPLY_SIZE
] = 0;
936 if (linebuf
[0] == 'r' &&
940 linebuf
[75] == 'H' &&
941 linebuf
[76] == 'M' &&
945 PC=XXXX CCR=XX:XXXXXXXX R0-R7= XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX
946 5436789012345678901234567890123456789012345678901234567890123456789012
951 reg
[PC_REGNUM
] = gethex (4, linebuf
+ 6, &gottok
);
952 reg
[CCR_REGNUM
] = gethex (2, linebuf
+ 15, &gottok
);
953 for (i
= 0; i
< 8; i
++)
955 reg
[i
] = gethex (4, linebuf
+ 34 + 5 * i
, &gottok
);
960 for (i
= 0; i
< NUM_REGS
; i
++)
965 swapped
[0] = (reg
[i
]) >> 8;
967 supply_register (i
, swapped
);
971 /* Store register REGNO, or all if REGNO == -1.
972 Return errno value. */
974 hms_store_register (regno
)
979 for (regno
= 0; regno
< NUM_REGS
; regno
++)
981 hms_store_register (regno
);
986 char *name
= get_reg_name (regno
);
988 /* Some regs dont really exist */
989 if (!(name
[0] == 'p' && name
[1] == 'r')
990 && !(name
[0] == 'c' && name
[1] == 'y')
991 && !(name
[0] == 't' && name
[1] == 'i')
992 && !(name
[0] == 'i' && name
[1] == 'n'))
994 sprintf (buffer
, "r %s=%x", name
, read_register (regno
));
995 hms_write_cr (buffer
);
1002 /* Get ready to modify the registers array. On machines which store
1003 individual registers, this doesn't need to do anything. On machines
1004 which store all the registers in one fell swoop, this makes sure
1005 that registers contains all the registers from the program being
1009 hms_prepare_to_store ()
1011 /* Do nothing, since we can store individual regs */
1015 translate_addr (addr
)
1025 hms_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
1030 struct target_ops
*target
; /* ignored */
1037 hms_write_inferior_memory (memaddr
, myaddr
, len
)
1039 unsigned char *myaddr
;
1055 thisgo
= len
- done
;
1059 sprintf (ptr
, "M.B %4x =", memaddr
+ done
);
1061 for (idx
= 0; idx
< thisgo
; idx
++)
1063 sprintf (ptr
, "%2x ", myaddr
[idx
+ done
]);
1066 hms_write_cr (buffer
);
1075 char *file
= "nothing";
1078 file
= bfd_get_filename (exec_bfd
);
1082 printf_filtered ("\tAttached to DOS asynctsr and running program %s\n", file
);
1084 printf_filtered ("\tAttached to %s at %d baud and running program %s\n", dev_name
, baudrate
, file
);
1086 printf_filtered ("\ton an H8/300 processor.\n");
1089 /* Copy LEN bytes of data from debugger memory at MYADDR
1090 to inferior's memory at MEMADDR. Returns errno value.
1091 * sb/sh instructions don't work on unaligned addresses, when TU=1.
1094 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
1095 at debugger address MYADDR. Returns errno value. */
1097 hms_read_inferior_memory (memaddr
, myaddr
, len
)
1102 /* Align to nearest low 16 bits */
1105 CORE_ADDR start
= memaddr
;
1106 CORE_ADDR end
= memaddr
+ len
- 1;
1111 AAAA: XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX '................'
1112 012345678901234567890123456789012345678901234567890123456789012345
1122 sprintf (buffer
, "m %4x %4x", start
& 0xffff, end
& 0xffff);
1125 hms_write_cr (buffer
);
1126 /* drop the echo and newline */
1127 for (i
= 0; i
< 13; i
++)
1130 /* Grab the lines as they come out and fill the area */
1141 buffer
[0] = readchar ();
1142 while (buffer
[0] == '\r'
1143 || buffer
[0] == '\n')
1144 buffer
[0] = readchar ();
1146 if (buffer
[0] == 'M')
1149 for (i
= 1; i
< 50; i
++)
1151 buffer
[i
] = readchar ();
1153 /* sometimes we loose characters in the ascii representation of the
1154 data. I don't know where. So just scan for the end of line */
1156 while (i
!= '\n' && i
!= '\r')
1159 /* Now parse the line */
1161 addr
= gethex (4, buffer
, &ok
);
1163 for (p
= 0; p
< 16; p
+= 2)
1165 byte
[p
] = gethex (2, buffer
+ idx
, &ok
);
1166 byte
[p
+ 1] = gethex (2, buffer
+ idx
+ 2, &ok
);
1170 for (p
= 0; p
< 16; p
++)
1172 if (addr
+ p
>= memaddr
&&
1173 addr
+ p
< memaddr
+ len
)
1175 myaddr
[(addr
+ p
) - memaddr
] = byte
[p
];
1181 #ifdef GDB_TARGET_IS_H8500
1184 #ifdef GDB_TARGET_IS_H8300
1195 #define MAX_BREAKS 16
1196 static int num_brkpts
= 0;
1198 hms_insert_breakpoint (addr
, save
)
1200 char *save
; /* Throw away, let hms save instructions */
1204 if (num_brkpts
< MAX_BREAKS
)
1209 sprintf (buffer
, "b %x", addr
& 0xffff);
1210 hms_write_cr (buffer
);
1216 fprintf_filtered (gdb_stderr
,
1217 "Too many break points, break point not installed\n");
1223 hms_remove_breakpoint (addr
, save
)
1225 char *save
; /* Throw away, let hms save instructions */
1232 sprintf (buffer
, "b - %x", addr
& 0xffff);
1233 hms_write_cr (buffer
);
1240 /* Clear the hmss notion of what the break points are */
1242 hms_clear_breakpoints ()
1247 hms_write_cr ("b -");
1255 hms_clear_breakpoints ();
1256 unpush_target (&hms_ops
);
1257 generic_mourn_inferior ();
1260 /* Put a command string, in args, out to the hms. The hms is assumed to
1261 be in raw mode, all writing/reading done through desc.
1262 Ouput from the hms is placed on the users terminal until the
1263 prompt from the hms is seen.
1264 FIXME: Can't handle commands that take input. */
1267 hms_com (args
, fromtty
)
1276 /* Clear all input so only command relative output is displayed */
1278 hms_write_cr (args
);
1279 /* hms_write ("\030", 1); */
1284 hms_open (name
, from_tty
)
1297 dev_name
= strdup (name
);
1299 if (!(desc
= SERIAL_OPEN (dev_name
)))
1300 perror_with_name ((char *) dev_name
);
1304 push_target (&hms_ops
);
1305 dcache_ptr
= dcache_init (hms_read_inferior_memory
,
1306 hms_write_inferior_memory
);
1308 /* Hello? Are you there? */
1309 SERIAL_WRITE (desc
, "\r\n", 2);
1312 /* Clear any break points */
1313 hms_clear_breakpoints ();
1315 printf_filtered ("Connected to remote board running HMS monitor.\n");
1320 /* Define the target subroutine names */
1322 struct target_ops hms_ops
;
1323 static void init_hms_ops(void)
1325 hms_ops
.to_shortname
= "hms";
1326 hms_ops
.to_longname
= "Remote HMS monitor";
1327 hms_ops
.to_doc
= "Use the H8 evaluation board running the HMS monitor connected\n\
1329 hms_ops
.to_open
= hms_open
;
1330 hms_ops
.to_close
= hms_close
;
1331 hms_ops
.to_attach
= 0;
1332 hms_ops
.to_post_attach
= NULL
;
1333 hms_ops
.to_require_attach
= NULL
;
1334 hms_ops
.to_detach
= hms_detach
;
1335 hms_ops
.to_require_detach
= NULL
;
1336 hms_ops
.to_resume
= hms_resume
;
1337 hms_ops
.to_wait
= hms_wait
;
1338 hms_ops
.to_post_wait
= NULL
;
1339 hms_ops
.to_fetch_registers
= hms_fetch_register
;
1340 hms_ops
.to_store_registers
= hms_store_register
;
1341 hms_ops
.to_prepare_to_store
= hms_prepare_to_store
;
1342 hms_ops
.to_xfer_memory
= hms_xfer_inferior_memory
;
1343 hms_ops
.to_files_info
= hms_files_info
;
1344 hms_ops
.to_insert_breakpoint
= hms_insert_breakpoint
;
1345 hms_ops
.to_remove_breakpoint
= hms_remove_breakpoint
;
1346 hms_ops
.to_terminal_init
= 0;
1347 hms_ops
.to_terminal_inferior
= 0;
1348 hms_ops
.to_terminal_ours_for_output
= 0;
1349 hms_ops
.to_terminal_ours
= 0;
1350 hms_ops
.to_terminal_info
= 0;
1351 hms_ops
.to_kill
= hms_kill
;
1352 hms_ops
.to_load
= generic_load
;
1353 hms_ops
.to_lookup_symbol
= 0;
1354 hms_ops
.to_create_inferior
= hms_create_inferior
;
1355 hms_ops
.to_post_startup_inferior
= NULL
;
1356 hms_ops
.to_acknowledge_created_inferior
= NULL
;
1357 hms_ops
.to_clone_and_follow_inferior
= NULL
;
1358 hms_ops
.to_post_follow_inferior_by_clone
= NULL
;
1359 hms_ops
.to_insert_fork_catchpoint
= NULL
;
1360 hms_ops
.to_remove_fork_catchpoint
= NULL
;
1361 hms_ops
.to_insert_vfork_catchpoint
= NULL
;
1362 hms_ops
.to_remove_vfork_catchpoint
= NULL
;
1363 hms_ops
.to_has_forked
= NULL
;
1364 hms_ops
.to_has_vforked
= NULL
;
1365 hms_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
1366 hms_ops
.to_post_follow_vfork
= NULL
;
1367 hms_ops
.to_insert_exec_catchpoint
= NULL
;
1368 hms_ops
.to_remove_exec_catchpoint
= NULL
;
1369 hms_ops
.to_has_execd
= NULL
;
1370 hms_ops
.to_reported_exec_events_per_exec_call
= NULL
;
1371 hms_ops
.to_has_exited
= NULL
;
1372 hms_ops
.to_mourn_inferior
= hms_mourn
;
1373 hms_ops
.to_can_run
= 0;
1374 hms_ops
.to_notice_signals
= 0;
1375 hms_ops
.to_thread_alive
= 0;
1376 hms_ops
.to_stop
= 0;
1377 hms_ops
.to_pid_to_exec_file
= NULL
;
1378 hms_ops
.to_core_file_to_sym_file
= NULL
;
1379 hms_ops
.to_stratum
= process_stratum
;
1380 hms_ops
.DONT_USE
= 0;
1381 hms_ops
.to_has_all_memory
= 1;
1382 hms_ops
.to_has_memory
= 1;
1383 hms_ops
.to_has_stack
= 1;
1384 hms_ops
.to_has_registers
= 1;
1385 hms_ops
.to_has_execution
= 1;
1386 hms_ops
.to_sections
= 0;
1387 hms_ops
.to_sections_end
= 0;
1388 hms_ops
.to_magic
= OPS_MAGIC
;
1391 hms_quiet () /* FIXME - this routine can be removed after Dec '94 */
1395 printf_filtered ("Snoop disabled\n");
1397 printf_filtered ("Snoop enabled\n");
1399 printf_filtered ("`snoop' is obsolete, please use `set remotedebug'.\n");
1407 dev_name
= get_word (&s
);
1420 int newrate
= atoi (s
);
1423 if (SERIAL_SETBAUDRATE (desc
, newrate
))
1424 error ("Can't use %d baud\n", newrate
);
1426 printf_filtered ("Checking target is in sync\n");
1428 printf_filtered ("Sending commands to set target to %d\n",
1431 sprintf (buffer
, "tm %d. N 8 1", baudrate
);
1432 hms_write_cr (buffer
);
1436 /***********************************************************************/
1439 hms_drain (args
, fromtty
)
1446 c
= SERIAL_READCHAR (desc
, 1);
1447 if (c
== SERIAL_TIMEOUT
)
1449 if (c
== SERIAL_ERROR
)
1451 if (c
> ' ' && c
< 127)
1452 printf ("%c", c
& 0xff);
1454 printf ("<%x>", c
& 0xff);
1462 add_com ("hms_drain", class_obscure
, hms_drain
,
1463 "Drain pending hms text buffers.");
1469 extern struct cmd_list_element
*cmdlist
;
1470 delete_cmd ("hms-drain", &cmdlist
);
1475 _initialize_remote_hms ()
1478 add_target (&hms_ops
);
1480 add_com ("hms <command>", class_obscure
, hms_com
,
1481 "Send a command to the HMS monitor.");
1483 /* FIXME - hms_quiet and `snoop' can be removed after Dec '94 */
1484 add_com ("snoop", class_obscure
, hms_quiet
,
1485 "Show what commands are going to the monitor (OBSOLETE - see 'set remotedebug')");
1487 add_com ("device", class_obscure
, hms_device
,
1488 "Set the terminal line for HMS communications");
1490 add_com ("speed", class_obscure
, hms_speed
,
1491 "Set the terminal line speed for HMS communications");