X-Git-Url: https://repo.jachan.dev/binutils.git/blobdiff_plain/7baea9460866303161d1598eddb93a936973ef1d..8b237a8965b9c4f4c0ec0bb13571b45fef6ed8ce:/gdb/remote-hms.c diff --git a/gdb/remote-hms.c b/gdb/remote-hms.c index 371fb389b2..328fc01965 100644 --- a/gdb/remote-hms.c +++ b/gdb/remote-hms.c @@ -1,5 +1,5 @@ /* Remote debugging interface for Hitachi HMS Monitor Version 1.0 - Copyright 1992, 1993, 1994, 1995 Free Software Foundation, Inc. + Copyright 1995 Free Software Foundation, Inc. Contributed by Cygnus Support. Written by Steve Chamberlain (sac@cygnus.com). @@ -17,13 +17,157 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ #include "defs.h" +#include "gdbcore.h" +#include "target.h" +#include "monitor.h" +#include "serial.h" + +static void hms_open PARAMS ((char *args, int from_tty)); +static void +hms_supply_register (regname, regnamelen, val, vallen) + char *regname; + int regnamelen; + char *val; + int vallen; +{ + int regno; + + if (regnamelen != 2) + return; + if (regname[0] != 'P') + return; + /* We scan off all the registers in one go */ + + val = monitor_supply_register (PC_REGNUM, val); + /* Skip the ccr string */ + while (*val != '=' && *val) + val++; + + val = monitor_supply_register (CCR_REGNUM, val + 1); + + /* Skip up to rest of regs */ + while (*val != '=' && *val) + val++; + + for (regno = 0; regno < 7; regno++) + { + val = monitor_supply_register (regno, val + 1); + } +} + +/* + * This array of registers needs to match the indexes used by GDB. The + * whole reason this exists is because the various ROM monitors use + * different names than GDB does, and don't support all the + * registers either. So, typing "info reg sp" becomes a "r30". + */ + +static char *hms_regnames[NUM_REGS] = +{ + "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", "CCR", "PC" +}; + +/* + * Define the monitor command strings. Since these are passed directly + * through to a printf style function, we need can include formatting + * strings. We also need a CR or LF on the end. + */ + +static struct target_ops hms_ops; + +static char *hms_inits[] = +{"\003", /* Resets the prompt, and clears repeated cmds */ + NULL}; + +static struct monitor_ops hms_cmds; + +static void +init_hms_cmds (void) +{ + hms_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_FILL_USES_ADDR | MO_GETMEM_NEEDS_RANGE; + hms_cmds.init = hms_inits; /* Init strings */ + hms_cmds.cont = "g\r"; /* continue command */ + hms_cmds.step = "s\r"; /* single step */ + hms_cmds.stop = "\003"; /* ^C interrupts the program */ + hms_cmds.set_break = "b %x\r"; /* set a breakpoint */ + hms_cmds.clr_break = "b - %x\r"; /* clear a breakpoint */ + hms_cmds.clr_all_break = "b -\r"; /* clear all breakpoints */ + hms_cmds.fill = "f %x %x %x\r"; /* fill (start end val) */ + hms_cmds.setmem.cmdb = "m.b %x=%x\r"; /* setmem.cmdb (addr, value) */ + hms_cmds.setmem.cmdw = "m.w %x=%x\r"; /* setmem.cmdw (addr, value) */ + hms_cmds.setmem.cmdl = NULL; /* setmem.cmdl (addr, value) */ + hms_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */ + hms_cmds.setmem.resp_delim = NULL; /* setreg.resp_delim */ + hms_cmds.setmem.term = NULL; /* setreg.term */ + hms_cmds.setmem.term_cmd = NULL; /* setreg.term_cmd */ + hms_cmds.getmem.cmdb = "m.b %x %x\r"; /* getmem.cmdb (addr, addr) */ + hms_cmds.getmem.cmdw = "m.w %x %x\r"; /* getmem.cmdw (addr, addr) */ + hms_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, addr) */ + hms_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, addr) */ + hms_cmds.getmem.resp_delim = ": "; /* getmem.resp_delim */ + hms_cmds.getmem.term = ">"; /* getmem.term */ + hms_cmds.getmem.term_cmd = "\003"; /* getmem.term_cmd */ + hms_cmds.setreg.cmd = "r %s=%x\r"; /* setreg.cmd (name, value) */ + hms_cmds.setreg.resp_delim = NULL; /* setreg.resp_delim */ + hms_cmds.setreg.term = NULL; /* setreg.term */ + hms_cmds.setreg.term_cmd = NULL; /* setreg.term_cmd */ + hms_cmds.getreg.cmd = "r %s\r"; /* getreg.cmd (name) */ + hms_cmds.getreg.resp_delim = " ("; /* getreg.resp_delim */ + hms_cmds.getreg.term = ":"; /* getreg.term */ + hms_cmds.getreg.term_cmd = "\003"; /* getreg.term_cmd */ + hms_cmds.dump_registers = "r\r"; /* dump_registers */ + hms_cmds.register_pattern = "\\(\\w+\\)=\\([0-9a-fA-F]+\\)"; /* register_pattern */ + hms_cmds.supply_register = hms_supply_register; /* supply_register */ + hms_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */ + hms_cmds.load = "tl\r"; /* download command */ + hms_cmds.loadresp = NULL; /* load response */ + hms_cmds.prompt = ">"; /* monitor command prompt */ + hms_cmds.line_term = "\r"; /* end-of-command delimitor */ + hms_cmds.cmd_end = NULL; /* optional command terminator */ + hms_cmds.target = &hms_ops; /* target operations */ + hms_cmds.stopbits = SERIAL_1_STOPBITS; /* number of stop bits */ + hms_cmds.regnames = hms_regnames; /* registers names */ + hms_cmds.magic = MONITOR_OPS_MAGIC; /* magic */ +} /* init_hms-cmds */ + +static void +hms_open (args, from_tty) + char *args; + int from_tty; +{ + monitor_open (args, &hms_cmds, from_tty); +} + +int write_dos_tick_delay; + +void +_initialize_remote_hms () +{ + init_hms_cmds (); + init_monitor_ops (&hms_ops); + + hms_ops.to_shortname = "hms"; + hms_ops.to_longname = "Hitachi Microsystems H8/300 debug monitor"; + hms_ops.to_doc = "Debug via the HMS monitor.\n\ +Specify the serial device it is connected to (e.g. /dev/ttya)."; + hms_ops.to_open = hms_open; + /* By trial and error I've found that this delay doesn't break things */ + write_dos_tick_delay = 1; + add_target (&hms_ops); +} + +#if 0 +/* This is kept here because we used to support the H8/500 in this module, + and I haven't done the H8/500 yet */ +#include "defs.h" #include "inferior.h" #include "wait.h" #include "value.h" -#include +#include "gdb_string.h" #include #include #include @@ -53,8 +197,6 @@ static void remove_commands (); static int quiet = 1; /* FIXME - can be removed after Dec '94 */ -static DCACHE *remote_dcache; -serial_t desc; /*********************************************************************** @@ -112,7 +254,7 @@ readchar () return buf & 0x7f; } -static void +static void flush () { while (1) @@ -272,7 +414,7 @@ hms_create_inferior (execfile, args, env) error ("Can't pass arguments to remote hms process."); if (execfile == 0 || exec_bfd == 0) - error ("No exec file specified"); + error ("No executable file specified"); entry_pt = (int) bfd_get_start_address (exec_bfd); check_open (); @@ -410,8 +552,6 @@ hms_resume (pid, step, sig) enum target_signal sig; { - dcache_flush (remote_dcache); - if (step) { hms_write_cr ("s"); @@ -779,7 +919,7 @@ hms_fetch_register (dummy) int s; int gottok; - unsigned LONGEST reg[NUM_REGS]; + ULONGEST reg[NUM_REGS]; check_open (); @@ -883,26 +1023,6 @@ translate_addr (addr) } -/* Read a word from remote address ADDR and return it. - * This goes through the data cache. - */ -int -hms_fetch_word (addr) - CORE_ADDR addr; -{ - return dcache_fetch (remote_dcache, addr); -} - -/* Write a word WORD into remote address ADDR. - This goes through the data cache. */ - -void -hms_store_word (addr, word) - CORE_ADDR addr; - int word; -{ - dcache_poke (remote_dcache, addr, word); -} int hms_xfer_inferior_memory (memaddr, myaddr, len, write, target) @@ -912,73 +1032,6 @@ hms_xfer_inferior_memory (memaddr, myaddr, len, write, target) int write; struct target_ops *target; /* ignored */ { - register int i; - - /* Round starting address down to longword boundary. */ - register CORE_ADDR addr; - - /* Round ending address up; get number of longwords that makes. */ - register int count; - - /* Allocate buffer of that many longwords. */ - register int *buffer; - - memaddr &= 0xffff; - addr = memaddr & -sizeof (int); - count = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int); - - buffer = (int *) alloca (count * sizeof (int)); - - if (write) - { - /* Fill start and end extra bytes of buffer with existing memory data. */ - - if (addr != memaddr || len < (int) sizeof (int)) - { - /* Need part of initial word -- fetch it. */ - buffer[0] = hms_fetch_word (addr); - } - - if (count > 1) /* FIXME, avoid if even boundary */ - { - buffer[count - 1] - = hms_fetch_word (addr + (count - 1) * sizeof (int)); - } - - /* Copy data to be written over corresponding part of buffer */ - - memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len); - - /* Write the entire buffer. */ - - for (i = 0; i < count; i++, addr += sizeof (int)) - { - errno = 0; - hms_store_word (addr, buffer[i]); - if (errno) - { - return 0; - } - - } - } - else - { - /* Read all the longwords */ - for (i = 0; i < count; i++, addr += sizeof (int)) - { - errno = 0; - buffer[i] = hms_fetch_word (addr); - if (errno) - { - return 0; - } - QUIT; - } - - /* Copy appropriate bytes out of the buffer. */ - memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len); - } return len; } @@ -1252,9 +1305,9 @@ hms_open (name, from_tty) SERIAL_RAW (desc); is_open = 1; push_target (&hms_ops); - dcache_init (hms_read_inferior_memory, - hms_write_inferior_memory); - + dcache_ptr = dcache_init (hms_read_inferior_memory, + hms_write_inferior_memory); + remote_dcache = 1; /* Hello? Are you there? */ SERIAL_WRITE (desc, "\r\n", 2); expect_prompt (); @@ -1269,32 +1322,75 @@ hms_open (name, from_tty) /* Define the target subroutine names */ -struct target_ops hms_ops = +struct target_ops hms_ops; + +static void +init_hms_ops (void) { - "hms", "Remote HMS monitor", - "Use the H8 evaluation board running the HMS monitor connected\n\ -by a serial line.", - - hms_open, hms_close, - 0, hms_detach, hms_resume, hms_wait, /* attach */ - hms_fetch_register, hms_store_register, - hms_prepare_to_store, - hms_xfer_inferior_memory, - hms_files_info, - hms_insert_breakpoint, hms_remove_breakpoint, /* Breakpoints */ - 0, 0, 0, 0, 0, /* Terminal handling */ - hms_kill, /* FIXME, kill */ - gr_load_image, - 0, /* lookup_symbol */ - hms_create_inferior, /* create_inferior */ - hms_mourn, /* mourn_inferior FIXME */ - 0, /* can_run */ - 0, /* notice_signals */ - 0, /* to_stop */ - process_stratum, 0, /* next */ - 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */ - 0, 0, /* Section pointers */ - OPS_MAGIC, /* Always the last thing */ + hms_ops.to_shortname = "hms"; + hms_ops.to_longname = "Remote HMS monitor"; + hms_ops.to_doc = "Use the H8 evaluation board running the HMS monitor connected\n\ +by a serial line."; + hms_ops.to_open = hms_open; + hms_ops.to_close = hms_close; + hms_ops.to_attach = 0; + hms_ops.to_post_attach = NULL; + hms_ops.to_require_attach = NULL; + hms_ops.to_detach = hms_detach; + hms_ops.to_require_detach = NULL; + hms_ops.to_resume = hms_resume; + hms_ops.to_wait = hms_wait; + hms_ops.to_post_wait = NULL; + hms_ops.to_fetch_registers = hms_fetch_register; + hms_ops.to_store_registers = hms_store_register; + hms_ops.to_prepare_to_store = hms_prepare_to_store; + hms_ops.to_xfer_memory = hms_xfer_inferior_memory; + hms_ops.to_files_info = hms_files_info; + hms_ops.to_insert_breakpoint = hms_insert_breakpoint; + hms_ops.to_remove_breakpoint = hms_remove_breakpoint; + hms_ops.to_terminal_init = 0; + hms_ops.to_terminal_inferior = 0; + hms_ops.to_terminal_ours_for_output = 0; + hms_ops.to_terminal_ours = 0; + hms_ops.to_terminal_info = 0; + hms_ops.to_kill = hms_kill; + hms_ops.to_load = generic_load; + hms_ops.to_lookup_symbol = 0; + hms_ops.to_create_inferior = hms_create_inferior; + hms_ops.to_post_startup_inferior = NULL; + hms_ops.to_acknowledge_created_inferior = NULL; + hms_ops.to_clone_and_follow_inferior = NULL; + hms_ops.to_post_follow_inferior_by_clone = NULL; + hms_ops.to_insert_fork_catchpoint = NULL; + hms_ops.to_remove_fork_catchpoint = NULL; + hms_ops.to_insert_vfork_catchpoint = NULL; + hms_ops.to_remove_vfork_catchpoint = NULL; + hms_ops.to_has_forked = NULL; + hms_ops.to_has_vforked = NULL; + hms_ops.to_can_follow_vfork_prior_to_exec = NULL; + hms_ops.to_post_follow_vfork = NULL; + hms_ops.to_insert_exec_catchpoint = NULL; + hms_ops.to_remove_exec_catchpoint = NULL; + hms_ops.to_has_execd = NULL; + hms_ops.to_reported_exec_events_per_exec_call = NULL; + hms_ops.to_has_exited = NULL; + hms_ops.to_mourn_inferior = hms_mourn; + hms_ops.to_can_run = 0; + hms_ops.to_notice_signals = 0; + hms_ops.to_thread_alive = 0; + hms_ops.to_stop = 0; + hms_ops.to_pid_to_exec_file = NULL; + hms_ops.to_core_file_to_sym_file = NULL; + hms_ops.to_stratum = process_stratum; + hms_ops.DONT_USE = 0; + hms_ops.to_has_all_memory = 1; + hms_ops.to_has_memory = 1; + hms_ops.to_has_stack = 1; + hms_ops.to_has_registers = 1; + hms_ops.to_has_execution = 1; + hms_ops.to_sections = 0; + hms_ops.to_sections_end = 0; + hms_ops.to_magic = OPS_MAGIC; }; hms_quiet () /* FIXME - this routine can be removed after Dec '94 */ @@ -1383,6 +1479,7 @@ remove_commands () void _initialize_remote_hms () { + init_hms_ops (); add_target (&hms_ops); add_com ("hms ", class_obscure, hms_com, @@ -1400,3 +1497,4 @@ _initialize_remote_hms () dev_name = NULL; } +#endif