diff options
| author | Andrew Cagney <cagney@redhat.com> | 2003-07-21 18:56:05 +0000 |
|---|---|---|
| committer | Andrew Cagney <cagney@redhat.com> | 2003-07-21 18:56:05 +0000 |
| commit | d95a89033d01d8f5132a8a4f79dc4c2d9deb54b1 (patch) | |
| tree | 36ed9eb488dded30b82a07455f99064b8b248d28 | |
| parent | 796f2a93d192aa7d2c8d6a1ab541581b7b874740 (diff) | |
| download | gdb-d95a89033d01d8f5132a8a4f79dc4c2d9deb54b1.zip gdb-d95a89033d01d8f5132a8a4f79dc4c2d9deb54b1.tar.gz gdb-d95a89033d01d8f5132a8a4f79dc4c2d9deb54b1.tar.bz2 | |
2003-07-21 Andrew Cagney <cagney@redhat.com>
From 2003-07-04 Kei Sakamoto <sakamoto.kei@renesas.com>:
* m32r-tdep.c, m32r-stub.c, m32r-tdep.c: Rewrite.
| -rw-r--r-- | gdb/ChangeLog | 5 | ||||
| -rw-r--r-- | gdb/m32r-rom.c | 1261 | ||||
| -rw-r--r-- | gdb/m32r-stub.c | 3497 | ||||
| -rw-r--r-- | gdb/m32r-tdep.c | 1697 |
4 files changed, 3408 insertions, 3052 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 97c9484..a3dc614 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,8 @@ +2003-07-21 Andrew Cagney <cagney@redhat.com> + + From 2003-07-04 Kei Sakamoto <sakamoto.kei@renesas.com>: + * m32r-tdep.c, m32r-stub.c, m32r-tdep.c: Rewrite. + 2003-07-20 Stephane Carrez <stcarrez@nerim.fr> * m68hc11-tdep.c (m68hc11_pseudo_register_read): Use diff --git a/gdb/m32r-rom.c b/gdb/m32r-rom.c index f8ac154..54e2cd9 100644 --- a/gdb/m32r-rom.c +++ b/gdb/m32r-rom.c @@ -1,626 +1,635 @@ -// OBSOLETE /* Remote debugging interface to m32r and mon2000 ROM monitors for GDB, -// OBSOLETE the GNU debugger. -// OBSOLETE Copyright 1996, 1997, 1998, 1999, 2000, 2001 -// OBSOLETE Free Software Foundation, Inc. -// OBSOLETE -// OBSOLETE Adapted by Michael Snyder of Cygnus Support. -// OBSOLETE -// OBSOLETE This file is part of GDB. -// OBSOLETE -// OBSOLETE This program is free software; you can redistribute it and/or modify -// OBSOLETE it under the terms of the GNU General Public License as published by -// OBSOLETE the Free Software Foundation; either version 2 of the License, or -// OBSOLETE (at your option) any later version. -// OBSOLETE -// OBSOLETE This program is distributed in the hope that it will be useful, -// OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of -// OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// OBSOLETE GNU General Public License for more details. -// OBSOLETE -// OBSOLETE You should have received a copy of the GNU General Public License -// OBSOLETE along with this program; if not, write to the Free Software -// OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, -// OBSOLETE Boston, MA 02111-1307, USA. */ -// OBSOLETE -// OBSOLETE /* This module defines communication with the Mitsubishi m32r monitor */ -// OBSOLETE -// OBSOLETE #include "defs.h" -// OBSOLETE #include "gdbcore.h" -// OBSOLETE #include "target.h" -// OBSOLETE #include "monitor.h" -// OBSOLETE #include "serial.h" -// OBSOLETE #include "symtab.h" -// OBSOLETE #include "command.h" -// OBSOLETE #include "gdbcmd.h" -// OBSOLETE #include "symfile.h" /* for generic load */ -// OBSOLETE #include <time.h> /* for time_t */ -// OBSOLETE #include "gdb_string.h" -// OBSOLETE #include "objfiles.h" /* for ALL_OBJFILES etc. */ -// OBSOLETE #include "inferior.h" /* for write_pc() */ -// OBSOLETE #include <ctype.h> -// OBSOLETE #include "regcache.h" -// OBSOLETE -// OBSOLETE extern void report_transfer_performance (unsigned long, time_t, time_t); -// OBSOLETE -// OBSOLETE /* -// OBSOLETE * All this stuff just to get my host computer's IP address! -// OBSOLETE */ -// OBSOLETE #include <sys/types.h> -// OBSOLETE #include <netdb.h> /* for hostent */ -// OBSOLETE #include <netinet/in.h> /* for struct in_addr */ -// OBSOLETE #if 1 -// OBSOLETE #include <arpa/inet.h> /* for inet_ntoa */ -// OBSOLETE #endif -// OBSOLETE -// OBSOLETE static char *board_addr; /* user-settable IP address for M32R-EVA */ -// OBSOLETE static char *server_addr; /* user-settable IP address for gdb host */ -// OBSOLETE static char *download_path; /* user-settable path for SREC files */ -// OBSOLETE -// OBSOLETE -// OBSOLETE /* -// OBSOLETE * Function: m32r_load_1 (helper function) -// OBSOLETE */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE m32r_load_section (bfd *abfd, asection *s, void *obj) -// OBSOLETE { -// OBSOLETE unsigned int *data_count = obj; -// OBSOLETE if (s->flags & SEC_LOAD) -// OBSOLETE { -// OBSOLETE bfd_size_type section_size = bfd_section_size (abfd, s); -// OBSOLETE bfd_vma section_base = bfd_section_lma (abfd, s); -// OBSOLETE unsigned int buffer, i; -// OBSOLETE -// OBSOLETE *data_count += section_size; -// OBSOLETE -// OBSOLETE printf_filtered ("Loading section %s, size 0x%lx lma ", -// OBSOLETE bfd_section_name (abfd, s), section_size); -// OBSOLETE print_address_numeric (section_base, 1, gdb_stdout); -// OBSOLETE printf_filtered ("\n"); -// OBSOLETE gdb_flush (gdb_stdout); -// OBSOLETE monitor_printf ("%s mw\r", paddr_nz (section_base)); -// OBSOLETE for (i = 0; i < section_size; i += 4) -// OBSOLETE { -// OBSOLETE QUIT; -// OBSOLETE monitor_expect (" -> ", NULL, 0); -// OBSOLETE bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4); -// OBSOLETE monitor_printf ("%x\n", buffer); -// OBSOLETE } -// OBSOLETE monitor_expect (" -> ", NULL, 0); -// OBSOLETE monitor_printf ("q\n"); -// OBSOLETE monitor_expect_prompt (NULL, 0); -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE static int -// OBSOLETE m32r_load_1 (void *dummy) -// OBSOLETE { -// OBSOLETE int data_count = 0; -// OBSOLETE -// OBSOLETE bfd_map_over_sections ((bfd *) dummy, m32r_load_section, &data_count); -// OBSOLETE return data_count; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* -// OBSOLETE * Function: m32r_load (an alternate way to load) -// OBSOLETE */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE m32r_load (char *filename, int from_tty) -// OBSOLETE { -// OBSOLETE bfd *abfd; -// OBSOLETE asection *s; -// OBSOLETE unsigned int i, data_count = 0; -// OBSOLETE time_t start_time, end_time; /* for timing of download */ -// OBSOLETE -// OBSOLETE if (filename == NULL || filename[0] == 0) -// OBSOLETE filename = get_exec_file (1); -// OBSOLETE -// OBSOLETE abfd = bfd_openr (filename, 0); -// OBSOLETE if (!abfd) -// OBSOLETE error ("Unable to open file %s\n", filename); -// OBSOLETE if (bfd_check_format (abfd, bfd_object) == 0) -// OBSOLETE error ("File is not an object file\n"); -// OBSOLETE start_time = time (NULL); -// OBSOLETE #if 0 -// OBSOLETE for (s = abfd->sections; s; s = s->next) -// OBSOLETE if (s->flags & SEC_LOAD) -// OBSOLETE { -// OBSOLETE bfd_size_type section_size = bfd_section_size (abfd, s); -// OBSOLETE bfd_vma section_base = bfd_section_vma (abfd, s); -// OBSOLETE unsigned int buffer; -// OBSOLETE -// OBSOLETE data_count += section_size; -// OBSOLETE -// OBSOLETE printf_filtered ("Loading section %s, size 0x%lx vma ", -// OBSOLETE bfd_section_name (abfd, s), section_size); -// OBSOLETE print_address_numeric (section_base, 1, gdb_stdout); -// OBSOLETE printf_filtered ("\n"); -// OBSOLETE gdb_flush (gdb_stdout); -// OBSOLETE monitor_printf ("%x mw\r", section_base); -// OBSOLETE for (i = 0; i < section_size; i += 4) -// OBSOLETE { -// OBSOLETE monitor_expect (" -> ", NULL, 0); -// OBSOLETE bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4); -// OBSOLETE monitor_printf ("%x\n", buffer); -// OBSOLETE } -// OBSOLETE monitor_expect (" -> ", NULL, 0); -// OBSOLETE monitor_printf ("q\n"); -// OBSOLETE monitor_expect_prompt (NULL, 0); -// OBSOLETE } -// OBSOLETE #else -// OBSOLETE if (!(catch_errors (m32r_load_1, abfd, "Load aborted!\n", RETURN_MASK_ALL))) -// OBSOLETE { -// OBSOLETE monitor_printf ("q\n"); -// OBSOLETE return; -// OBSOLETE } -// OBSOLETE #endif -// OBSOLETE end_time = time (NULL); -// OBSOLETE printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd)); -// OBSOLETE report_transfer_performance (data_count, start_time, end_time); -// OBSOLETE -// OBSOLETE /* Finally, make the PC point at the start address */ -// OBSOLETE if (exec_bfd) -// OBSOLETE write_pc (bfd_get_start_address (exec_bfd)); -// OBSOLETE -// OBSOLETE inferior_ptid = null_ptid; /* No process now */ -// OBSOLETE -// OBSOLETE /* This is necessary because many things were based on the PC at the -// OBSOLETE time that we attached to the monitor, which is no longer valid -// OBSOLETE now that we have loaded new code (and just changed the PC). -// OBSOLETE Another way to do this might be to call normal_stop, except that -// OBSOLETE the stack may not be valid, and things would get horribly -// OBSOLETE confused... */ -// OBSOLETE -// OBSOLETE clear_symtab_users (); -// OBSOLETE } -// OBSOLETE -// OBSOLETE static void -// OBSOLETE m32r_load_gen (char *filename, int from_tty) -// OBSOLETE { -// OBSOLETE generic_load (filename, from_tty); -// OBSOLETE } -// OBSOLETE -// OBSOLETE static void m32r_open (char *args, int from_tty); -// OBSOLETE static void mon2000_open (char *args, int from_tty); -// OBSOLETE -// OBSOLETE /* This array of registers needs to match the indexes used by GDB. The -// OBSOLETE whole reason this exists is because the various ROM monitors use -// OBSOLETE different names than GDB does, and don't support all the registers -// OBSOLETE either. So, typing "info reg sp" becomes an "A7". */ -// OBSOLETE -// OBSOLETE static char *m32r_regnames[] = -// OBSOLETE {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", -// OBSOLETE "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", -// OBSOLETE "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch", -// OBSOLETE }; -// OBSOLETE -// OBSOLETE static void -// OBSOLETE m32r_supply_register (char *regname, int regnamelen, char *val, int vallen) -// OBSOLETE { -// OBSOLETE int regno; -// OBSOLETE int num_regs = sizeof (m32r_regnames) / sizeof (m32r_regnames[0]); -// OBSOLETE -// OBSOLETE for (regno = 0; regno < num_regs; regno++) -// OBSOLETE if (strncmp (regname, m32r_regnames[regno], regnamelen) == 0) -// OBSOLETE break; -// OBSOLETE -// OBSOLETE if (regno >= num_regs) -// OBSOLETE return; /* no match */ -// OBSOLETE -// OBSOLETE if (regno == ACCL_REGNUM) -// OBSOLETE { /* special handling for 64-bit acc reg */ -// OBSOLETE monitor_supply_register (ACCH_REGNUM, val); -// OBSOLETE val = strchr (val, ':'); /* skip past ':' to get 2nd word */ -// OBSOLETE if (val != NULL) -// OBSOLETE monitor_supply_register (ACCL_REGNUM, val + 1); -// OBSOLETE } -// OBSOLETE else -// OBSOLETE { -// OBSOLETE monitor_supply_register (regno, val); -// OBSOLETE if (regno == PSW_REGNUM) -// OBSOLETE { -// OBSOLETE unsigned long psw = strtoul (val, NULL, 16); -// OBSOLETE char *zero = "00000000", *one = "00000001"; -// OBSOLETE -// OBSOLETE #ifdef SM_REGNUM -// OBSOLETE /* Stack mode bit */ -// OBSOLETE monitor_supply_register (SM_REGNUM, (psw & 0x80) ? one : zero); -// OBSOLETE #endif -// OBSOLETE #ifdef BSM_REGNUM -// OBSOLETE /* Backup stack mode bit */ -// OBSOLETE monitor_supply_register (BSM_REGNUM, (psw & 0x8000) ? one : zero); -// OBSOLETE #endif -// OBSOLETE #ifdef IE_REGNUM -// OBSOLETE /* Interrupt enable bit */ -// OBSOLETE monitor_supply_register (IE_REGNUM, (psw & 0x40) ? one : zero); -// OBSOLETE #endif -// OBSOLETE #ifdef BIE_REGNUM -// OBSOLETE /* Backup interrupt enable bit */ -// OBSOLETE monitor_supply_register (BIE_REGNUM, (psw & 0x4000) ? one : zero); -// OBSOLETE #endif -// OBSOLETE #ifdef COND_REGNUM -// OBSOLETE /* Condition bit (carry etc.) */ -// OBSOLETE monitor_supply_register (COND_REGNUM, (psw & 0x1) ? one : zero); -// OBSOLETE #endif -// OBSOLETE #ifdef CBR_REGNUM -// OBSOLETE monitor_supply_register (CBR_REGNUM, (psw & 0x1) ? one : zero); -// OBSOLETE #endif -// OBSOLETE #ifdef BPC_REGNUM -// OBSOLETE monitor_supply_register (BPC_REGNUM, zero); /* KLUDGE: (???????) */ -// OBSOLETE #endif -// OBSOLETE #ifdef BCARRY_REGNUM -// OBSOLETE monitor_supply_register (BCARRY_REGNUM, zero); /* KLUDGE: (??????) */ -// OBSOLETE #endif -// OBSOLETE } -// OBSOLETE -// OBSOLETE if (regno == SPI_REGNUM || regno == SPU_REGNUM) -// OBSOLETE { /* special handling for stack pointer (spu or spi) */ -// OBSOLETE unsigned long stackmode = read_register (PSW_REGNUM) & 0x80; -// OBSOLETE -// OBSOLETE if (regno == SPI_REGNUM && !stackmode) /* SP == SPI */ -// OBSOLETE monitor_supply_register (SP_REGNUM, val); -// OBSOLETE else if (regno == SPU_REGNUM && stackmode) /* SP == SPU */ -// OBSOLETE monitor_supply_register (SP_REGNUM, val); -// OBSOLETE } -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* m32r RevC board monitor */ -// OBSOLETE -// OBSOLETE static struct target_ops m32r_ops; -// OBSOLETE -// OBSOLETE static char *m32r_inits[] = -// OBSOLETE {"\r", NULL}; -// OBSOLETE -// OBSOLETE static struct monitor_ops m32r_cmds; -// OBSOLETE -// OBSOLETE static void -// OBSOLETE init_m32r_cmds (void) -// OBSOLETE { -// OBSOLETE m32r_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST; -// OBSOLETE m32r_cmds.init = m32r_inits; /* Init strings */ -// OBSOLETE m32r_cmds.cont = "go\r"; /* continue command */ -// OBSOLETE m32r_cmds.step = "step\r"; /* single step */ -// OBSOLETE m32r_cmds.stop = NULL; /* interrupt command */ -// OBSOLETE m32r_cmds.set_break = "%x +bp\r"; /* set a breakpoint */ -// OBSOLETE m32r_cmds.clr_break = "%x -bp\r"; /* clear a breakpoint */ -// OBSOLETE m32r_cmds.clr_all_break = "bpoff\r"; /* clear all breakpoints */ -// OBSOLETE m32r_cmds.fill = "%x %x %x fill\r"; /* fill (start length val) */ -// OBSOLETE m32r_cmds.setmem.cmdb = "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */ -// OBSOLETE m32r_cmds.setmem.cmdw = "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */ -// OBSOLETE m32r_cmds.setmem.cmdl = "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */ -// OBSOLETE m32r_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */ -// OBSOLETE m32r_cmds.setmem.resp_delim = NULL; /* setmem.resp_delim */ -// OBSOLETE m32r_cmds.setmem.term = NULL; /* setmem.term */ -// OBSOLETE m32r_cmds.setmem.term_cmd = NULL; /* setmem.term_cmd */ -// OBSOLETE m32r_cmds.getmem.cmdb = "%x %x dump\r"; /* getmem.cmdb (addr, len) */ -// OBSOLETE m32r_cmds.getmem.cmdw = NULL; /* getmem.cmdw (addr, len) */ -// OBSOLETE m32r_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, len) */ -// OBSOLETE m32r_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */ -// OBSOLETE m32r_cmds.getmem.resp_delim = ": "; /* getmem.resp_delim */ -// OBSOLETE m32r_cmds.getmem.term = NULL; /* getmem.term */ -// OBSOLETE m32r_cmds.getmem.term_cmd = NULL; /* getmem.term_cmd */ -// OBSOLETE m32r_cmds.setreg.cmd = "%x to %%%s\r"; /* setreg.cmd (name, value) */ -// OBSOLETE m32r_cmds.setreg.resp_delim = NULL; /* setreg.resp_delim */ -// OBSOLETE m32r_cmds.setreg.term = NULL; /* setreg.term */ -// OBSOLETE m32r_cmds.setreg.term_cmd = NULL; /* setreg.term_cmd */ -// OBSOLETE m32r_cmds.getreg.cmd = NULL; /* getreg.cmd (name) */ -// OBSOLETE m32r_cmds.getreg.resp_delim = NULL; /* getreg.resp_delim */ -// OBSOLETE m32r_cmds.getreg.term = NULL; /* getreg.term */ -// OBSOLETE m32r_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */ -// OBSOLETE m32r_cmds.dump_registers = ".reg\r"; /* dump_registers */ -// OBSOLETE m32r_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)"; /* register_pattern */ -// OBSOLETE m32r_cmds.supply_register = m32r_supply_register; /* supply_register */ -// OBSOLETE m32r_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */ -// OBSOLETE m32r_cmds.load = NULL; /* download command */ -// OBSOLETE m32r_cmds.loadresp = NULL; /* load response */ -// OBSOLETE m32r_cmds.prompt = "ok "; /* monitor command prompt */ -// OBSOLETE m32r_cmds.line_term = "\r"; /* end-of-line terminator */ -// OBSOLETE m32r_cmds.cmd_end = NULL; /* optional command terminator */ -// OBSOLETE m32r_cmds.target = &m32r_ops; /* target operations */ -// OBSOLETE m32r_cmds.stopbits = SERIAL_1_STOPBITS; /* number of stop bits */ -// OBSOLETE m32r_cmds.regnames = m32r_regnames; /* registers names */ -// OBSOLETE m32r_cmds.magic = MONITOR_OPS_MAGIC; /* magic */ -// OBSOLETE } /* init_m32r_cmds */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE m32r_open (char *args, int from_tty) -// OBSOLETE { -// OBSOLETE monitor_open (args, &m32r_cmds, from_tty); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Mon2000 monitor (MSA2000 board) */ -// OBSOLETE -// OBSOLETE static struct target_ops mon2000_ops; -// OBSOLETE static struct monitor_ops mon2000_cmds; -// OBSOLETE -// OBSOLETE static void -// OBSOLETE init_mon2000_cmds (void) -// OBSOLETE { -// OBSOLETE mon2000_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST; -// OBSOLETE mon2000_cmds.init = m32r_inits; /* Init strings */ -// OBSOLETE mon2000_cmds.cont = "go\r"; /* continue command */ -// OBSOLETE mon2000_cmds.step = "step\r"; /* single step */ -// OBSOLETE mon2000_cmds.stop = NULL; /* interrupt command */ -// OBSOLETE mon2000_cmds.set_break = "%x +bp\r"; /* set a breakpoint */ -// OBSOLETE mon2000_cmds.clr_break = "%x -bp\r"; /* clear a breakpoint */ -// OBSOLETE mon2000_cmds.clr_all_break = "bpoff\r"; /* clear all breakpoints */ -// OBSOLETE mon2000_cmds.fill = "%x %x %x fill\r"; /* fill (start length val) */ -// OBSOLETE mon2000_cmds.setmem.cmdb = "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */ -// OBSOLETE mon2000_cmds.setmem.cmdw = "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */ -// OBSOLETE mon2000_cmds.setmem.cmdl = "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */ -// OBSOLETE mon2000_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */ -// OBSOLETE mon2000_cmds.setmem.resp_delim = NULL; /* setmem.resp_delim */ -// OBSOLETE mon2000_cmds.setmem.term = NULL; /* setmem.term */ -// OBSOLETE mon2000_cmds.setmem.term_cmd = NULL; /* setmem.term_cmd */ -// OBSOLETE mon2000_cmds.getmem.cmdb = "%x %x dump\r"; /* getmem.cmdb (addr, len) */ -// OBSOLETE mon2000_cmds.getmem.cmdw = NULL; /* getmem.cmdw (addr, len) */ -// OBSOLETE mon2000_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, len) */ -// OBSOLETE mon2000_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */ -// OBSOLETE mon2000_cmds.getmem.resp_delim = ": "; /* getmem.resp_delim */ -// OBSOLETE mon2000_cmds.getmem.term = NULL; /* getmem.term */ -// OBSOLETE mon2000_cmds.getmem.term_cmd = NULL; /* getmem.term_cmd */ -// OBSOLETE mon2000_cmds.setreg.cmd = "%x to %%%s\r"; /* setreg.cmd (name, value) */ -// OBSOLETE mon2000_cmds.setreg.resp_delim = NULL; /* setreg.resp_delim */ -// OBSOLETE mon2000_cmds.setreg.term = NULL; /* setreg.term */ -// OBSOLETE mon2000_cmds.setreg.term_cmd = NULL; /* setreg.term_cmd */ -// OBSOLETE mon2000_cmds.getreg.cmd = NULL; /* getreg.cmd (name) */ -// OBSOLETE mon2000_cmds.getreg.resp_delim = NULL; /* getreg.resp_delim */ -// OBSOLETE mon2000_cmds.getreg.term = NULL; /* getreg.term */ -// OBSOLETE mon2000_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */ -// OBSOLETE mon2000_cmds.dump_registers = ".reg\r"; /* dump_registers */ -// OBSOLETE mon2000_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)"; /* register_pattern */ -// OBSOLETE mon2000_cmds.supply_register = m32r_supply_register; /* supply_register */ -// OBSOLETE mon2000_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */ -// OBSOLETE mon2000_cmds.load = NULL; /* download command */ -// OBSOLETE mon2000_cmds.loadresp = NULL; /* load response */ -// OBSOLETE mon2000_cmds.prompt = "Mon2000>"; /* monitor command prompt */ -// OBSOLETE mon2000_cmds.line_term = "\r"; /* end-of-line terminator */ -// OBSOLETE mon2000_cmds.cmd_end = NULL; /* optional command terminator */ -// OBSOLETE mon2000_cmds.target = &mon2000_ops; /* target operations */ -// OBSOLETE mon2000_cmds.stopbits = SERIAL_1_STOPBITS; /* number of stop bits */ -// OBSOLETE mon2000_cmds.regnames = m32r_regnames; /* registers names */ -// OBSOLETE mon2000_cmds.magic = MONITOR_OPS_MAGIC; /* magic */ -// OBSOLETE } /* init_mon2000_cmds */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE mon2000_open (char *args, int from_tty) -// OBSOLETE { -// OBSOLETE monitor_open (args, &mon2000_cmds, from_tty); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: set_board_address -// OBSOLETE Tell the BootOne monitor what it's ethernet IP address is. */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE m32r_set_board_address (char *args, int from_tty) -// OBSOLETE { -// OBSOLETE int resp_len; -// OBSOLETE char buf[1024]; -// OBSOLETE -// OBSOLETE if (args && *args) -// OBSOLETE { -// OBSOLETE monitor_printf ("ulip %s\n", args); -// OBSOLETE resp_len = monitor_expect_prompt (buf, sizeof (buf)); -// OBSOLETE /* now parse the result for success */ -// OBSOLETE } -// OBSOLETE else -// OBSOLETE error ("Requires argument (IP address for M32R-EVA board)"); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: set_server_address -// OBSOLETE Tell the BootOne monitor what gdb's ethernet IP address is. */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE m32r_set_server_address (char *args, int from_tty) -// OBSOLETE { -// OBSOLETE int resp_len; -// OBSOLETE char buf[1024]; -// OBSOLETE -// OBSOLETE if (args && *args) -// OBSOLETE { -// OBSOLETE monitor_printf ("uhip %s\n", args); -// OBSOLETE resp_len = monitor_expect_prompt (buf, sizeof (buf)); -// OBSOLETE /* now parse the result for success */ -// OBSOLETE } -// OBSOLETE else -// OBSOLETE error ("Requires argument (IP address of GDB's host computer)"); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: set_download_path -// OBSOLETE Tell the BootOne monitor the default path for downloadable SREC files. */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE m32r_set_download_path (char *args, int from_tty) -// OBSOLETE { -// OBSOLETE int resp_len; -// OBSOLETE char buf[1024]; -// OBSOLETE -// OBSOLETE if (args && *args) -// OBSOLETE { -// OBSOLETE monitor_printf ("up %s\n", args); -// OBSOLETE resp_len = monitor_expect_prompt (buf, sizeof (buf)); -// OBSOLETE /* now parse the result for success */ -// OBSOLETE } -// OBSOLETE else -// OBSOLETE error ("Requires argument (default path for downloadable SREC files)"); -// OBSOLETE } -// OBSOLETE -// OBSOLETE static void -// OBSOLETE m32r_upload_command (char *args, int from_tty) -// OBSOLETE { -// OBSOLETE bfd *abfd; -// OBSOLETE asection *s; -// OBSOLETE time_t start_time, end_time; /* for timing of download */ -// OBSOLETE int resp_len, data_count = 0; -// OBSOLETE char buf[1024]; -// OBSOLETE struct hostent *hostent; -// OBSOLETE struct in_addr inet_addr; -// OBSOLETE -// OBSOLETE /* first check to see if there's an ethernet port! */ -// OBSOLETE monitor_printf ("ust\r"); -// OBSOLETE resp_len = monitor_expect_prompt (buf, sizeof (buf)); -// OBSOLETE if (!strchr (buf, ':')) -// OBSOLETE error ("No ethernet connection!"); -// OBSOLETE -// OBSOLETE if (board_addr == 0) -// OBSOLETE { -// OBSOLETE /* scan second colon in the output from the "ust" command */ -// OBSOLETE char *myIPaddress = strchr (strchr (buf, ':') + 1, ':') + 1; -// OBSOLETE -// OBSOLETE while (isspace (*myIPaddress)) -// OBSOLETE myIPaddress++; -// OBSOLETE -// OBSOLETE if (!strncmp (myIPaddress, "0.0.", 4)) /* empty */ -// OBSOLETE error ("Please use 'set board-address' to set the M32R-EVA board's IP address."); -// OBSOLETE if (strchr (myIPaddress, '(')) -// OBSOLETE *(strchr (myIPaddress, '(')) = '\0'; /* delete trailing junk */ -// OBSOLETE board_addr = xstrdup (myIPaddress); -// OBSOLETE } -// OBSOLETE if (server_addr == 0) -// OBSOLETE { -// OBSOLETE buf[0] = 0; -// OBSOLETE gethostname (buf, sizeof (buf)); -// OBSOLETE if (buf[0] != 0) -// OBSOLETE hostent = gethostbyname (buf); -// OBSOLETE if (hostent != 0) -// OBSOLETE { -// OBSOLETE #if 1 -// OBSOLETE memcpy (&inet_addr.s_addr, hostent->h_addr, -// OBSOLETE sizeof (inet_addr.s_addr)); -// OBSOLETE server_addr = (char *) inet_ntoa (inet_addr); -// OBSOLETE #else -// OBSOLETE server_addr = (char *) inet_ntoa (hostent->h_addr); -// OBSOLETE #endif -// OBSOLETE } -// OBSOLETE if (server_addr == 0) /* failed? */ -// OBSOLETE error ("Need to know gdb host computer's IP address (use 'set server-address')"); -// OBSOLETE } -// OBSOLETE -// OBSOLETE if (args == 0 || args[0] == 0) /* no args: upload the current file */ -// OBSOLETE args = get_exec_file (1); -// OBSOLETE -// OBSOLETE if (args[0] != '/' && download_path == 0) -// OBSOLETE { -// OBSOLETE if (current_directory) -// OBSOLETE download_path = xstrdup (current_directory); -// OBSOLETE else -// OBSOLETE error ("Need to know default download path (use 'set download-path')"); -// OBSOLETE } -// OBSOLETE -// OBSOLETE start_time = time (NULL); -// OBSOLETE monitor_printf ("uhip %s\r", server_addr); -// OBSOLETE resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ -// OBSOLETE monitor_printf ("ulip %s\r", board_addr); -// OBSOLETE resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ -// OBSOLETE if (args[0] != '/') -// OBSOLETE monitor_printf ("up %s\r", download_path); /* use default path */ -// OBSOLETE else -// OBSOLETE monitor_printf ("up\r"); /* rooted filename/path */ -// OBSOLETE resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ -// OBSOLETE -// OBSOLETE if (strrchr (args, '.') && !strcmp (strrchr (args, '.'), ".srec")) -// OBSOLETE monitor_printf ("ul %s\r", args); -// OBSOLETE else /* add ".srec" suffix */ -// OBSOLETE monitor_printf ("ul %s.srec\r", args); -// OBSOLETE resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ -// OBSOLETE -// OBSOLETE if (buf[0] == 0 || strstr (buf, "complete") == 0) -// OBSOLETE error ("Upload file not found: %s.srec\nCheck IP addresses and download path.", args); -// OBSOLETE else -// OBSOLETE printf_filtered (" -- Ethernet load complete.\n"); -// OBSOLETE -// OBSOLETE end_time = time (NULL); -// OBSOLETE abfd = bfd_openr (args, 0); -// OBSOLETE if (abfd != NULL) -// OBSOLETE { /* Download is done -- print section statistics */ -// OBSOLETE if (bfd_check_format (abfd, bfd_object) == 0) -// OBSOLETE { -// OBSOLETE printf_filtered ("File is not an object file\n"); -// OBSOLETE } -// OBSOLETE for (s = abfd->sections; s; s = s->next) -// OBSOLETE if (s->flags & SEC_LOAD) -// OBSOLETE { -// OBSOLETE bfd_size_type section_size = bfd_section_size (abfd, s); -// OBSOLETE bfd_vma section_base = bfd_section_lma (abfd, s); -// OBSOLETE unsigned int buffer; -// OBSOLETE -// OBSOLETE data_count += section_size; -// OBSOLETE -// OBSOLETE printf_filtered ("Loading section %s, size 0x%lx lma ", -// OBSOLETE bfd_section_name (abfd, s), section_size); -// OBSOLETE print_address_numeric (section_base, 1, gdb_stdout); -// OBSOLETE printf_filtered ("\n"); -// OBSOLETE gdb_flush (gdb_stdout); -// OBSOLETE } -// OBSOLETE /* Finally, make the PC point at the start address */ -// OBSOLETE write_pc (bfd_get_start_address (abfd)); -// OBSOLETE report_transfer_performance (data_count, start_time, end_time); -// OBSOLETE printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd)); -// OBSOLETE } -// OBSOLETE inferior_ptid = null_ptid; /* No process now */ -// OBSOLETE -// OBSOLETE /* This is necessary because many things were based on the PC at the -// OBSOLETE time that we attached to the monitor, which is no longer valid -// OBSOLETE now that we have loaded new code (and just changed the PC). -// OBSOLETE Another way to do this might be to call normal_stop, except that -// OBSOLETE the stack may not be valid, and things would get horribly -// OBSOLETE confused... */ -// OBSOLETE -// OBSOLETE clear_symtab_users (); -// OBSOLETE } -// OBSOLETE -// OBSOLETE void -// OBSOLETE _initialize_m32r_rom (void) -// OBSOLETE { -// OBSOLETE /* Initialize m32r RevC monitor target */ -// OBSOLETE init_m32r_cmds (); -// OBSOLETE init_monitor_ops (&m32r_ops); -// OBSOLETE -// OBSOLETE m32r_ops.to_shortname = "m32r"; -// OBSOLETE m32r_ops.to_longname = "m32r monitor"; -// OBSOLETE m32r_ops.to_load = m32r_load_gen; /* monitor lacks a download command */ -// OBSOLETE m32r_ops.to_doc = "Debug via the m32r monitor.\n\ -// OBSOLETE Specify the serial device it is connected to (e.g. /dev/ttya)."; -// OBSOLETE m32r_ops.to_open = m32r_open; -// OBSOLETE add_target (&m32r_ops); -// OBSOLETE -// OBSOLETE /* Initialize mon2000 monitor target */ -// OBSOLETE init_mon2000_cmds (); -// OBSOLETE init_monitor_ops (&mon2000_ops); -// OBSOLETE -// OBSOLETE mon2000_ops.to_shortname = "mon2000"; -// OBSOLETE mon2000_ops.to_longname = "Mon2000 monitor"; -// OBSOLETE mon2000_ops.to_load = m32r_load_gen; /* monitor lacks a download command */ -// OBSOLETE mon2000_ops.to_doc = "Debug via the Mon2000 monitor.\n\ -// OBSOLETE Specify the serial device it is connected to (e.g. /dev/ttya)."; -// OBSOLETE mon2000_ops.to_open = mon2000_open; -// OBSOLETE add_target (&mon2000_ops); -// OBSOLETE -// OBSOLETE add_show_from_set -// OBSOLETE (add_set_cmd ("download-path", class_obscure, var_string, -// OBSOLETE (char *) &download_path, -// OBSOLETE "Set the default path for downloadable SREC files.", -// OBSOLETE &setlist), -// OBSOLETE &showlist); -// OBSOLETE -// OBSOLETE add_show_from_set -// OBSOLETE (add_set_cmd ("board-address", class_obscure, var_string, -// OBSOLETE (char *) &board_addr, -// OBSOLETE "Set IP address for M32R-EVA target board.", -// OBSOLETE &setlist), -// OBSOLETE &showlist); -// OBSOLETE -// OBSOLETE add_show_from_set -// OBSOLETE (add_set_cmd ("server-address", class_obscure, var_string, -// OBSOLETE (char *) &server_addr, -// OBSOLETE "Set IP address for download server (GDB's host computer).", -// OBSOLETE &setlist), -// OBSOLETE &showlist); -// OBSOLETE -// OBSOLETE add_com ("upload", class_obscure, m32r_upload_command, -// OBSOLETE "Upload the srec file via the monitor's Ethernet upload capability."); -// OBSOLETE -// OBSOLETE add_com ("tload", class_obscure, m32r_load, "test upload command."); -// OBSOLETE } +/* Remote debugging interface to m32r and mon2000 ROM monitors for GDB, + the GNU debugger. + Copyright 1996, 1997, 1998, 1999, 2000, 2001 + Free Software Foundation, Inc. + + Adapted by Michael Snyder of Cygnus Support. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* This module defines communication with the Renesas m32r monitor */ + +#include "defs.h" +#include "gdbcore.h" +#include "target.h" +#include "monitor.h" +#include "serial.h" +#include "symtab.h" +#include "command.h" +#include "gdbcmd.h" +#include "symfile.h" /* for generic load */ +#include <time.h> /* for time_t */ +#include "gdb_string.h" +#include "objfiles.h" /* for ALL_OBJFILES etc. */ +#include "inferior.h" /* for write_pc() */ +#include <ctype.h> +#include "regcache.h" + +extern void report_transfer_performance (unsigned long, time_t, time_t); + +/* + * All this stuff just to get my host computer's IP address! + */ +#include <sys/types.h> +#include <netdb.h> /* for hostent */ +#include <netinet/in.h> /* for struct in_addr */ +#if 1 +#include <arpa/inet.h> /* for inet_ntoa */ +#endif + +static char *board_addr; /* user-settable IP address for M32R-EVA */ +static char *server_addr; /* user-settable IP address for gdb host */ +static char *download_path; /* user-settable path for SREC files */ + + +/* REGNUM */ +#define PSW_REGNUM 16 +#define SPI_REGNUM 18 +#define SPU_REGNUM 19 +#define ACCL_REGNUM 22 +#define ACCH_REGNUM 23 + + +/* + * Function: m32r_load_1 (helper function) + */ + +static void +m32r_load_section (bfd *abfd, asection *s, void *obj) +{ + unsigned int *data_count = obj; + if (s->flags & SEC_LOAD) + { + bfd_size_type section_size = bfd_section_size (abfd, s); + bfd_vma section_base = bfd_section_lma (abfd, s); + unsigned int buffer, i; + + *data_count += section_size; + + printf_filtered ("Loading section %s, size 0x%lx lma ", + bfd_section_name (abfd, s), section_size); + print_address_numeric (section_base, 1, gdb_stdout); + printf_filtered ("\n"); + gdb_flush (gdb_stdout); + monitor_printf ("%s mw\r", paddr_nz (section_base)); + for (i = 0; i < section_size; i += 4) + { + QUIT; + monitor_expect (" -> ", NULL, 0); + bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4); + monitor_printf ("%x\n", buffer); + } + monitor_expect (" -> ", NULL, 0); + monitor_printf ("q\n"); + monitor_expect_prompt (NULL, 0); + } +} + +static int +m32r_load_1 (void *dummy) +{ + int data_count = 0; + + bfd_map_over_sections ((bfd *) dummy, m32r_load_section, &data_count); + return data_count; +} + +/* + * Function: m32r_load (an alternate way to load) + */ + +static void +m32r_load (char *filename, int from_tty) +{ + bfd *abfd; + asection *s; + unsigned int i, data_count = 0; + time_t start_time, end_time; /* for timing of download */ + + if (filename == NULL || filename[0] == 0) + filename = get_exec_file (1); + + abfd = bfd_openr (filename, 0); + if (!abfd) + error ("Unable to open file %s\n", filename); + if (bfd_check_format (abfd, bfd_object) == 0) + error ("File is not an object file\n"); + start_time = time (NULL); +#if 0 + for (s = abfd->sections; s; s = s->next) + if (s->flags & SEC_LOAD) + { + bfd_size_type section_size = bfd_section_size (abfd, s); + bfd_vma section_base = bfd_section_vma (abfd, s); + unsigned int buffer; + + data_count += section_size; + + printf_filtered ("Loading section %s, size 0x%lx vma ", + bfd_section_name (abfd, s), section_size); + print_address_numeric (section_base, 1, gdb_stdout); + printf_filtered ("\n"); + gdb_flush (gdb_stdout); + monitor_printf ("%x mw\r", section_base); + for (i = 0; i < section_size; i += 4) + { + monitor_expect (" -> ", NULL, 0); + bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4); + monitor_printf ("%x\n", buffer); + } + monitor_expect (" -> ", NULL, 0); + monitor_printf ("q\n"); + monitor_expect_prompt (NULL, 0); + } +#else + if (!(catch_errors (m32r_load_1, abfd, "Load aborted!\n", RETURN_MASK_ALL))) + { + monitor_printf ("q\n"); + return; + } +#endif + end_time = time (NULL); + printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd)); + report_transfer_performance (data_count, start_time, end_time); + + /* Finally, make the PC point at the start address */ + if (exec_bfd) + write_pc (bfd_get_start_address (exec_bfd)); + + inferior_ptid = null_ptid; /* No process now */ + + /* This is necessary because many things were based on the PC at the + time that we attached to the monitor, which is no longer valid + now that we have loaded new code (and just changed the PC). + Another way to do this might be to call normal_stop, except that + the stack may not be valid, and things would get horribly + confused... */ + + clear_symtab_users (); +} + +static void +m32r_load_gen (char *filename, int from_tty) +{ + generic_load (filename, from_tty); +} + +static void m32r_open (char *args, int from_tty); +static void mon2000_open (char *args, int from_tty); + +/* 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 an "A7". */ + +static char *m32r_regnames[] = + { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", + "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", + "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch", +}; + +static void +m32r_supply_register (char *regname, int regnamelen, char *val, int vallen) +{ + int regno; + int num_regs = sizeof (m32r_regnames) / sizeof (m32r_regnames[0]); + + for (regno = 0; regno < num_regs; regno++) + if (strncmp (regname, m32r_regnames[regno], regnamelen) == 0) + break; + + if (regno >= num_regs) + return; /* no match */ + + if (regno == ACCL_REGNUM) + { /* special handling for 64-bit acc reg */ + monitor_supply_register (ACCH_REGNUM, val); + val = strchr (val, ':'); /* skip past ':' to get 2nd word */ + if (val != NULL) + monitor_supply_register (ACCL_REGNUM, val + 1); + } + else + { + monitor_supply_register (regno, val); + if (regno == PSW_REGNUM) + { + unsigned long psw = strtoul (val, NULL, 16); + char *zero = "00000000", *one = "00000001"; + +#ifdef SM_REGNUM + /* Stack mode bit */ + monitor_supply_register (SM_REGNUM, (psw & 0x80) ? one : zero); +#endif +#ifdef BSM_REGNUM + /* Backup stack mode bit */ + monitor_supply_register (BSM_REGNUM, (psw & 0x8000) ? one : zero); +#endif +#ifdef IE_REGNUM + /* Interrupt enable bit */ + monitor_supply_register (IE_REGNUM, (psw & 0x40) ? one : zero); +#endif +#ifdef BIE_REGNUM + /* Backup interrupt enable bit */ + monitor_supply_register (BIE_REGNUM, (psw & 0x4000) ? one : zero); +#endif +#ifdef COND_REGNUM + /* Condition bit (carry etc.) */ + monitor_supply_register (COND_REGNUM, (psw & 0x1) ? one : zero); +#endif +#ifdef CBR_REGNUM + monitor_supply_register (CBR_REGNUM, (psw & 0x1) ? one : zero); +#endif +#ifdef BPC_REGNUM + monitor_supply_register (BPC_REGNUM, zero); /* KLUDGE: (???????) */ +#endif +#ifdef BCARRY_REGNUM + monitor_supply_register (BCARRY_REGNUM, zero); /* KLUDGE: (??????) */ +#endif + } + + if (regno == SPI_REGNUM || regno == SPU_REGNUM) + { /* special handling for stack pointer (spu or spi) */ + unsigned long stackmode = read_register (PSW_REGNUM) & 0x80; + + if (regno == SPI_REGNUM && !stackmode) /* SP == SPI */ + monitor_supply_register (SP_REGNUM, val); + else if (regno == SPU_REGNUM && stackmode) /* SP == SPU */ + monitor_supply_register (SP_REGNUM, val); + } + } +} + +/* m32r RevC board monitor */ + +static struct target_ops m32r_ops; + +static char *m32r_inits[] = { "\r", NULL }; + +static struct monitor_ops m32r_cmds; + +static void +init_m32r_cmds (void) +{ + m32r_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST; + m32r_cmds.init = m32r_inits; /* Init strings */ + m32r_cmds.cont = "go\r"; /* continue command */ + m32r_cmds.step = "step\r"; /* single step */ + m32r_cmds.stop = NULL; /* interrupt command */ + m32r_cmds.set_break = "%x +bp\r"; /* set a breakpoint */ + m32r_cmds.clr_break = "%x -bp\r"; /* clear a breakpoint */ + m32r_cmds.clr_all_break = "bpoff\r"; /* clear all breakpoints */ + m32r_cmds.fill = "%x %x %x fill\r"; /* fill (start length val) */ + m32r_cmds.setmem.cmdb = "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */ + m32r_cmds.setmem.cmdw = "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */ + m32r_cmds.setmem.cmdl = "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */ + m32r_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */ + m32r_cmds.setmem.resp_delim = NULL; /* setmem.resp_delim */ + m32r_cmds.setmem.term = NULL; /* setmem.term */ + m32r_cmds.setmem.term_cmd = NULL; /* setmem.term_cmd */ + m32r_cmds.getmem.cmdb = "%x %x dump\r"; /* getmem.cmdb (addr, len) */ + m32r_cmds.getmem.cmdw = NULL; /* getmem.cmdw (addr, len) */ + m32r_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, len) */ + m32r_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */ + m32r_cmds.getmem.resp_delim = ": "; /* getmem.resp_delim */ + m32r_cmds.getmem.term = NULL; /* getmem.term */ + m32r_cmds.getmem.term_cmd = NULL; /* getmem.term_cmd */ + m32r_cmds.setreg.cmd = "%x to %%%s\r"; /* setreg.cmd (name, value) */ + m32r_cmds.setreg.resp_delim = NULL; /* setreg.resp_delim */ + m32r_cmds.setreg.term = NULL; /* setreg.term */ + m32r_cmds.setreg.term_cmd = NULL; /* setreg.term_cmd */ + m32r_cmds.getreg.cmd = NULL; /* getreg.cmd (name) */ + m32r_cmds.getreg.resp_delim = NULL; /* getreg.resp_delim */ + m32r_cmds.getreg.term = NULL; /* getreg.term */ + m32r_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */ + m32r_cmds.dump_registers = ".reg\r"; /* dump_registers */ + m32r_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)"; /* register_pattern */ + m32r_cmds.supply_register = m32r_supply_register; /* supply_register */ + m32r_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */ + m32r_cmds.load = NULL; /* download command */ + m32r_cmds.loadresp = NULL; /* load response */ + m32r_cmds.prompt = "ok "; /* monitor command prompt */ + m32r_cmds.line_term = "\r"; /* end-of-line terminator */ + m32r_cmds.cmd_end = NULL; /* optional command terminator */ + m32r_cmds.target = &m32r_ops; /* target operations */ + m32r_cmds.stopbits = SERIAL_1_STOPBITS; /* number of stop bits */ + m32r_cmds.regnames = m32r_regnames; /* registers names */ + m32r_cmds.magic = MONITOR_OPS_MAGIC; /* magic */ +} /* init_m32r_cmds */ + +static void +m32r_open (char *args, int from_tty) +{ + monitor_open (args, &m32r_cmds, from_tty); +} + +/* Mon2000 monitor (MSA2000 board) */ + +static struct target_ops mon2000_ops; +static struct monitor_ops mon2000_cmds; + +static void +init_mon2000_cmds (void) +{ + mon2000_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST; + mon2000_cmds.init = m32r_inits; /* Init strings */ + mon2000_cmds.cont = "go\r"; /* continue command */ + mon2000_cmds.step = "step\r"; /* single step */ + mon2000_cmds.stop = NULL; /* interrupt command */ + mon2000_cmds.set_break = "%x +bp\r"; /* set a breakpoint */ + mon2000_cmds.clr_break = "%x -bp\r"; /* clear a breakpoint */ + mon2000_cmds.clr_all_break = "bpoff\r"; /* clear all breakpoints */ + mon2000_cmds.fill = "%x %x %x fill\r"; /* fill (start length val) */ + mon2000_cmds.setmem.cmdb = "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */ + mon2000_cmds.setmem.cmdw = "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */ + mon2000_cmds.setmem.cmdl = "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */ + mon2000_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */ + mon2000_cmds.setmem.resp_delim = NULL; /* setmem.resp_delim */ + mon2000_cmds.setmem.term = NULL; /* setmem.term */ + mon2000_cmds.setmem.term_cmd = NULL; /* setmem.term_cmd */ + mon2000_cmds.getmem.cmdb = "%x %x dump\r"; /* getmem.cmdb (addr, len) */ + mon2000_cmds.getmem.cmdw = NULL; /* getmem.cmdw (addr, len) */ + mon2000_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, len) */ + mon2000_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */ + mon2000_cmds.getmem.resp_delim = ": "; /* getmem.resp_delim */ + mon2000_cmds.getmem.term = NULL; /* getmem.term */ + mon2000_cmds.getmem.term_cmd = NULL; /* getmem.term_cmd */ + mon2000_cmds.setreg.cmd = "%x to %%%s\r"; /* setreg.cmd (name, value) */ + mon2000_cmds.setreg.resp_delim = NULL; /* setreg.resp_delim */ + mon2000_cmds.setreg.term = NULL; /* setreg.term */ + mon2000_cmds.setreg.term_cmd = NULL; /* setreg.term_cmd */ + mon2000_cmds.getreg.cmd = NULL; /* getreg.cmd (name) */ + mon2000_cmds.getreg.resp_delim = NULL; /* getreg.resp_delim */ + mon2000_cmds.getreg.term = NULL; /* getreg.term */ + mon2000_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */ + mon2000_cmds.dump_registers = ".reg\r"; /* dump_registers */ + mon2000_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)"; /* register_pattern */ + mon2000_cmds.supply_register = m32r_supply_register; /* supply_register */ + mon2000_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */ + mon2000_cmds.load = NULL; /* download command */ + mon2000_cmds.loadresp = NULL; /* load response */ + mon2000_cmds.prompt = "Mon2000>"; /* monitor command prompt */ + mon2000_cmds.line_term = "\r"; /* end-of-line terminator */ + mon2000_cmds.cmd_end = NULL; /* optional command terminator */ + mon2000_cmds.target = &mon2000_ops; /* target operations */ + mon2000_cmds.stopbits = SERIAL_1_STOPBITS; /* number of stop bits */ + mon2000_cmds.regnames = m32r_regnames; /* registers names */ + mon2000_cmds.magic = MONITOR_OPS_MAGIC; /* magic */ +} /* init_mon2000_cmds */ + +static void +mon2000_open (char *args, int from_tty) +{ + monitor_open (args, &mon2000_cmds, from_tty); +} + +/* Function: set_board_address + Tell the BootOne monitor what it's ethernet IP address is. */ + +static void +m32r_set_board_address (char *args, int from_tty) +{ + int resp_len; + char buf[1024]; + + if (args && *args) + { + monitor_printf ("ulip %s\n", args); + resp_len = monitor_expect_prompt (buf, sizeof (buf)); + /* now parse the result for success */ + } + else + error ("Requires argument (IP address for M32R-EVA board)"); +} + +/* Function: set_server_address + Tell the BootOne monitor what gdb's ethernet IP address is. */ + +static void +m32r_set_server_address (char *args, int from_tty) +{ + int resp_len; + char buf[1024]; + + if (args && *args) + { + monitor_printf ("uhip %s\n", args); + resp_len = monitor_expect_prompt (buf, sizeof (buf)); + /* now parse the result for success */ + } + else + error ("Requires argument (IP address of GDB's host computer)"); +} + +/* Function: set_download_path + Tell the BootOne monitor the default path for downloadable SREC files. */ + +static void +m32r_set_download_path (char *args, int from_tty) +{ + int resp_len; + char buf[1024]; + + if (args && *args) + { + monitor_printf ("up %s\n", args); + resp_len = monitor_expect_prompt (buf, sizeof (buf)); + /* now parse the result for success */ + } + else + error ("Requires argument (default path for downloadable SREC files)"); +} + +static void +m32r_upload_command (char *args, int from_tty) +{ + bfd *abfd; + asection *s; + time_t start_time, end_time; /* for timing of download */ + int resp_len, data_count = 0; + char buf[1024]; + struct hostent *hostent; + struct in_addr inet_addr; + + /* first check to see if there's an ethernet port! */ + monitor_printf ("ust\r"); + resp_len = monitor_expect_prompt (buf, sizeof (buf)); + if (!strchr (buf, ':')) + error ("No ethernet connection!"); + + if (board_addr == 0) + { + /* scan second colon in the output from the "ust" command */ + char *myIPaddress = strchr (strchr (buf, ':') + 1, ':') + 1; + + while (isspace (*myIPaddress)) + myIPaddress++; + + if (!strncmp (myIPaddress, "0.0.", 4)) /* empty */ + error + ("Please use 'set board-address' to set the M32R-EVA board's IP address."); + if (strchr (myIPaddress, '(')) + *(strchr (myIPaddress, '(')) = '\0'; /* delete trailing junk */ + board_addr = xstrdup (myIPaddress); + } + if (server_addr == 0) + { + buf[0] = 0; + gethostname (buf, sizeof (buf)); + if (buf[0] != 0) + hostent = gethostbyname (buf); + if (hostent != 0) + { +#if 1 + memcpy (&inet_addr.s_addr, hostent->h_addr, + sizeof (inet_addr.s_addr)); + server_addr = (char *) inet_ntoa (inet_addr); +#else + server_addr = (char *) inet_ntoa (hostent->h_addr); +#endif + } + if (server_addr == 0) /* failed? */ + error + ("Need to know gdb host computer's IP address (use 'set server-address')"); + } + + if (args == 0 || args[0] == 0) /* no args: upload the current file */ + args = get_exec_file (1); + + if (args[0] != '/' && download_path == 0) + { + if (current_directory) + download_path = xstrdup (current_directory); + else + error + ("Need to know default download path (use 'set download-path')"); + } + + start_time = time (NULL); + monitor_printf ("uhip %s\r", server_addr); + resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ + monitor_printf ("ulip %s\r", board_addr); + resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ + if (args[0] != '/') + monitor_printf ("up %s\r", download_path); /* use default path */ + else + monitor_printf ("up\r"); /* rooted filename/path */ + resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ + + if (strrchr (args, '.') && !strcmp (strrchr (args, '.'), ".srec")) + monitor_printf ("ul %s\r", args); + else /* add ".srec" suffix */ + monitor_printf ("ul %s.srec\r", args); + resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ + + if (buf[0] == 0 || strstr (buf, "complete") == 0) + error + ("Upload file not found: %s.srec\nCheck IP addresses and download path.", + args); + else + printf_filtered (" -- Ethernet load complete.\n"); + + end_time = time (NULL); + abfd = bfd_openr (args, 0); + if (abfd != NULL) + { /* Download is done -- print section statistics */ + if (bfd_check_format (abfd, bfd_object) == 0) + { + printf_filtered ("File is not an object file\n"); + } + for (s = abfd->sections; s; s = s->next) + if (s->flags & SEC_LOAD) + { + bfd_size_type section_size = bfd_section_size (abfd, s); + bfd_vma section_base = bfd_section_lma (abfd, s); + unsigned int buffer; + + data_count += section_size; + + printf_filtered ("Loading section %s, size 0x%lx lma ", + bfd_section_name (abfd, s), section_size); + print_address_numeric (section_base, 1, gdb_stdout); + printf_filtered ("\n"); + gdb_flush (gdb_stdout); + } + /* Finally, make the PC point at the start address */ + write_pc (bfd_get_start_address (abfd)); + report_transfer_performance (data_count, start_time, end_time); + printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd)); + } + inferior_ptid = null_ptid; /* No process now */ + + /* This is necessary because many things were based on the PC at the + time that we attached to the monitor, which is no longer valid + now that we have loaded new code (and just changed the PC). + Another way to do this might be to call normal_stop, except that + the stack may not be valid, and things would get horribly + confused... */ + + clear_symtab_users (); +} + +void +_initialize_m32r_rom (void) +{ + /* Initialize m32r RevC monitor target */ + init_m32r_cmds (); + init_monitor_ops (&m32r_ops); + + m32r_ops.to_shortname = "m32r"; + m32r_ops.to_longname = "m32r monitor"; + m32r_ops.to_load = m32r_load_gen; /* monitor lacks a download command */ + m32r_ops.to_doc = "Debug via the m32r monitor.\n\ +Specify the serial device it is connected to (e.g. /dev/ttya)."; + m32r_ops.to_open = m32r_open; + add_target (&m32r_ops); + + /* Initialize mon2000 monitor target */ + init_mon2000_cmds (); + init_monitor_ops (&mon2000_ops); + + mon2000_ops.to_shortname = "mon2000"; + mon2000_ops.to_longname = "Mon2000 monitor"; + mon2000_ops.to_load = m32r_load_gen; /* monitor lacks a download command */ + mon2000_ops.to_doc = "Debug via the Mon2000 monitor.\n\ +Specify the serial device it is connected to (e.g. /dev/ttya)."; + mon2000_ops.to_open = mon2000_open; + add_target (&mon2000_ops); + + add_show_from_set + (add_set_cmd ("download-path", class_obscure, var_string, + (char *) &download_path, + "Set the default path for downloadable SREC files.", + &setlist), &showlist); + + add_show_from_set + (add_set_cmd ("board-address", class_obscure, var_string, + (char *) &board_addr, + "Set IP address for M32R-EVA target board.", + &setlist), &showlist); + + add_show_from_set + (add_set_cmd ("server-address", class_obscure, var_string, + (char *) &server_addr, + "Set IP address for download server (GDB's host computer).", + &setlist), &showlist); + + add_com ("upload", class_obscure, m32r_upload_command, + "Upload the srec file via the monitor's Ethernet upload capability."); + + add_com ("tload", class_obscure, m32r_load, "test upload command."); +} diff --git a/gdb/m32r-stub.c b/gdb/m32r-stub.c index d9be3eb..c7033ea 100644 --- a/gdb/m32r-stub.c +++ b/gdb/m32r-stub.c @@ -1,1718 +1,1779 @@ -// OBSOLETE /**************************************************************************** -// OBSOLETE -// OBSOLETE THIS SOFTWARE IS NOT COPYRIGHTED -// OBSOLETE -// OBSOLETE HP offers the following for use in the public domain. HP makes no -// OBSOLETE warranty with regard to the software or it's performance and the -// OBSOLETE user accepts the software "AS IS" with all faults. -// OBSOLETE -// OBSOLETE HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD -// OBSOLETE TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES -// OBSOLETE OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. -// OBSOLETE -// OBSOLETE ****************************************************************************/ -// OBSOLETE -// OBSOLETE /**************************************************************************** -// OBSOLETE * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $ -// OBSOLETE * -// OBSOLETE * Module name: remcom.c $ -// OBSOLETE * Revision: 1.34 $ -// OBSOLETE * Date: 91/03/09 12:29:49 $ -// OBSOLETE * Contributor: Lake Stevens Instrument Division$ -// OBSOLETE * -// OBSOLETE * Description: low level support for gdb debugger. $ -// OBSOLETE * -// OBSOLETE * Considerations: only works on target hardware $ -// OBSOLETE * -// OBSOLETE * Written by: Glenn Engel $ -// OBSOLETE * ModuleState: Experimental $ -// OBSOLETE * -// OBSOLETE * NOTES: See Below $ -// OBSOLETE * -// OBSOLETE * Modified for M32R by Michael Snyder, Cygnus Support. -// OBSOLETE * -// OBSOLETE * To enable debugger support, two things need to happen. One, a -// OBSOLETE * call to set_debug_traps() is necessary in order to allow any breakpoints -// OBSOLETE * or error conditions to be properly intercepted and reported to gdb. -// OBSOLETE * Two, a breakpoint needs to be generated to begin communication. This -// OBSOLETE * is most easily accomplished by a call to breakpoint(). Breakpoint() -// OBSOLETE * simulates a breakpoint by executing a trap #1. -// OBSOLETE * -// OBSOLETE * The external function exceptionHandler() is -// OBSOLETE * used to attach a specific handler to a specific M32R vector number. -// OBSOLETE * It should use the same privilege level it runs at. It should -// OBSOLETE * install it as an interrupt gate so that interrupts are masked -// OBSOLETE * while the handler runs. -// OBSOLETE * -// OBSOLETE * Because gdb will sometimes write to the stack area to execute function -// OBSOLETE * calls, this program cannot rely on using the supervisor stack so it -// OBSOLETE * uses it's own stack area reserved in the int array remcomStack. -// OBSOLETE * -// OBSOLETE ************* -// OBSOLETE * -// OBSOLETE * The following gdb commands are supported: -// OBSOLETE * -// OBSOLETE * command function Return value -// OBSOLETE * -// OBSOLETE * g return the value of the CPU registers hex data or ENN -// OBSOLETE * G set the value of the CPU registers OK or ENN -// OBSOLETE * -// OBSOLETE * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN -// OBSOLETE * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN -// OBSOLETE * XAA..AA,LLLL: Write LLLL binary bytes at address OK or ENN -// OBSOLETE * AA..AA -// OBSOLETE * -// OBSOLETE * c Resume at current address SNN ( signal NN) -// OBSOLETE * cAA..AA Continue at address AA..AA SNN -// OBSOLETE * -// OBSOLETE * s Step one instruction SNN -// OBSOLETE * sAA..AA Step one instruction from AA..AA SNN -// OBSOLETE * -// OBSOLETE * k kill -// OBSOLETE * -// OBSOLETE * ? What was the last sigval ? SNN (signal NN) -// OBSOLETE * -// OBSOLETE * All commands and responses are sent with a packet which includes a -// OBSOLETE * checksum. A packet consists of -// OBSOLETE * -// OBSOLETE * $<packet info>#<checksum>. -// OBSOLETE * -// OBSOLETE * where -// OBSOLETE * <packet info> :: <characters representing the command or response> -// OBSOLETE * <checksum> :: <two hex digits computed as modulo 256 sum of <packetinfo>> -// OBSOLETE * -// OBSOLETE * When a packet is received, it is first acknowledged with either '+' or '-'. -// OBSOLETE * '+' indicates a successful transfer. '-' indicates a failed transfer. -// OBSOLETE * -// OBSOLETE * Example: -// OBSOLETE * -// OBSOLETE * Host: Reply: -// OBSOLETE * $m0,10#2a +$00010203040506070809101112131415#42 -// OBSOLETE * -// OBSOLETE ****************************************************************************/ -// OBSOLETE -// OBSOLETE -// OBSOLETE /************************************************************************ -// OBSOLETE * -// OBSOLETE * external low-level support routines -// OBSOLETE */ -// OBSOLETE extern void putDebugChar(); /* write a single character */ -// OBSOLETE extern int getDebugChar(); /* read and return a single char */ -// OBSOLETE extern void exceptionHandler(); /* assign an exception handler */ -// OBSOLETE -// OBSOLETE /***************************************************************************** -// OBSOLETE * BUFMAX defines the maximum number of characters in inbound/outbound buffers -// OBSOLETE * at least NUMREGBYTES*2 are needed for register packets -// OBSOLETE */ -// OBSOLETE #define BUFMAX 400 -// OBSOLETE -// OBSOLETE static char initialized; /* boolean flag. != 0 means we've been initialized */ -// OBSOLETE -// OBSOLETE int remote_debug; -// OBSOLETE /* debug > 0 prints ill-formed commands in valid packets & checksum errors */ -// OBSOLETE -// OBSOLETE static const unsigned char hexchars[]="0123456789abcdef"; -// OBSOLETE -// OBSOLETE #define NUMREGS 24 -// OBSOLETE -// OBSOLETE /* Number of bytes of registers. */ -// OBSOLETE #define NUMREGBYTES (NUMREGS * 4) -// OBSOLETE enum regnames { R0, R1, R2, R3, R4, R5, R6, R7, -// OBSOLETE R8, R9, R10, R11, R12, R13, R14, R15, -// OBSOLETE PSW, CBR, SPI, SPU, BPC, PC, ACCL, ACCH }; -// OBSOLETE -// OBSOLETE enum SYS_calls { -// OBSOLETE SYS_null, -// OBSOLETE SYS_exit, -// OBSOLETE SYS_open, -// OBSOLETE SYS_close, -// OBSOLETE SYS_read, -// OBSOLETE SYS_write, -// OBSOLETE SYS_lseek, -// OBSOLETE SYS_unlink, -// OBSOLETE SYS_getpid, -// OBSOLETE SYS_kill, -// OBSOLETE SYS_fstat, -// OBSOLETE SYS_sbrk, -// OBSOLETE SYS_fork, -// OBSOLETE SYS_execve, -// OBSOLETE SYS_wait4, -// OBSOLETE SYS_link, -// OBSOLETE SYS_chdir, -// OBSOLETE SYS_stat, -// OBSOLETE SYS_utime, -// OBSOLETE SYS_chown, -// OBSOLETE SYS_chmod, -// OBSOLETE SYS_time, -// OBSOLETE SYS_pipe }; -// OBSOLETE -// OBSOLETE static int registers[NUMREGS]; -// OBSOLETE -// OBSOLETE #define STACKSIZE 8096 -// OBSOLETE static unsigned char remcomInBuffer[BUFMAX]; -// OBSOLETE static unsigned char remcomOutBuffer[BUFMAX]; -// OBSOLETE static int remcomStack[STACKSIZE/sizeof(int)]; -// OBSOLETE static int* stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1]; -// OBSOLETE -// OBSOLETE static unsigned int save_vectors[18]; /* previous exception vectors */ -// OBSOLETE -// OBSOLETE /* Indicate to caller of mem2hex or hex2mem that there has been an error. */ -// OBSOLETE static volatile int mem_err = 0; -// OBSOLETE -// OBSOLETE /* Store the vector number here (since GDB only gets the signal -// OBSOLETE number through the usual means, and that's not very specific). */ -// OBSOLETE int gdb_m32r_vector = -1; -// OBSOLETE -// OBSOLETE #if 0 -// OBSOLETE #include "syscall.h" /* for SYS_exit, SYS_write etc. */ -// OBSOLETE #endif -// OBSOLETE -// OBSOLETE /* Global entry points: -// OBSOLETE */ -// OBSOLETE -// OBSOLETE extern void handle_exception(int); -// OBSOLETE extern void set_debug_traps(void); -// OBSOLETE extern void breakpoint(void); -// OBSOLETE -// OBSOLETE /* Local functions: -// OBSOLETE */ -// OBSOLETE -// OBSOLETE static int computeSignal(int); -// OBSOLETE static void putpacket(unsigned char *); -// OBSOLETE static unsigned char *getpacket(void); -// OBSOLETE -// OBSOLETE static unsigned char *mem2hex(unsigned char *, unsigned char *, int, int); -// OBSOLETE static unsigned char *hex2mem(unsigned char *, unsigned char *, int, int); -// OBSOLETE static int hexToInt(unsigned char **, int *); -// OBSOLETE static unsigned char *bin2mem(unsigned char *, unsigned char *, int, int); -// OBSOLETE static void stash_registers(void); -// OBSOLETE static void restore_registers(void); -// OBSOLETE static int prepare_to_step(int); -// OBSOLETE static int finish_from_step(void); -// OBSOLETE static unsigned long crc32 (unsigned char *, int, unsigned long); -// OBSOLETE -// OBSOLETE static void gdb_error(char *, char *); -// OBSOLETE static int gdb_putchar(int), gdb_puts(char *), gdb_write(char *, int); -// OBSOLETE -// OBSOLETE static unsigned char *strcpy (unsigned char *, const unsigned char *); -// OBSOLETE static int strlen (const unsigned char *); -// OBSOLETE -// OBSOLETE /* -// OBSOLETE * This function does all command procesing for interfacing to gdb. -// OBSOLETE */ -// OBSOLETE -// OBSOLETE void -// OBSOLETE handle_exception(int exceptionVector) -// OBSOLETE { -// OBSOLETE int sigval, stepping; -// OBSOLETE int addr, length, i; -// OBSOLETE unsigned char * ptr; -// OBSOLETE unsigned char buf[16]; -// OBSOLETE int binary; -// OBSOLETE -// OBSOLETE /* Do not call finish_from_step() if this is not a trap #1 -// OBSOLETE * (breakpoint trap). Without this check, the finish_from_step() -// OBSOLETE * might interpret a system call trap as a single step trap. This -// OBSOLETE * can happen if: the stub receives 's' and exits, but an interrupt -// OBSOLETE * was pending; the interrupt is now handled and causes the stub to -// OBSOLETE * be reentered because some function makes a system call. -// OBSOLETE */ -// OBSOLETE if (exceptionVector == 1) /* Trap exception? */ -// OBSOLETE if (!finish_from_step()) /* Go see if stepping state needs update. */ -// OBSOLETE return; /* "false step": let the target continue */ -// OBSOLETE -// OBSOLETE gdb_m32r_vector = exceptionVector; -// OBSOLETE -// OBSOLETE if (remote_debug) -// OBSOLETE { -// OBSOLETE mem2hex((unsigned char *) &exceptionVector, buf, 4, 0); -// OBSOLETE gdb_error("Handle exception %s, ", buf); -// OBSOLETE mem2hex((unsigned char *) ®isters[PC], buf, 4, 0); -// OBSOLETE gdb_error("PC == 0x%s\n", buf); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* reply to host that an exception has occurred */ -// OBSOLETE sigval = computeSignal( exceptionVector ); -// OBSOLETE -// OBSOLETE ptr = remcomOutBuffer; -// OBSOLETE -// OBSOLETE *ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */ -// OBSOLETE *ptr++ = hexchars[sigval >> 4]; -// OBSOLETE *ptr++ = hexchars[sigval & 0xf]; -// OBSOLETE -// OBSOLETE *ptr++ = hexchars[PC >> 4]; -// OBSOLETE *ptr++ = hexchars[PC & 0xf]; -// OBSOLETE *ptr++ = ':'; -// OBSOLETE ptr = mem2hex((unsigned char *)®isters[PC], ptr, 4, 0); /* PC */ -// OBSOLETE *ptr++ = ';'; -// OBSOLETE -// OBSOLETE *ptr++ = hexchars[R13 >> 4]; -// OBSOLETE *ptr++ = hexchars[R13 & 0xf]; -// OBSOLETE *ptr++ = ':'; -// OBSOLETE ptr = mem2hex((unsigned char *)®isters[R13], ptr, 4, 0); /* FP */ -// OBSOLETE *ptr++ = ';'; -// OBSOLETE -// OBSOLETE *ptr++ = hexchars[R15 >> 4]; -// OBSOLETE *ptr++ = hexchars[R15 & 0xf]; -// OBSOLETE *ptr++ = ':'; -// OBSOLETE ptr = mem2hex((unsigned char *)®isters[R15], ptr, 4, 0); /* SP */ -// OBSOLETE *ptr++ = ';'; -// OBSOLETE *ptr++ = 0; -// OBSOLETE -// OBSOLETE if (exceptionVector == 0) /* simulated SYS call stuff */ -// OBSOLETE { -// OBSOLETE mem2hex((unsigned char *) ®isters[PC], buf, 4, 0); -// OBSOLETE switch (registers[R0]) { -// OBSOLETE case SYS_exit: -// OBSOLETE gdb_error("Target program has exited at %s\n", buf); -// OBSOLETE ptr = remcomOutBuffer; -// OBSOLETE *ptr++ = 'W'; -// OBSOLETE sigval = registers[R1] & 0xff; -// OBSOLETE *ptr++ = hexchars[sigval >> 4]; -// OBSOLETE *ptr++ = hexchars[sigval & 0xf]; -// OBSOLETE *ptr++ = 0; -// OBSOLETE break; -// OBSOLETE case SYS_open: -// OBSOLETE gdb_error("Target attempts SYS_open call at %s\n", buf); -// OBSOLETE break; -// OBSOLETE case SYS_close: -// OBSOLETE gdb_error("Target attempts SYS_close call at %s\n", buf); -// OBSOLETE break; -// OBSOLETE case SYS_read: -// OBSOLETE gdb_error("Target attempts SYS_read call at %s\n", buf); -// OBSOLETE break; -// OBSOLETE case SYS_write: -// OBSOLETE if (registers[R1] == 1 || /* write to stdout */ -// OBSOLETE registers[R1] == 2) /* write to stderr */ -// OBSOLETE { /* (we can do that) */ -// OBSOLETE registers[R0] = gdb_write((void *) registers[R2], registers[R3]); -// OBSOLETE return; -// OBSOLETE } -// OBSOLETE else -// OBSOLETE gdb_error("Target attempts SYS_write call at %s\n", buf); -// OBSOLETE break; -// OBSOLETE case SYS_lseek: -// OBSOLETE gdb_error("Target attempts SYS_lseek call at %s\n", buf); -// OBSOLETE break; -// OBSOLETE case SYS_unlink: -// OBSOLETE gdb_error("Target attempts SYS_unlink call at %s\n", buf); -// OBSOLETE break; -// OBSOLETE case SYS_getpid: -// OBSOLETE gdb_error("Target attempts SYS_getpid call at %s\n", buf); -// OBSOLETE break; -// OBSOLETE case SYS_kill: -// OBSOLETE gdb_error("Target attempts SYS_kill call at %s\n", buf); -// OBSOLETE break; -// OBSOLETE case SYS_fstat: -// OBSOLETE gdb_error("Target attempts SYS_fstat call at %s\n", buf); -// OBSOLETE break; -// OBSOLETE default: -// OBSOLETE gdb_error("Target attempts unknown SYS call at %s\n", buf); -// OBSOLETE break; -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE putpacket(remcomOutBuffer); -// OBSOLETE -// OBSOLETE stepping = 0; -// OBSOLETE -// OBSOLETE while (1==1) { -// OBSOLETE remcomOutBuffer[0] = 0; -// OBSOLETE ptr = getpacket(); -// OBSOLETE binary = 0; -// OBSOLETE switch (*ptr++) { -// OBSOLETE default: /* Unknown code. Return an empty reply message. */ -// OBSOLETE break; -// OBSOLETE case 'R': -// OBSOLETE if (hexToInt (&ptr, &addr)) -// OBSOLETE registers[PC] = addr; -// OBSOLETE strcpy(remcomOutBuffer, "OK"); -// OBSOLETE break; -// OBSOLETE case '!': -// OBSOLETE strcpy(remcomOutBuffer, "OK"); -// OBSOLETE break; -// OBSOLETE case 'X': /* XAA..AA,LLLL:<binary data>#cs */ -// OBSOLETE binary = 1; -// OBSOLETE case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ -// OBSOLETE /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */ -// OBSOLETE { -// OBSOLETE if (hexToInt(&ptr,&addr)) -// OBSOLETE if (*(ptr++) == ',') -// OBSOLETE if (hexToInt(&ptr,&length)) -// OBSOLETE if (*(ptr++) == ':') -// OBSOLETE { -// OBSOLETE mem_err = 0; -// OBSOLETE if (binary) -// OBSOLETE bin2mem (ptr, (unsigned char *) addr, length, 1); -// OBSOLETE else -// OBSOLETE hex2mem(ptr, (unsigned char*) addr, length, 1); -// OBSOLETE if (mem_err) { -// OBSOLETE strcpy (remcomOutBuffer, "E03"); -// OBSOLETE gdb_error ("memory fault", ""); -// OBSOLETE } else { -// OBSOLETE strcpy(remcomOutBuffer,"OK"); -// OBSOLETE } -// OBSOLETE ptr = 0; -// OBSOLETE } -// OBSOLETE if (ptr) -// OBSOLETE { -// OBSOLETE strcpy(remcomOutBuffer,"E02"); -// OBSOLETE } -// OBSOLETE } -// OBSOLETE break; -// OBSOLETE case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ -// OBSOLETE /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */ -// OBSOLETE if (hexToInt(&ptr,&addr)) -// OBSOLETE if (*(ptr++) == ',') -// OBSOLETE if (hexToInt(&ptr,&length)) -// OBSOLETE { -// OBSOLETE ptr = 0; -// OBSOLETE mem_err = 0; -// OBSOLETE mem2hex((unsigned char*) addr, remcomOutBuffer, length, 1); -// OBSOLETE if (mem_err) { -// OBSOLETE strcpy (remcomOutBuffer, "E03"); -// OBSOLETE gdb_error ("memory fault", ""); -// OBSOLETE } -// OBSOLETE } -// OBSOLETE if (ptr) -// OBSOLETE { -// OBSOLETE strcpy(remcomOutBuffer,"E01"); -// OBSOLETE } -// OBSOLETE break; -// OBSOLETE case '?': -// OBSOLETE remcomOutBuffer[0] = 'S'; -// OBSOLETE remcomOutBuffer[1] = hexchars[sigval >> 4]; -// OBSOLETE remcomOutBuffer[2] = hexchars[sigval % 16]; -// OBSOLETE remcomOutBuffer[3] = 0; -// OBSOLETE break; -// OBSOLETE case 'd': -// OBSOLETE remote_debug = !(remote_debug); /* toggle debug flag */ -// OBSOLETE break; -// OBSOLETE case 'g': /* return the value of the CPU registers */ -// OBSOLETE mem2hex((unsigned char*) registers, remcomOutBuffer, NUMREGBYTES, 0); -// OBSOLETE break; -// OBSOLETE case 'P': /* set the value of a single CPU register - return OK */ -// OBSOLETE { -// OBSOLETE int regno; -// OBSOLETE -// OBSOLETE if (hexToInt (&ptr, ®no) && *ptr++ == '=') -// OBSOLETE if (regno >= 0 && regno < NUMREGS) -// OBSOLETE { -// OBSOLETE int stackmode; -// OBSOLETE -// OBSOLETE hex2mem (ptr, (unsigned char *) ®isters[regno], 4, 0); -// OBSOLETE /* -// OBSOLETE * Since we just changed a single CPU register, let's -// OBSOLETE * make sure to keep the several stack pointers consistant. -// OBSOLETE */ -// OBSOLETE stackmode = registers[PSW] & 0x80; -// OBSOLETE if (regno == R15) /* stack pointer changed */ -// OBSOLETE { /* need to change SPI or SPU */ -// OBSOLETE if (stackmode == 0) -// OBSOLETE registers[SPI] = registers[R15]; -// OBSOLETE else -// OBSOLETE registers[SPU] = registers[R15]; -// OBSOLETE } -// OBSOLETE else if (regno == SPU) /* "user" stack pointer changed */ -// OBSOLETE { -// OBSOLETE if (stackmode != 0) /* stack in user mode: copy SP */ -// OBSOLETE registers[R15] = registers[SPU]; -// OBSOLETE } -// OBSOLETE else if (regno == SPI) /* "interrupt" stack pointer changed */ -// OBSOLETE { -// OBSOLETE if (stackmode == 0) /* stack in interrupt mode: copy SP */ -// OBSOLETE registers[R15] = registers[SPI]; -// OBSOLETE } -// OBSOLETE else if (regno == PSW) /* stack mode may have changed! */ -// OBSOLETE { /* force SP to either SPU or SPI */ -// OBSOLETE if (stackmode == 0) /* stack in user mode */ -// OBSOLETE registers[R15] = registers[SPI]; -// OBSOLETE else /* stack in interrupt mode */ -// OBSOLETE registers[R15] = registers[SPU]; -// OBSOLETE } -// OBSOLETE strcpy (remcomOutBuffer, "OK"); -// OBSOLETE break; -// OBSOLETE } -// OBSOLETE strcpy (remcomOutBuffer, "E01"); -// OBSOLETE break; -// OBSOLETE } -// OBSOLETE case 'G': /* set the value of the CPU registers - return OK */ -// OBSOLETE hex2mem(ptr, (unsigned char*) registers, NUMREGBYTES, 0); -// OBSOLETE strcpy(remcomOutBuffer,"OK"); -// OBSOLETE break; -// OBSOLETE case 's': /* sAA..AA Step one instruction from AA..AA(optional) */ -// OBSOLETE stepping = 1; -// OBSOLETE case 'c': /* cAA..AA Continue from address AA..AA(optional) */ -// OBSOLETE /* try to read optional parameter, pc unchanged if no parm */ -// OBSOLETE if (hexToInt(&ptr,&addr)) -// OBSOLETE registers[ PC ] = addr; -// OBSOLETE -// OBSOLETE if (stepping) /* single-stepping */ -// OBSOLETE { -// OBSOLETE if (!prepare_to_step(0)) /* set up for single-step */ -// OBSOLETE { -// OBSOLETE /* prepare_to_step has already emulated the target insn: -// OBSOLETE Send SIGTRAP to gdb, don't resume the target at all. */ -// OBSOLETE ptr = remcomOutBuffer; -// OBSOLETE *ptr++ = 'T'; /* Simulate stopping with SIGTRAP */ -// OBSOLETE *ptr++ = '0'; -// OBSOLETE *ptr++ = '5'; -// OBSOLETE -// OBSOLETE *ptr++ = hexchars[PC >> 4]; /* send PC */ -// OBSOLETE *ptr++ = hexchars[PC & 0xf]; -// OBSOLETE *ptr++ = ':'; -// OBSOLETE ptr = mem2hex((unsigned char *)®isters[PC], ptr, 4, 0); -// OBSOLETE *ptr++ = ';'; -// OBSOLETE -// OBSOLETE *ptr++ = hexchars[R13 >> 4]; /* send FP */ -// OBSOLETE *ptr++ = hexchars[R13 & 0xf]; -// OBSOLETE *ptr++ = ':'; -// OBSOLETE ptr = mem2hex((unsigned char *)®isters[R13], ptr, 4, 0); -// OBSOLETE *ptr++ = ';'; -// OBSOLETE -// OBSOLETE *ptr++ = hexchars[R15 >> 4]; /* send SP */ -// OBSOLETE *ptr++ = hexchars[R15 & 0xf]; -// OBSOLETE *ptr++ = ':'; -// OBSOLETE ptr = mem2hex((unsigned char *)®isters[R15], ptr, 4, 0); -// OBSOLETE *ptr++ = ';'; -// OBSOLETE *ptr++ = 0; -// OBSOLETE -// OBSOLETE break; -// OBSOLETE } -// OBSOLETE } -// OBSOLETE else /* continuing, not single-stepping */ -// OBSOLETE { -// OBSOLETE /* OK, about to do a "continue". First check to see if the -// OBSOLETE target pc is on an odd boundary (second instruction in the -// OBSOLETE word). If so, we must do a single-step first, because -// OBSOLETE ya can't jump or return back to an odd boundary! */ -// OBSOLETE if ((registers[PC] & 2) != 0) -// OBSOLETE prepare_to_step(1); -// OBSOLETE } -// OBSOLETE -// OBSOLETE return; -// OBSOLETE -// OBSOLETE case 'D': /* Detach */ -// OBSOLETE #if 0 -// OBSOLETE /* I am interpreting this to mean, release the board from control -// OBSOLETE by the remote stub. To do this, I am restoring the original -// OBSOLETE (or at least previous) exception vectors. -// OBSOLETE */ -// OBSOLETE for (i = 0; i < 18; i++) -// OBSOLETE exceptionHandler (i, save_vectors[i]); -// OBSOLETE putpacket ("OK"); -// OBSOLETE return; /* continue the inferior */ -// OBSOLETE #else -// OBSOLETE strcpy(remcomOutBuffer,"OK"); -// OBSOLETE break; -// OBSOLETE #endif -// OBSOLETE case 'q': -// OBSOLETE if (*ptr++ == 'C' && -// OBSOLETE *ptr++ == 'R' && -// OBSOLETE *ptr++ == 'C' && -// OBSOLETE *ptr++ == ':') -// OBSOLETE { -// OBSOLETE unsigned long start, len, our_crc; -// OBSOLETE -// OBSOLETE if (hexToInt (&ptr, (int *) &start) && -// OBSOLETE *ptr++ == ',' && -// OBSOLETE hexToInt (&ptr, (int *) &len)) -// OBSOLETE { -// OBSOLETE remcomOutBuffer[0] = 'C'; -// OBSOLETE our_crc = crc32 ((unsigned char *) start, len, 0xffffffff); -// OBSOLETE mem2hex ((char *) &our_crc, -// OBSOLETE &remcomOutBuffer[1], -// OBSOLETE sizeof (long), -// OBSOLETE 0); -// OBSOLETE } /* else do nothing */ -// OBSOLETE } /* else do nothing */ -// OBSOLETE break; -// OBSOLETE -// OBSOLETE case 'k': /* kill the program */ -// OBSOLETE continue; -// OBSOLETE } /* switch */ -// OBSOLETE -// OBSOLETE /* reply to the request */ -// OBSOLETE putpacket(remcomOutBuffer); -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* qCRC support */ -// OBSOLETE -// OBSOLETE /* Table used by the crc32 function to calcuate the checksum. */ -// OBSOLETE static unsigned long crc32_table[256] = {0, 0}; -// OBSOLETE -// OBSOLETE static unsigned long -// OBSOLETE crc32 (unsigned char *buf, int len, unsigned long crc) -// OBSOLETE { -// OBSOLETE if (! crc32_table[1]) -// OBSOLETE { -// OBSOLETE /* Initialize the CRC table and the decoding table. */ -// OBSOLETE int i, j; -// OBSOLETE unsigned long c; -// OBSOLETE -// OBSOLETE for (i = 0; i < 256; i++) -// OBSOLETE { -// OBSOLETE for (c = i << 24, j = 8; j > 0; --j) -// OBSOLETE c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); -// OBSOLETE crc32_table[i] = c; -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE while (len--) -// OBSOLETE { -// OBSOLETE crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255]; -// OBSOLETE buf++; -// OBSOLETE } -// OBSOLETE return crc; -// OBSOLETE } -// OBSOLETE -// OBSOLETE static int -// OBSOLETE hex (unsigned char ch) -// OBSOLETE { -// OBSOLETE if ((ch >= 'a') && (ch <= 'f')) return (ch-'a'+10); -// OBSOLETE if ((ch >= '0') && (ch <= '9')) return (ch-'0'); -// OBSOLETE if ((ch >= 'A') && (ch <= 'F')) return (ch-'A'+10); -// OBSOLETE return (-1); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* scan for the sequence $<data>#<checksum> */ -// OBSOLETE -// OBSOLETE unsigned char * -// OBSOLETE getpacket (void) -// OBSOLETE { -// OBSOLETE unsigned char *buffer = &remcomInBuffer[0]; -// OBSOLETE unsigned char checksum; -// OBSOLETE unsigned char xmitcsum; -// OBSOLETE int count; -// OBSOLETE char ch; -// OBSOLETE -// OBSOLETE while (1) -// OBSOLETE { -// OBSOLETE /* wait around for the start character, ignore all other characters */ -// OBSOLETE while ((ch = getDebugChar ()) != '$') -// OBSOLETE ; -// OBSOLETE -// OBSOLETE retry: -// OBSOLETE checksum = 0; -// OBSOLETE xmitcsum = -1; -// OBSOLETE count = 0; -// OBSOLETE -// OBSOLETE /* now, read until a # or end of buffer is found */ -// OBSOLETE while (count < BUFMAX) -// OBSOLETE { -// OBSOLETE ch = getDebugChar (); -// OBSOLETE if (ch == '$') -// OBSOLETE goto retry; -// OBSOLETE if (ch == '#') -// OBSOLETE break; -// OBSOLETE checksum = checksum + ch; -// OBSOLETE buffer[count] = ch; -// OBSOLETE count = count + 1; -// OBSOLETE } -// OBSOLETE buffer[count] = 0; -// OBSOLETE -// OBSOLETE if (ch == '#') -// OBSOLETE { -// OBSOLETE ch = getDebugChar (); -// OBSOLETE xmitcsum = hex (ch) << 4; -// OBSOLETE ch = getDebugChar (); -// OBSOLETE xmitcsum += hex (ch); -// OBSOLETE -// OBSOLETE if (checksum != xmitcsum) -// OBSOLETE { -// OBSOLETE if (remote_debug) -// OBSOLETE { -// OBSOLETE unsigned char buf[16]; -// OBSOLETE -// OBSOLETE mem2hex((unsigned char *) &checksum, buf, 4, 0); -// OBSOLETE gdb_error("Bad checksum: my count = %s, ", buf); -// OBSOLETE mem2hex((unsigned char *) &xmitcsum, buf, 4, 0); -// OBSOLETE gdb_error("sent count = %s\n", buf); -// OBSOLETE gdb_error(" -- Bad buffer: \"%s\"\n", buffer); -// OBSOLETE } -// OBSOLETE putDebugChar ('-'); /* failed checksum */ -// OBSOLETE } -// OBSOLETE else -// OBSOLETE { -// OBSOLETE putDebugChar ('+'); /* successful transfer */ -// OBSOLETE -// OBSOLETE /* if a sequence char is present, reply the sequence ID */ -// OBSOLETE if (buffer[2] == ':') -// OBSOLETE { -// OBSOLETE putDebugChar (buffer[0]); -// OBSOLETE putDebugChar (buffer[1]); -// OBSOLETE -// OBSOLETE return &buffer[3]; -// OBSOLETE } -// OBSOLETE -// OBSOLETE return &buffer[0]; -// OBSOLETE } -// OBSOLETE } -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* send the packet in buffer. */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE putpacket (unsigned char *buffer) -// OBSOLETE { -// OBSOLETE unsigned char checksum; -// OBSOLETE int count; -// OBSOLETE char ch; -// OBSOLETE -// OBSOLETE /* $<packet info>#<checksum>. */ -// OBSOLETE do { -// OBSOLETE putDebugChar('$'); -// OBSOLETE checksum = 0; -// OBSOLETE count = 0; -// OBSOLETE -// OBSOLETE while (ch=buffer[count]) { -// OBSOLETE putDebugChar(ch); -// OBSOLETE checksum += ch; -// OBSOLETE count += 1; -// OBSOLETE } -// OBSOLETE putDebugChar('#'); -// OBSOLETE putDebugChar(hexchars[checksum >> 4]); -// OBSOLETE putDebugChar(hexchars[checksum % 16]); -// OBSOLETE } while (getDebugChar() != '+'); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Address of a routine to RTE to if we get a memory fault. */ -// OBSOLETE -// OBSOLETE static void (*volatile mem_fault_routine)() = 0; -// OBSOLETE -// OBSOLETE static void -// OBSOLETE set_mem_err (void) -// OBSOLETE { -// OBSOLETE mem_err = 1; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Check the address for safe access ranges. As currently defined, -// OBSOLETE this routine will reject the "expansion bus" address range(s). -// OBSOLETE To make those ranges useable, someone must implement code to detect -// OBSOLETE whether there's anything connected to the expansion bus. */ -// OBSOLETE -// OBSOLETE static int -// OBSOLETE mem_safe (unsigned char *addr) -// OBSOLETE { -// OBSOLETE #define BAD_RANGE_ONE_START ((unsigned char *) 0x600000) -// OBSOLETE #define BAD_RANGE_ONE_END ((unsigned char *) 0xa00000) -// OBSOLETE #define BAD_RANGE_TWO_START ((unsigned char *) 0xff680000) -// OBSOLETE #define BAD_RANGE_TWO_END ((unsigned char *) 0xff800000) -// OBSOLETE -// OBSOLETE if (addr < BAD_RANGE_ONE_START) return 1; /* safe */ -// OBSOLETE if (addr < BAD_RANGE_ONE_END) return 0; /* unsafe */ -// OBSOLETE if (addr < BAD_RANGE_TWO_START) return 1; /* safe */ -// OBSOLETE if (addr < BAD_RANGE_TWO_END) return 0; /* unsafe */ -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* These are separate functions so that they are so short and sweet -// OBSOLETE that the compiler won't save any registers (if there is a fault -// OBSOLETE to mem_fault, they won't get restored, so there better not be any -// OBSOLETE saved). */ -// OBSOLETE static int -// OBSOLETE get_char (unsigned char *addr) -// OBSOLETE { -// OBSOLETE #if 1 -// OBSOLETE if (mem_fault_routine && !mem_safe(addr)) -// OBSOLETE { -// OBSOLETE mem_fault_routine (); -// OBSOLETE return 0; -// OBSOLETE } -// OBSOLETE #endif -// OBSOLETE return *addr; -// OBSOLETE } -// OBSOLETE -// OBSOLETE static void -// OBSOLETE set_char (unsigned char *addr, unsigned char val) -// OBSOLETE { -// OBSOLETE #if 1 -// OBSOLETE if (mem_fault_routine && !mem_safe (addr)) -// OBSOLETE { -// OBSOLETE mem_fault_routine (); -// OBSOLETE return; -// OBSOLETE } -// OBSOLETE #endif -// OBSOLETE *addr = val; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Convert the memory pointed to by mem into hex, placing result in buf. -// OBSOLETE Return a pointer to the last char put in buf (null). -// OBSOLETE If MAY_FAULT is non-zero, then we should set mem_err in response to -// OBSOLETE a fault; if zero treat a fault like any other fault in the stub. */ -// OBSOLETE -// OBSOLETE static unsigned char * -// OBSOLETE mem2hex (unsigned char *mem, unsigned char *buf, int count, int may_fault) -// OBSOLETE { -// OBSOLETE int i; -// OBSOLETE unsigned char ch; -// OBSOLETE -// OBSOLETE if (may_fault) -// OBSOLETE mem_fault_routine = set_mem_err; -// OBSOLETE for (i=0;i<count;i++) { -// OBSOLETE ch = get_char (mem++); -// OBSOLETE if (may_fault && mem_err) -// OBSOLETE return (buf); -// OBSOLETE *buf++ = hexchars[ch >> 4]; -// OBSOLETE *buf++ = hexchars[ch % 16]; -// OBSOLETE } -// OBSOLETE *buf = 0; -// OBSOLETE if (may_fault) -// OBSOLETE mem_fault_routine = 0; -// OBSOLETE return(buf); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Convert the hex array pointed to by buf into binary to be placed in mem. -// OBSOLETE Return a pointer to the character AFTER the last byte written. */ -// OBSOLETE -// OBSOLETE static unsigned char* -// OBSOLETE hex2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault) -// OBSOLETE { -// OBSOLETE int i; -// OBSOLETE unsigned char ch; -// OBSOLETE -// OBSOLETE if (may_fault) -// OBSOLETE mem_fault_routine = set_mem_err; -// OBSOLETE for (i=0;i<count;i++) { -// OBSOLETE ch = hex(*buf++) << 4; -// OBSOLETE ch = ch + hex(*buf++); -// OBSOLETE set_char (mem++, ch); -// OBSOLETE if (may_fault && mem_err) -// OBSOLETE return (mem); -// OBSOLETE } -// OBSOLETE if (may_fault) -// OBSOLETE mem_fault_routine = 0; -// OBSOLETE return(mem); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Convert the binary stream in BUF to memory. -// OBSOLETE -// OBSOLETE Gdb will escape $, #, and the escape char (0x7d). -// OBSOLETE COUNT is the total number of bytes to write into -// OBSOLETE memory. */ -// OBSOLETE static unsigned char * -// OBSOLETE bin2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault) -// OBSOLETE { -// OBSOLETE int i; -// OBSOLETE unsigned char ch; -// OBSOLETE -// OBSOLETE if (may_fault) -// OBSOLETE mem_fault_routine = set_mem_err; -// OBSOLETE for (i = 0; i < count; i++) -// OBSOLETE { -// OBSOLETE /* Check for any escaped characters. Be paranoid and -// OBSOLETE only unescape chars that should be escaped. */ -// OBSOLETE if (*buf == 0x7d) -// OBSOLETE { -// OBSOLETE switch (*(buf+1)) -// OBSOLETE { -// OBSOLETE case 0x3: /* # */ -// OBSOLETE case 0x4: /* $ */ -// OBSOLETE case 0x5d: /* escape char */ -// OBSOLETE buf++; -// OBSOLETE *buf |= 0x20; -// OBSOLETE break; -// OBSOLETE default: -// OBSOLETE /* nothing */ -// OBSOLETE break; -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE set_char (mem++, *buf++); -// OBSOLETE -// OBSOLETE if (may_fault && mem_err) -// OBSOLETE return mem; -// OBSOLETE } -// OBSOLETE -// OBSOLETE if (may_fault) -// OBSOLETE mem_fault_routine = 0; -// OBSOLETE return mem; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* this function takes the m32r exception vector and attempts to -// OBSOLETE translate this number into a unix compatible signal value */ -// OBSOLETE -// OBSOLETE static int -// OBSOLETE computeSignal (int exceptionVector) -// OBSOLETE { -// OBSOLETE int sigval; -// OBSOLETE switch (exceptionVector) { -// OBSOLETE case 0 : sigval = 23; break; /* I/O trap */ -// OBSOLETE case 1 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 2 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 3 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 4 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 5 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 6 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 7 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 8 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 9 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 10 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 11 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 12 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 13 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 14 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 15 : sigval = 5; break; /* breakpoint */ -// OBSOLETE case 16 : sigval = 10; break; /* BUS ERROR (alignment) */ -// OBSOLETE case 17 : sigval = 2; break; /* INTerrupt */ -// OBSOLETE default : sigval = 7; break; /* "software generated" */ -// OBSOLETE } -// OBSOLETE return (sigval); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /**********************************************/ -// OBSOLETE /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */ -// OBSOLETE /* RETURN NUMBER OF CHARS PROCESSED */ -// OBSOLETE /**********************************************/ -// OBSOLETE static int -// OBSOLETE hexToInt (unsigned char **ptr, int *intValue) -// OBSOLETE { -// OBSOLETE int numChars = 0; -// OBSOLETE int hexValue; -// OBSOLETE -// OBSOLETE *intValue = 0; -// OBSOLETE while (**ptr) -// OBSOLETE { -// OBSOLETE hexValue = hex(**ptr); -// OBSOLETE if (hexValue >=0) -// OBSOLETE { -// OBSOLETE *intValue = (*intValue <<4) | hexValue; -// OBSOLETE numChars ++; -// OBSOLETE } -// OBSOLETE else -// OBSOLETE break; -// OBSOLETE (*ptr)++; -// OBSOLETE } -// OBSOLETE return (numChars); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* -// OBSOLETE Table of branch instructions: -// OBSOLETE -// OBSOLETE 10B6 RTE return from trap or exception -// OBSOLETE 1FCr JMP jump -// OBSOLETE 1ECr JL jump and link -// OBSOLETE 7Fxx BRA branch -// OBSOLETE FFxxxxxx BRA branch (long) -// OBSOLETE B09rxxxx BNEZ branch not-equal-zero -// OBSOLETE Br1rxxxx BNE branch not-equal -// OBSOLETE 7Dxx BNC branch not-condition -// OBSOLETE FDxxxxxx BNC branch not-condition (long) -// OBSOLETE B0Arxxxx BLTZ branch less-than-zero -// OBSOLETE B0Crxxxx BLEZ branch less-equal-zero -// OBSOLETE 7Exx BL branch and link -// OBSOLETE FExxxxxx BL branch and link (long) -// OBSOLETE B0Drxxxx BGTZ branch greater-than-zero -// OBSOLETE B0Brxxxx BGEZ branch greater-equal-zero -// OBSOLETE B08rxxxx BEQZ branch equal-zero -// OBSOLETE Br0rxxxx BEQ branch equal -// OBSOLETE 7Cxx BC branch condition -// OBSOLETE FCxxxxxx BC branch condition (long) -// OBSOLETE */ -// OBSOLETE -// OBSOLETE static int -// OBSOLETE isShortBranch (unsigned char *instr) -// OBSOLETE { -// OBSOLETE unsigned char instr0 = instr[0] & 0x7F; /* mask off high bit */ -// OBSOLETE -// OBSOLETE if (instr0 == 0x10 && instr[1] == 0xB6) /* RTE */ -// OBSOLETE return 1; /* return from trap or exception */ -// OBSOLETE -// OBSOLETE if (instr0 == 0x1E || instr0 == 0x1F) /* JL or JMP */ -// OBSOLETE if ((instr[1] & 0xF0) == 0xC0) -// OBSOLETE return 2; /* jump thru a register */ -// OBSOLETE -// OBSOLETE if (instr0 == 0x7C || instr0 == 0x7D || /* BC, BNC, BL, BRA */ -// OBSOLETE instr0 == 0x7E || instr0 == 0x7F) -// OBSOLETE return 3; /* eight bit PC offset */ -// OBSOLETE -// OBSOLETE return 0; -// OBSOLETE } -// OBSOLETE -// OBSOLETE static int -// OBSOLETE isLongBranch (unsigned char *instr) -// OBSOLETE { -// OBSOLETE if (instr[0] == 0xFC || instr[0] == 0xFD || /* BRA, BNC, BL, BC */ -// OBSOLETE instr[0] == 0xFE || instr[0] == 0xFF) /* 24 bit relative */ -// OBSOLETE return 4; -// OBSOLETE if ((instr[0] & 0xF0) == 0xB0) /* 16 bit relative */ -// OBSOLETE { -// OBSOLETE if ((instr[1] & 0xF0) == 0x00 || /* BNE, BEQ */ -// OBSOLETE (instr[1] & 0xF0) == 0x10) -// OBSOLETE return 5; -// OBSOLETE if (instr[0] == 0xB0) /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ, BEQZ */ -// OBSOLETE if ((instr[1] & 0xF0) == 0x80 || (instr[1] & 0xF0) == 0x90 || -// OBSOLETE (instr[1] & 0xF0) == 0xA0 || (instr[1] & 0xF0) == 0xB0 || -// OBSOLETE (instr[1] & 0xF0) == 0xC0 || (instr[1] & 0xF0) == 0xD0) -// OBSOLETE return 6; -// OBSOLETE } -// OBSOLETE return 0; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* if address is NOT on a 4-byte boundary, or high-bit of instr is zero, -// OBSOLETE then it's a 2-byte instruction, else it's a 4-byte instruction. */ -// OBSOLETE -// OBSOLETE #define INSTRUCTION_SIZE(addr) \ -// OBSOLETE ((((int) addr & 2) || (((unsigned char *) addr)[0] & 0x80) == 0) ? 2 : 4) -// OBSOLETE -// OBSOLETE static int -// OBSOLETE isBranch (unsigned char *instr) -// OBSOLETE { -// OBSOLETE if (INSTRUCTION_SIZE(instr) == 2) -// OBSOLETE return isShortBranch(instr); -// OBSOLETE else -// OBSOLETE return isLongBranch(instr); -// OBSOLETE } -// OBSOLETE -// OBSOLETE static int -// OBSOLETE willBranch (unsigned char *instr, int branchCode) -// OBSOLETE { -// OBSOLETE switch (branchCode) -// OBSOLETE { -// OBSOLETE case 0: return 0; /* not a branch */ -// OBSOLETE case 1: return 1; /* RTE */ -// OBSOLETE case 2: return 1; /* JL or JMP */ -// OBSOLETE case 3: /* BC, BNC, BL, BRA (short) */ -// OBSOLETE case 4: /* BC, BNC, BL, BRA (long) */ -// OBSOLETE switch (instr[0] & 0x0F) -// OBSOLETE { -// OBSOLETE case 0xC: /* Branch if Condition Register */ -// OBSOLETE return (registers[CBR] != 0); -// OBSOLETE case 0xD: /* Branch if NOT Condition Register */ -// OBSOLETE return (registers[CBR] == 0); -// OBSOLETE case 0xE: /* Branch and Link */ -// OBSOLETE case 0xF: /* Branch (unconditional) */ -// OBSOLETE return 1; -// OBSOLETE default: /* oops? */ -// OBSOLETE return 0; -// OBSOLETE } -// OBSOLETE case 5: /* BNE, BEQ */ -// OBSOLETE switch (instr[1] & 0xF0) -// OBSOLETE { -// OBSOLETE case 0x00: /* Branch if r1 equal to r2 */ -// OBSOLETE return (registers[instr[0] & 0x0F] == registers[instr[1] & 0x0F]); -// OBSOLETE case 0x10: /* Branch if r1 NOT equal to r2 */ -// OBSOLETE return (registers[instr[0] & 0x0F] != registers[instr[1] & 0x0F]); -// OBSOLETE default: /* oops? */ -// OBSOLETE return 0; -// OBSOLETE } -// OBSOLETE case 6: /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ */ -// OBSOLETE switch (instr[1] & 0xF0) -// OBSOLETE { -// OBSOLETE case 0x80: /* Branch if reg equal to zero */ -// OBSOLETE return (registers[instr[1] & 0x0F] == 0); -// OBSOLETE case 0x90: /* Branch if reg NOT equal to zero */ -// OBSOLETE return (registers[instr[1] & 0x0F] != 0); -// OBSOLETE case 0xA0: /* Branch if reg less than zero */ -// OBSOLETE return (registers[instr[1] & 0x0F] < 0); -// OBSOLETE case 0xB0: /* Branch if reg greater or equal to zero */ -// OBSOLETE return (registers[instr[1] & 0x0F] >= 0); -// OBSOLETE case 0xC0: /* Branch if reg less than or equal to zero */ -// OBSOLETE return (registers[instr[1] & 0x0F] <= 0); -// OBSOLETE case 0xD0: /* Branch if reg greater than zero */ -// OBSOLETE return (registers[instr[1] & 0x0F] > 0); -// OBSOLETE default: /* oops? */ -// OBSOLETE return 0; -// OBSOLETE } -// OBSOLETE default: /* oops? */ -// OBSOLETE return 0; -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE static int -// OBSOLETE branchDestination (unsigned char *instr, int branchCode) -// OBSOLETE { -// OBSOLETE switch (branchCode) { -// OBSOLETE default: -// OBSOLETE case 0: /* not a branch */ -// OBSOLETE return 0; -// OBSOLETE case 1: /* RTE */ -// OBSOLETE return registers[BPC] & ~3; /* pop BPC into PC */ -// OBSOLETE case 2: /* JL or JMP */ -// OBSOLETE return registers[instr[1] & 0x0F] & ~3; /* jump thru a register */ -// OBSOLETE case 3: /* BC, BNC, BL, BRA (short, 8-bit relative offset) */ -// OBSOLETE return (((int) instr) & ~3) + ((char) instr[1] << 2); -// OBSOLETE case 4: /* BC, BNC, BL, BRA (long, 24-bit relative offset) */ -// OBSOLETE return ((int) instr + -// OBSOLETE ((((char) instr[1] << 16) | (instr[2] << 8) | (instr[3])) << 2)); -// OBSOLETE case 5: /* BNE, BEQ (16-bit relative offset) */ -// OBSOLETE case 6: /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ (ditto) */ -// OBSOLETE return ((int) instr + ((((char) instr[2] << 8) | (instr[3])) << 2)); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* An explanatory note: in the last three return expressions, I have -// OBSOLETE cast the most-significant byte of the return offset to char. -// OBSOLETE What this accomplishes is sign extension. If the other -// OBSOLETE less-significant bytes were signed as well, they would get sign -// OBSOLETE extended too and, if negative, their leading bits would clobber -// OBSOLETE the bits of the more-significant bytes ahead of them. There are -// OBSOLETE other ways I could have done this, but sign extension from -// OBSOLETE odd-sized integers is always a pain. */ -// OBSOLETE } -// OBSOLETE -// OBSOLETE static void -// OBSOLETE branchSideEffects (unsigned char *instr, int branchCode) -// OBSOLETE { -// OBSOLETE switch (branchCode) -// OBSOLETE { -// OBSOLETE case 1: /* RTE */ -// OBSOLETE return; /* I <THINK> this is already handled... */ -// OBSOLETE case 2: /* JL (or JMP) */ -// OBSOLETE case 3: /* BL (or BC, BNC, BRA) */ -// OBSOLETE case 4: -// OBSOLETE if ((instr[0] & 0x0F) == 0x0E) /* branch/jump and link */ -// OBSOLETE registers[R14] = (registers[PC] & ~3) + 4; -// OBSOLETE return; -// OBSOLETE default: /* any other branch has no side effects */ -// OBSOLETE return; -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE static struct STEPPING_CONTEXT { -// OBSOLETE int stepping; /* true when we've started a single-step */ -// OBSOLETE unsigned long target_addr; /* the instr we're trying to execute */ -// OBSOLETE unsigned long target_size; /* the size of the target instr */ -// OBSOLETE unsigned long noop_addr; /* where we've inserted a no-op, if any */ -// OBSOLETE unsigned long trap1_addr; /* the trap following the target instr */ -// OBSOLETE unsigned long trap2_addr; /* the trap at a branch destination, if any */ -// OBSOLETE unsigned short noop_save; /* instruction overwritten by our no-op */ -// OBSOLETE unsigned short trap1_save; /* instruction overwritten by trap1 */ -// OBSOLETE unsigned short trap2_save; /* instruction overwritten by trap2 */ -// OBSOLETE unsigned short continue_p; /* true if NOT returning to gdb after step */ -// OBSOLETE } stepping; -// OBSOLETE -// OBSOLETE /* Function: prepare_to_step -// OBSOLETE Called from handle_exception to prepare the user program to single-step. -// OBSOLETE Places a trap instruction after the target instruction, with special -// OBSOLETE extra handling for branch instructions and for instructions in the -// OBSOLETE second half-word of a word. -// OBSOLETE -// OBSOLETE Returns: True if we should actually execute the instruction; -// OBSOLETE False if we are going to emulate executing the instruction, -// OBSOLETE in which case we simply report to GDB that the instruction -// OBSOLETE has already been executed. */ -// OBSOLETE -// OBSOLETE #define TRAP1 0x10f1; /* trap #1 instruction */ -// OBSOLETE #define NOOP 0x7000; /* noop instruction */ -// OBSOLETE -// OBSOLETE static unsigned short trap1 = TRAP1; -// OBSOLETE static unsigned short noop = NOOP; -// OBSOLETE -// OBSOLETE static int -// OBSOLETE prepare_to_step(continue_p) -// OBSOLETE int continue_p; /* if this isn't REALLY a single-step (see below) */ -// OBSOLETE { -// OBSOLETE unsigned long pc = registers[PC]; -// OBSOLETE int branchCode = isBranch((unsigned char *) pc); -// OBSOLETE unsigned char *p; -// OBSOLETE -// OBSOLETE /* zero out the stepping context -// OBSOLETE (paranoia -- it should already be zeroed) */ -// OBSOLETE for (p = (unsigned char *) &stepping; -// OBSOLETE p < ((unsigned char *) &stepping) + sizeof(stepping); -// OBSOLETE p++) -// OBSOLETE *p = 0; -// OBSOLETE -// OBSOLETE if (branchCode != 0) /* next instruction is a branch */ -// OBSOLETE { -// OBSOLETE branchSideEffects((unsigned char *) pc, branchCode); -// OBSOLETE if (willBranch((unsigned char *)pc, branchCode)) -// OBSOLETE registers[PC] = branchDestination((unsigned char *) pc, branchCode); -// OBSOLETE else -// OBSOLETE registers[PC] = pc + INSTRUCTION_SIZE(pc); -// OBSOLETE return 0; /* branch "executed" -- just notify GDB */ -// OBSOLETE } -// OBSOLETE else if (((int) pc & 2) != 0) /* "second-slot" instruction */ -// OBSOLETE { -// OBSOLETE /* insert no-op before pc */ -// OBSOLETE stepping.noop_addr = pc - 2; -// OBSOLETE stepping.noop_save = *(unsigned short *) stepping.noop_addr; -// OBSOLETE *(unsigned short *) stepping.noop_addr = noop; -// OBSOLETE /* insert trap after pc */ -// OBSOLETE stepping.trap1_addr = pc + 2; -// OBSOLETE stepping.trap1_save = *(unsigned short *) stepping.trap1_addr; -// OBSOLETE *(unsigned short *) stepping.trap1_addr = trap1; -// OBSOLETE } -// OBSOLETE else /* "first-slot" instruction */ -// OBSOLETE { -// OBSOLETE /* insert trap after pc */ -// OBSOLETE stepping.trap1_addr = pc + INSTRUCTION_SIZE(pc); -// OBSOLETE stepping.trap1_save = *(unsigned short *) stepping.trap1_addr; -// OBSOLETE *(unsigned short *) stepping.trap1_addr = trap1; -// OBSOLETE } -// OBSOLETE /* "continue_p" means that we are actually doing a continue, and not -// OBSOLETE being requested to single-step by GDB. Sometimes we have to do -// OBSOLETE one single-step before continuing, because the PC is on a half-word -// OBSOLETE boundary. There's no way to simply resume at such an address. */ -// OBSOLETE stepping.continue_p = continue_p; -// OBSOLETE stepping.stepping = 1; /* starting a single-step */ -// OBSOLETE return 1; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: finish_from_step -// OBSOLETE Called from handle_exception to finish up when the user program -// OBSOLETE returns from a single-step. Replaces the instructions that had -// OBSOLETE been overwritten by traps or no-ops, -// OBSOLETE -// OBSOLETE Returns: True if we should notify GDB that the target stopped. -// OBSOLETE False if we only single-stepped because we had to before we -// OBSOLETE could continue (ie. we were trying to continue at a -// OBSOLETE half-word boundary). In that case don't notify GDB: -// OBSOLETE just "continue continuing". */ -// OBSOLETE -// OBSOLETE static int -// OBSOLETE finish_from_step (void) -// OBSOLETE { -// OBSOLETE if (stepping.stepping) /* anything to do? */ -// OBSOLETE { -// OBSOLETE int continue_p = stepping.continue_p; -// OBSOLETE unsigned char *p; -// OBSOLETE -// OBSOLETE if (stepping.noop_addr) /* replace instr "under" our no-op */ -// OBSOLETE *(unsigned short *) stepping.noop_addr = stepping.noop_save; -// OBSOLETE if (stepping.trap1_addr) /* replace instr "under" our trap */ -// OBSOLETE *(unsigned short *) stepping.trap1_addr = stepping.trap1_save; -// OBSOLETE if (stepping.trap2_addr) /* ditto our other trap, if any */ -// OBSOLETE *(unsigned short *) stepping.trap2_addr = stepping.trap2_save; -// OBSOLETE -// OBSOLETE for (p = (unsigned char *) &stepping; /* zero out the stepping context */ -// OBSOLETE p < ((unsigned char *) &stepping) + sizeof(stepping); -// OBSOLETE p++) -// OBSOLETE *p = 0; -// OBSOLETE -// OBSOLETE return !(continue_p); -// OBSOLETE } -// OBSOLETE else /* we didn't single-step, therefore this must be a legitimate stop */ -// OBSOLETE return 1; -// OBSOLETE } -// OBSOLETE -// OBSOLETE struct PSWreg { /* separate out the bit flags in the PSW register */ -// OBSOLETE int pad1 : 16; -// OBSOLETE int bsm : 1; -// OBSOLETE int bie : 1; -// OBSOLETE int pad2 : 5; -// OBSOLETE int bc : 1; -// OBSOLETE int sm : 1; -// OBSOLETE int ie : 1; -// OBSOLETE int pad3 : 5; -// OBSOLETE int c : 1; -// OBSOLETE } *psw; -// OBSOLETE -// OBSOLETE /* Upon entry the value for LR to save has been pushed. -// OBSOLETE We unpush that so that the value for the stack pointer saved is correct. -// OBSOLETE Upon entry, all other registers are assumed to have not been modified -// OBSOLETE since the interrupt/trap occured. */ -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE stash_registers: -// OBSOLETE push r0 -// OBSOLETE push r1 -// OBSOLETE seth r1, #shigh(registers) -// OBSOLETE add3 r1, r1, #low(registers) -// OBSOLETE pop r0 ; r1 -// OBSOLETE st r0, @(4,r1) -// OBSOLETE pop r0 ; r0 -// OBSOLETE st r0, @r1 -// OBSOLETE addi r1, #4 ; only add 4 as subsequent saves are `pre inc' -// OBSOLETE st r2, @+r1 -// OBSOLETE st r3, @+r1 -// OBSOLETE st r4, @+r1 -// OBSOLETE st r5, @+r1 -// OBSOLETE st r6, @+r1 -// OBSOLETE st r7, @+r1 -// OBSOLETE st r8, @+r1 -// OBSOLETE st r9, @+r1 -// OBSOLETE st r10, @+r1 -// OBSOLETE st r11, @+r1 -// OBSOLETE st r12, @+r1 -// OBSOLETE st r13, @+r1 ; fp -// OBSOLETE pop r0 ; lr (r14) -// OBSOLETE st r0, @+r1 -// OBSOLETE st sp, @+r1 ; sp contains right value at this point -// OBSOLETE mvfc r0, cr0 -// OBSOLETE st r0, @+r1 ; cr0 == PSW -// OBSOLETE mvfc r0, cr1 -// OBSOLETE st r0, @+r1 ; cr1 == CBR -// OBSOLETE mvfc r0, cr2 -// OBSOLETE st r0, @+r1 ; cr2 == SPI -// OBSOLETE mvfc r0, cr3 -// OBSOLETE st r0, @+r1 ; cr3 == SPU -// OBSOLETE mvfc r0, cr6 -// OBSOLETE st r0, @+r1 ; cr6 == BPC -// OBSOLETE st r0, @+r1 ; PC == BPC -// OBSOLETE mvfaclo r0 -// OBSOLETE st r0, @+r1 ; ACCL -// OBSOLETE mvfachi r0 -// OBSOLETE st r0, @+r1 ; ACCH -// OBSOLETE jmp lr"); -// OBSOLETE -// OBSOLETE /* C routine to clean up what stash_registers did. -// OBSOLETE It is called after calling stash_registers. -// OBSOLETE This is separate from stash_registers as we want to do this in C -// OBSOLETE but doing stash_registers in C isn't straightforward. */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE cleanup_stash (void) -// OBSOLETE { -// OBSOLETE psw = (struct PSWreg *) ®isters[PSW]; /* fields of PSW register */ -// OBSOLETE psw->sm = psw->bsm; /* fix up pre-trap values of psw fields */ -// OBSOLETE psw->ie = psw->bie; -// OBSOLETE psw->c = psw->bc; -// OBSOLETE registers[CBR] = psw->bc; /* fix up pre-trap "C" register */ -// OBSOLETE -// OBSOLETE #if 0 /* FIXME: Was in previous version. Necessary? -// OBSOLETE (Remember that we use the "rte" insn to return from the -// OBSOLETE trap/interrupt so the values of bsm, bie, bc are important. */ -// OBSOLETE psw->bsm = psw->bie = psw->bc = 0; /* zero post-trap values */ -// OBSOLETE #endif -// OBSOLETE -// OBSOLETE /* FIXME: Copied from previous version. This can probably be deleted -// OBSOLETE since methinks stash_registers has already done this. */ -// OBSOLETE registers[PC] = registers[BPC]; /* pre-trap PC */ -// OBSOLETE -// OBSOLETE /* FIXME: Copied from previous version. Necessary? */ -// OBSOLETE if (psw->sm) /* copy R15 into (psw->sm ? SPU : SPI) */ -// OBSOLETE registers[SPU] = registers[R15]; -// OBSOLETE else -// OBSOLETE registers[SPI] = registers[R15]; -// OBSOLETE } -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE restore_and_return: -// OBSOLETE seth r0, #shigh(registers+8) -// OBSOLETE add3 r0, r0, #low(registers+8) -// OBSOLETE ld r2, @r0+ ; restore r2 -// OBSOLETE ld r3, @r0+ ; restore r3 -// OBSOLETE ld r4, @r0+ ; restore r4 -// OBSOLETE ld r5, @r0+ ; restore r5 -// OBSOLETE ld r6, @r0+ ; restore r6 -// OBSOLETE ld r7, @r0+ ; restore r7 -// OBSOLETE ld r8, @r0+ ; restore r8 -// OBSOLETE ld r9, @r0+ ; restore r9 -// OBSOLETE ld r10, @r0+ ; restore r10 -// OBSOLETE ld r11, @r0+ ; restore r11 -// OBSOLETE ld r12, @r0+ ; restore r12 -// OBSOLETE ld r13, @r0+ ; restore r13 -// OBSOLETE ld r14, @r0+ ; restore r14 -// OBSOLETE ld r15, @r0+ ; restore r15 -// OBSOLETE addi r0, #4 ; don't restore PSW (rte will do it) -// OBSOLETE ld r1, @r0+ ; restore cr1 == CBR (no-op, because it's read only) -// OBSOLETE mvtc r1, cr1 -// OBSOLETE ld r1, @r0+ ; restore cr2 == SPI -// OBSOLETE mvtc r1, cr2 -// OBSOLETE ld r1, @r0+ ; restore cr3 == SPU -// OBSOLETE mvtc r1, cr3 -// OBSOLETE addi r0, #4 ; skip BPC -// OBSOLETE ld r1, @r0+ ; restore cr6 (BPC) == PC -// OBSOLETE mvtc r1, cr6 -// OBSOLETE ld r1, @r0+ ; restore ACCL -// OBSOLETE mvtaclo r1 -// OBSOLETE ld r1, @r0+ ; restore ACCH -// OBSOLETE mvtachi r1 -// OBSOLETE seth r0, #shigh(registers) -// OBSOLETE add3 r0, r0, #low(registers) -// OBSOLETE ld r1, @(4,r0) ; restore r1 -// OBSOLETE ld r0, @r0 ; restore r0 -// OBSOLETE rte"); -// OBSOLETE -// OBSOLETE /* General trap handler, called after the registers have been stashed. -// OBSOLETE NUM is the trap/exception number. */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE process_exception (int num) -// OBSOLETE { -// OBSOLETE cleanup_stash (); -// OBSOLETE asm volatile (" -// OBSOLETE seth r1, #shigh(stackPtr) -// OBSOLETE add3 r1, r1, #low(stackPtr) -// OBSOLETE ld r15, @r1 ; setup local stack (protect user stack) -// OBSOLETE mv r0, %0 -// OBSOLETE bl handle_exception -// OBSOLETE bl restore_and_return" -// OBSOLETE : : "r" (num) : "r0", "r1"); -// OBSOLETE } -// OBSOLETE -// OBSOLETE void _catchException0 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException0: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #0 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException1 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException1: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE bl cleanup_stash -// OBSOLETE seth r1, #shigh(stackPtr) -// OBSOLETE add3 r1, r1, #low(stackPtr) -// OBSOLETE ld r15, @r1 ; setup local stack (protect user stack) -// OBSOLETE seth r1, #shigh(registers + 21*4) ; PC -// OBSOLETE add3 r1, r1, #low(registers + 21*4) -// OBSOLETE ld r0, @r1 -// OBSOLETE addi r0, #-4 ; back up PC for breakpoint trap. -// OBSOLETE st r0, @r1 ; FIXME: what about bp in right slot? -// OBSOLETE ldi r0, #1 -// OBSOLETE bl handle_exception -// OBSOLETE bl restore_and_return"); -// OBSOLETE -// OBSOLETE void _catchException2 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException2: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #2 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException3 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException3: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #3 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException4 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException4: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #4 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException5 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException5: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #5 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException6 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException6: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #6 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException7 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException7: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #7 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException8 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException8: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #8 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException9 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException9: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #9 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException10 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException10: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #10 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException11 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException11: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #11 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException12 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException12: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #12 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException13 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException13: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #13 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException14 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException14: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #14 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException15 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException15: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #15 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException16 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException16: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #16 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE void _catchException17 (); -// OBSOLETE -// OBSOLETE asm (" -// OBSOLETE _catchException17: -// OBSOLETE push lr -// OBSOLETE bl stash_registers -// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped -// OBSOLETE ldi r0, #17 -// OBSOLETE bl process_exception"); -// OBSOLETE -// OBSOLETE -// OBSOLETE /* this function is used to set up exception handlers for tracing and -// OBSOLETE breakpoints */ -// OBSOLETE void -// OBSOLETE set_debug_traps (void) -// OBSOLETE { -// OBSOLETE /* extern void remcomHandler(); */ -// OBSOLETE int i; -// OBSOLETE -// OBSOLETE for (i = 0; i < 18; i++) /* keep a copy of old vectors */ -// OBSOLETE if (save_vectors[i] == 0) /* only copy them the first time */ -// OBSOLETE save_vectors[i] = getExceptionHandler (i); -// OBSOLETE -// OBSOLETE stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1]; -// OBSOLETE -// OBSOLETE exceptionHandler (0, _catchException0); -// OBSOLETE exceptionHandler (1, _catchException1); -// OBSOLETE exceptionHandler (2, _catchException2); -// OBSOLETE exceptionHandler (3, _catchException3); -// OBSOLETE exceptionHandler (4, _catchException4); -// OBSOLETE exceptionHandler (5, _catchException5); -// OBSOLETE exceptionHandler (6, _catchException6); -// OBSOLETE exceptionHandler (7, _catchException7); -// OBSOLETE exceptionHandler (8, _catchException8); -// OBSOLETE exceptionHandler (9, _catchException9); -// OBSOLETE exceptionHandler (10, _catchException10); -// OBSOLETE exceptionHandler (11, _catchException11); -// OBSOLETE exceptionHandler (12, _catchException12); -// OBSOLETE exceptionHandler (13, _catchException13); -// OBSOLETE exceptionHandler (14, _catchException14); -// OBSOLETE exceptionHandler (15, _catchException15); -// OBSOLETE exceptionHandler (16, _catchException16); -// OBSOLETE /* exceptionHandler (17, _catchException17); */ -// OBSOLETE -// OBSOLETE initialized = 1; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* This function will generate a breakpoint exception. It is used at the -// OBSOLETE beginning of a program to sync up with a debugger and can be used -// OBSOLETE otherwise as a quick means to stop program execution and "break" into -// OBSOLETE the debugger. */ -// OBSOLETE -// OBSOLETE #define BREAKPOINT() asm volatile (" trap #2"); -// OBSOLETE -// OBSOLETE void -// OBSOLETE breakpoint (void) -// OBSOLETE { -// OBSOLETE if (initialized) -// OBSOLETE BREAKPOINT(); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* STDOUT section: -// OBSOLETE Stuff pertaining to simulating stdout by sending chars to gdb to be echoed. -// OBSOLETE Functions: gdb_putchar(char ch) -// OBSOLETE gdb_puts(char *str) -// OBSOLETE gdb_write(char *str, int len) -// OBSOLETE gdb_error(char *format, char *parm) -// OBSOLETE */ -// OBSOLETE -// OBSOLETE /* Function: gdb_putchar(int) -// OBSOLETE Make gdb write a char to stdout. -// OBSOLETE Returns: the char */ -// OBSOLETE -// OBSOLETE static int -// OBSOLETE gdb_putchar (int ch) -// OBSOLETE { -// OBSOLETE char buf[4]; -// OBSOLETE -// OBSOLETE buf[0] = 'O'; -// OBSOLETE buf[1] = hexchars[ch >> 4]; -// OBSOLETE buf[2] = hexchars[ch & 0x0F]; -// OBSOLETE buf[3] = 0; -// OBSOLETE putpacket(buf); -// OBSOLETE return ch; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: gdb_write(char *, int) -// OBSOLETE Make gdb write n bytes to stdout (not assumed to be null-terminated). -// OBSOLETE Returns: number of bytes written */ -// OBSOLETE -// OBSOLETE static int -// OBSOLETE gdb_write (char *data, int len) -// OBSOLETE { -// OBSOLETE char *buf, *cpy; -// OBSOLETE int i; -// OBSOLETE -// OBSOLETE buf = remcomOutBuffer; -// OBSOLETE buf[0] = 'O'; -// OBSOLETE i = 0; -// OBSOLETE while (i < len) -// OBSOLETE { -// OBSOLETE for (cpy = buf+1; -// OBSOLETE i < len && cpy < buf + sizeof(remcomOutBuffer) - 3; -// OBSOLETE i++) -// OBSOLETE { -// OBSOLETE *cpy++ = hexchars[data[i] >> 4]; -// OBSOLETE *cpy++ = hexchars[data[i] & 0x0F]; -// OBSOLETE } -// OBSOLETE *cpy = 0; -// OBSOLETE putpacket(buf); -// OBSOLETE } -// OBSOLETE return len; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: gdb_puts(char *) -// OBSOLETE Make gdb write a null-terminated string to stdout. -// OBSOLETE Returns: the length of the string */ -// OBSOLETE -// OBSOLETE static int -// OBSOLETE gdb_puts (char *str) -// OBSOLETE { -// OBSOLETE return gdb_write(str, strlen(str)); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: gdb_error(char *, char *) -// OBSOLETE Send an error message to gdb's stdout. -// OBSOLETE First string may have 1 (one) optional "%s" in it, which -// OBSOLETE will cause the optional second string to be inserted. */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE gdb_error (char *format, char *parm) -// OBSOLETE { -// OBSOLETE char buf[400], *cpy; -// OBSOLETE int len; -// OBSOLETE -// OBSOLETE if (remote_debug) -// OBSOLETE { -// OBSOLETE if (format && *format) -// OBSOLETE len = strlen(format); -// OBSOLETE else -// OBSOLETE return; /* empty input */ -// OBSOLETE -// OBSOLETE if (parm && *parm) -// OBSOLETE len += strlen(parm); -// OBSOLETE -// OBSOLETE for (cpy = buf; *format; ) -// OBSOLETE { -// OBSOLETE if (format[0] == '%' && format[1] == 's') /* include second string */ -// OBSOLETE { -// OBSOLETE format += 2; /* advance two chars instead of just one */ -// OBSOLETE while (parm && *parm) -// OBSOLETE *cpy++ = *parm++; -// OBSOLETE } -// OBSOLETE else -// OBSOLETE *cpy++ = *format++; -// OBSOLETE } -// OBSOLETE *cpy = '\0'; -// OBSOLETE gdb_puts(buf); -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE static unsigned char * -// OBSOLETE strcpy (unsigned char *dest, const unsigned char *src) -// OBSOLETE { -// OBSOLETE unsigned char *ret = dest; -// OBSOLETE -// OBSOLETE if (dest && src) -// OBSOLETE { -// OBSOLETE while (*src) -// OBSOLETE *dest++ = *src++; -// OBSOLETE *dest = 0; -// OBSOLETE } -// OBSOLETE return ret; -// OBSOLETE } -// OBSOLETE -// OBSOLETE static int -// OBSOLETE strlen (const unsigned char *src) -// OBSOLETE { -// OBSOLETE int ret; -// OBSOLETE -// OBSOLETE for (ret = 0; *src; src++) -// OBSOLETE ret++; -// OBSOLETE -// OBSOLETE return ret; -// OBSOLETE } -// OBSOLETE -// OBSOLETE #if 0 -// OBSOLETE void exit (code) -// OBSOLETE int code; -// OBSOLETE { -// OBSOLETE _exit (code); -// OBSOLETE } -// OBSOLETE -// OBSOLETE int atexit (void *p) -// OBSOLETE { -// OBSOLETE return 0; -// OBSOLETE } -// OBSOLETE -// OBSOLETE void abort (void) -// OBSOLETE { -// OBSOLETE _exit (1); -// OBSOLETE } -// OBSOLETE #endif +/**************************************************************************** + + THIS SOFTWARE IS NOT COPYRIGHTED + + HP offers the following for use in the public domain. HP makes no + warranty with regard to the software or it's performance and the + user accepts the software "AS IS" with all faults. + + HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD + TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES + OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + +****************************************************************************/ + +/**************************************************************************** + * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $ + * + * Module name: remcom.c $ + * Revision: 1.34 $ + * Date: 91/03/09 12:29:49 $ + * Contributor: Lake Stevens Instrument Division$ + * + * Description: low level support for gdb debugger. $ + * + * Considerations: only works on target hardware $ + * + * Written by: Glenn Engel $ + * ModuleState: Experimental $ + * + * NOTES: See Below $ + * + * Modified for M32R by Michael Snyder, Cygnus Support. + * + * To enable debugger support, two things need to happen. One, a + * call to set_debug_traps() is necessary in order to allow any breakpoints + * or error conditions to be properly intercepted and reported to gdb. + * Two, a breakpoint needs to be generated to begin communication. This + * is most easily accomplished by a call to breakpoint(). Breakpoint() + * simulates a breakpoint by executing a trap #1. + * + * The external function exceptionHandler() is + * used to attach a specific handler to a specific M32R vector number. + * It should use the same privilege level it runs at. It should + * install it as an interrupt gate so that interrupts are masked + * while the handler runs. + * + * Because gdb will sometimes write to the stack area to execute function + * calls, this program cannot rely on using the supervisor stack so it + * uses it's own stack area reserved in the int array remcomStack. + * + ************* + * + * The following gdb commands are supported: + * + * command function Return value + * + * g return the value of the CPU registers hex data or ENN + * G set the value of the CPU registers OK or ENN + * + * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN + * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN + * XAA..AA,LLLL: Write LLLL binary bytes at address OK or ENN + * AA..AA + * + * c Resume at current address SNN ( signal NN) + * cAA..AA Continue at address AA..AA SNN + * + * s Step one instruction SNN + * sAA..AA Step one instruction from AA..AA SNN + * + * k kill + * + * ? What was the last sigval ? SNN (signal NN) + * + * All commands and responses are sent with a packet which includes a + * checksum. A packet consists of + * + * $<packet info>#<checksum>. + * + * where + * <packet info> :: <characters representing the command or response> + * <checksum> :: <two hex digits computed as modulo 256 sum of <packetinfo>> + * + * When a packet is received, it is first acknowledged with either '+' or '-'. + * '+' indicates a successful transfer. '-' indicates a failed transfer. + * + * Example: + * + * Host: Reply: + * $m0,10#2a +$00010203040506070809101112131415#42 + * + ****************************************************************************/ + + +/************************************************************************ + * + * external low-level support routines + */ +extern void putDebugChar (); /* write a single character */ +extern int getDebugChar (); /* read and return a single char */ +extern void exceptionHandler (); /* assign an exception handler */ + +/***************************************************************************** + * BUFMAX defines the maximum number of characters in inbound/outbound buffers + * at least NUMREGBYTES*2 are needed for register packets + */ +#define BUFMAX 400 + +static char initialized; /* boolean flag. != 0 means we've been initialized */ + +int remote_debug; +/* debug > 0 prints ill-formed commands in valid packets & checksum errors */ + +static const unsigned char hexchars[] = "0123456789abcdef"; + +#define NUMREGS 24 + +/* Number of bytes of registers. */ +#define NUMREGBYTES (NUMREGS * 4) +enum regnames +{ R0, R1, R2, R3, R4, R5, R6, R7, + R8, R9, R10, R11, R12, R13, R14, R15, + PSW, CBR, SPI, SPU, BPC, PC, ACCL, ACCH +}; + +enum SYS_calls +{ + SYS_null, + SYS_exit, + SYS_open, + SYS_close, + SYS_read, + SYS_write, + SYS_lseek, + SYS_unlink, + SYS_getpid, + SYS_kill, + SYS_fstat, + SYS_sbrk, + SYS_fork, + SYS_execve, + SYS_wait4, + SYS_link, + SYS_chdir, + SYS_stat, + SYS_utime, + SYS_chown, + SYS_chmod, + SYS_time, + SYS_pipe +}; + +static int registers[NUMREGS]; + +#define STACKSIZE 8096 +static unsigned char remcomInBuffer[BUFMAX]; +static unsigned char remcomOutBuffer[BUFMAX]; +static int remcomStack[STACKSIZE / sizeof (int)]; +static int *stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1]; + +static unsigned int save_vectors[18]; /* previous exception vectors */ + +/* Indicate to caller of mem2hex or hex2mem that there has been an error. */ +static volatile int mem_err = 0; + +/* Store the vector number here (since GDB only gets the signal + number through the usual means, and that's not very specific). */ +int gdb_m32r_vector = -1; + +#if 0 +#include "syscall.h" /* for SYS_exit, SYS_write etc. */ +#endif + +/* Global entry points: + */ + +extern void handle_exception (int); +extern void set_debug_traps (void); +extern void breakpoint (void); + +/* Local functions: + */ + +static int computeSignal (int); +static void putpacket (unsigned char *); +static unsigned char *getpacket (void); + +static unsigned char *mem2hex (unsigned char *, unsigned char *, int, int); +static unsigned char *hex2mem (unsigned char *, unsigned char *, int, int); +static int hexToInt (unsigned char **, int *); +static unsigned char *bin2mem (unsigned char *, unsigned char *, int, int); +static void stash_registers (void); +static void restore_registers (void); +static int prepare_to_step (int); +static int finish_from_step (void); +static unsigned long crc32 (unsigned char *, int, unsigned long); + +static void gdb_error (char *, char *); +static int gdb_putchar (int), gdb_puts (char *), gdb_write (char *, int); + +static unsigned char *strcpy (unsigned char *, const unsigned char *); +static int strlen (const unsigned char *); + +/* + * This function does all command procesing for interfacing to gdb. + */ + +void +handle_exception (int exceptionVector) +{ + int sigval, stepping; + int addr, length, i; + unsigned char *ptr; + unsigned char buf[16]; + int binary; + + if (!finish_from_step ()) + return; /* "false step": let the target continue */ + + gdb_m32r_vector = exceptionVector; + + if (remote_debug) + { + mem2hex ((unsigned char *) &exceptionVector, buf, 4, 0); + gdb_error ("Handle exception %s, ", buf); + mem2hex ((unsigned char *) ®isters[PC], buf, 4, 0); + gdb_error ("PC == 0x%s\n", buf); + } + + /* reply to host that an exception has occurred */ + sigval = computeSignal (exceptionVector); + + ptr = remcomOutBuffer; + + *ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */ + *ptr++ = hexchars[sigval >> 4]; + *ptr++ = hexchars[sigval & 0xf]; + + *ptr++ = hexchars[PC >> 4]; + *ptr++ = hexchars[PC & 0xf]; + *ptr++ = ':'; + ptr = mem2hex ((unsigned char *) ®isters[PC], ptr, 4, 0); /* PC */ + *ptr++ = ';'; + + *ptr++ = hexchars[R13 >> 4]; + *ptr++ = hexchars[R13 & 0xf]; + *ptr++ = ':'; + ptr = mem2hex ((unsigned char *) ®isters[R13], ptr, 4, 0); /* FP */ + *ptr++ = ';'; + + *ptr++ = hexchars[R15 >> 4]; + *ptr++ = hexchars[R15 & 0xf]; + *ptr++ = ':'; + ptr = mem2hex ((unsigned char *) ®isters[R15], ptr, 4, 0); /* SP */ + *ptr++ = ';'; + *ptr++ = 0; + + if (exceptionVector == 0) /* simulated SYS call stuff */ + { + mem2hex ((unsigned char *) ®isters[PC], buf, 4, 0); + switch (registers[R0]) + { + case SYS_exit: + gdb_error ("Target program has exited at %s\n", buf); + ptr = remcomOutBuffer; + *ptr++ = 'W'; + sigval = registers[R1] & 0xff; + *ptr++ = hexchars[sigval >> 4]; + *ptr++ = hexchars[sigval & 0xf]; + *ptr++ = 0; + break; + case SYS_open: + gdb_error ("Target attempts SYS_open call at %s\n", buf); + break; + case SYS_close: + gdb_error ("Target attempts SYS_close call at %s\n", buf); + break; + case SYS_read: + gdb_error ("Target attempts SYS_read call at %s\n", buf); + break; + case SYS_write: + if (registers[R1] == 1 || /* write to stdout */ + registers[R1] == 2) /* write to stderr */ + { /* (we can do that) */ + registers[R0] = + gdb_write ((void *) registers[R2], registers[R3]); + return; + } + else + gdb_error ("Target attempts SYS_write call at %s\n", buf); + break; + case SYS_lseek: + gdb_error ("Target attempts SYS_lseek call at %s\n", buf); + break; + case SYS_unlink: + gdb_error ("Target attempts SYS_unlink call at %s\n", buf); + break; + case SYS_getpid: + gdb_error ("Target attempts SYS_getpid call at %s\n", buf); + break; + case SYS_kill: + gdb_error ("Target attempts SYS_kill call at %s\n", buf); + break; + case SYS_fstat: + gdb_error ("Target attempts SYS_fstat call at %s\n", buf); + break; + default: + gdb_error ("Target attempts unknown SYS call at %s\n", buf); + break; + } + } + + putpacket (remcomOutBuffer); + + stepping = 0; + + while (1 == 1) + { + remcomOutBuffer[0] = 0; + ptr = getpacket (); + binary = 0; + switch (*ptr++) + { + default: /* Unknown code. Return an empty reply message. */ + break; + case 'R': + if (hexToInt (&ptr, &addr)) + registers[PC] = addr; + strcpy (remcomOutBuffer, "OK"); + break; + case '!': + strcpy (remcomOutBuffer, "OK"); + break; + case 'X': /* XAA..AA,LLLL:<binary data>#cs */ + binary = 1; + case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ + /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */ + { + if (hexToInt (&ptr, &addr)) + if (*(ptr++) == ',') + if (hexToInt (&ptr, &length)) + if (*(ptr++) == ':') + { + mem_err = 0; + if (binary) + bin2mem (ptr, (unsigned char *) addr, length, 1); + else + hex2mem (ptr, (unsigned char *) addr, length, 1); + if (mem_err) + { + strcpy (remcomOutBuffer, "E03"); + gdb_error ("memory fault", ""); + } + else + { + strcpy (remcomOutBuffer, "OK"); + } + ptr = 0; + } + if (ptr) + { + strcpy (remcomOutBuffer, "E02"); + } + } + break; + case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ + /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */ + if (hexToInt (&ptr, &addr)) + if (*(ptr++) == ',') + if (hexToInt (&ptr, &length)) + { + ptr = 0; + mem_err = 0; + mem2hex ((unsigned char *) addr, remcomOutBuffer, length, + 1); + if (mem_err) + { + strcpy (remcomOutBuffer, "E03"); + gdb_error ("memory fault", ""); + } + } + if (ptr) + { + strcpy (remcomOutBuffer, "E01"); + } + break; + case '?': + remcomOutBuffer[0] = 'S'; + remcomOutBuffer[1] = hexchars[sigval >> 4]; + remcomOutBuffer[2] = hexchars[sigval % 16]; + remcomOutBuffer[3] = 0; + break; + case 'd': + remote_debug = !(remote_debug); /* toggle debug flag */ + break; + case 'g': /* return the value of the CPU registers */ + mem2hex ((unsigned char *) registers, remcomOutBuffer, NUMREGBYTES, + 0); + break; + case 'P': /* set the value of a single CPU register - return OK */ + { + int regno; + + if (hexToInt (&ptr, ®no) && *ptr++ == '=') + if (regno >= 0 && regno < NUMREGS) + { + int stackmode; + + hex2mem (ptr, (unsigned char *) ®isters[regno], 4, 0); + /* + * Since we just changed a single CPU register, let's + * make sure to keep the several stack pointers consistant. + */ + stackmode = registers[PSW] & 0x80; + if (regno == R15) /* stack pointer changed */ + { /* need to change SPI or SPU */ + if (stackmode == 0) + registers[SPI] = registers[R15]; + else + registers[SPU] = registers[R15]; + } + else if (regno == SPU) /* "user" stack pointer changed */ + { + if (stackmode != 0) /* stack in user mode: copy SP */ + registers[R15] = registers[SPU]; + } + else if (regno == SPI) /* "interrupt" stack pointer changed */ + { + if (stackmode == 0) /* stack in interrupt mode: copy SP */ + registers[R15] = registers[SPI]; + } + else if (regno == PSW) /* stack mode may have changed! */ + { /* force SP to either SPU or SPI */ + if (stackmode == 0) /* stack in user mode */ + registers[R15] = registers[SPI]; + else /* stack in interrupt mode */ + registers[R15] = registers[SPU]; + } + strcpy (remcomOutBuffer, "OK"); + break; + } + strcpy (remcomOutBuffer, "E01"); + break; + } + case 'G': /* set the value of the CPU registers - return OK */ + hex2mem (ptr, (unsigned char *) registers, NUMREGBYTES, 0); + strcpy (remcomOutBuffer, "OK"); + break; + case 's': /* sAA..AA Step one instruction from AA..AA(optional) */ + stepping = 1; + case 'c': /* cAA..AA Continue from address AA..AA(optional) */ + /* try to read optional parameter, pc unchanged if no parm */ + if (hexToInt (&ptr, &addr)) + registers[PC] = addr; + + if (stepping) /* single-stepping */ + { + if (!prepare_to_step (0)) /* set up for single-step */ + { + /* prepare_to_step has already emulated the target insn: + Send SIGTRAP to gdb, don't resume the target at all. */ + ptr = remcomOutBuffer; + *ptr++ = 'T'; /* Simulate stopping with SIGTRAP */ + *ptr++ = '0'; + *ptr++ = '5'; + + *ptr++ = hexchars[PC >> 4]; /* send PC */ + *ptr++ = hexchars[PC & 0xf]; + *ptr++ = ':'; + ptr = mem2hex ((unsigned char *) ®isters[PC], ptr, 4, 0); + *ptr++ = ';'; + + *ptr++ = hexchars[R13 >> 4]; /* send FP */ + *ptr++ = hexchars[R13 & 0xf]; + *ptr++ = ':'; + ptr = + mem2hex ((unsigned char *) ®isters[R13], ptr, 4, 0); + *ptr++ = ';'; + + *ptr++ = hexchars[R15 >> 4]; /* send SP */ + *ptr++ = hexchars[R15 & 0xf]; + *ptr++ = ':'; + ptr = + mem2hex ((unsigned char *) ®isters[R15], ptr, 4, 0); + *ptr++ = ';'; + *ptr++ = 0; + + break; + } + } + else /* continuing, not single-stepping */ + { + /* OK, about to do a "continue". First check to see if the + target pc is on an odd boundary (second instruction in the + word). If so, we must do a single-step first, because + ya can't jump or return back to an odd boundary! */ + if ((registers[PC] & 2) != 0) + prepare_to_step (1); + } + + return; + + case 'D': /* Detach */ +#if 0 + /* I am interpreting this to mean, release the board from control + by the remote stub. To do this, I am restoring the original + (or at least previous) exception vectors. + */ + for (i = 0; i < 18; i++) + exceptionHandler (i, save_vectors[i]); + putpacket ("OK"); + return; /* continue the inferior */ +#else + strcpy (remcomOutBuffer, "OK"); + break; +#endif + case 'q': + if (*ptr++ == 'C' && + *ptr++ == 'R' && *ptr++ == 'C' && *ptr++ == ':') + { + unsigned long start, len, our_crc; + + if (hexToInt (&ptr, (int *) &start) && + *ptr++ == ',' && hexToInt (&ptr, (int *) &len)) + { + remcomOutBuffer[0] = 'C'; + our_crc = crc32 ((unsigned char *) start, len, 0xffffffff); + mem2hex ((char *) &our_crc, + &remcomOutBuffer[1], sizeof (long), 0); + } /* else do nothing */ + } /* else do nothing */ + break; + + case 'k': /* kill the program */ + continue; + } /* switch */ + + /* reply to the request */ + putpacket (remcomOutBuffer); + } +} + +/* qCRC support */ + +/* Table used by the crc32 function to calcuate the checksum. */ +static unsigned long crc32_table[256] = { 0, 0 }; + +static unsigned long +crc32 (unsigned char *buf, int len, unsigned long crc) +{ + if (!crc32_table[1]) + { + /* Initialize the CRC table and the decoding table. */ + int i, j; + unsigned long c; + + for (i = 0; i < 256; i++) + { + for (c = i << 24, j = 8; j > 0; --j) + c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); + crc32_table[i] = c; + } + } + + while (len--) + { + crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255]; + buf++; + } + return crc; +} + +static int +hex (unsigned char ch) +{ + if ((ch >= 'a') && (ch <= 'f')) + return (ch - 'a' + 10); + if ((ch >= '0') && (ch <= '9')) + return (ch - '0'); + if ((ch >= 'A') && (ch <= 'F')) + return (ch - 'A' + 10); + return (-1); +} + +/* scan for the sequence $<data>#<checksum> */ + +unsigned char * +getpacket (void) +{ + unsigned char *buffer = &remcomInBuffer[0]; + unsigned char checksum; + unsigned char xmitcsum; + int count; + char ch; + + while (1) + { + /* wait around for the start character, ignore all other characters */ + while ((ch = getDebugChar ()) != '$') + ; + + retry: + checksum = 0; + xmitcsum = -1; + count = 0; + + /* now, read until a # or end of buffer is found */ + while (count < BUFMAX) + { + ch = getDebugChar (); + if (ch == '$') + goto retry; + if (ch == '#') + break; + checksum = checksum + ch; + buffer[count] = ch; + count = count + 1; + } + buffer[count] = 0; + + if (ch == '#') + { + ch = getDebugChar (); + xmitcsum = hex (ch) << 4; + ch = getDebugChar (); + xmitcsum += hex (ch); + + if (checksum != xmitcsum) + { + if (remote_debug) + { + unsigned char buf[16]; + + mem2hex ((unsigned char *) &checksum, buf, 4, 0); + gdb_error ("Bad checksum: my count = %s, ", buf); + mem2hex ((unsigned char *) &xmitcsum, buf, 4, 0); + gdb_error ("sent count = %s\n", buf); + gdb_error (" -- Bad buffer: \"%s\"\n", buffer); + } + putDebugChar ('-'); /* failed checksum */ + } + else + { + putDebugChar ('+'); /* successful transfer */ + + /* if a sequence char is present, reply the sequence ID */ + if (buffer[2] == ':') + { + putDebugChar (buffer[0]); + putDebugChar (buffer[1]); + + return &buffer[3]; + } + + return &buffer[0]; + } + } + } +} + +/* send the packet in buffer. */ + +static void +putpacket (unsigned char *buffer) +{ + unsigned char checksum; + int count; + char ch; + + /* $<packet info>#<checksum>. */ + do + { + putDebugChar ('$'); + checksum = 0; + count = 0; + + while (ch = buffer[count]) + { + putDebugChar (ch); + checksum += ch; + count += 1; + } + putDebugChar ('#'); + putDebugChar (hexchars[checksum >> 4]); + putDebugChar (hexchars[checksum % 16]); + } + while (getDebugChar () != '+'); +} + +/* Address of a routine to RTE to if we get a memory fault. */ + +static void (*volatile mem_fault_routine) () = 0; + +static void +set_mem_err (void) +{ + mem_err = 1; +} + +/* Check the address for safe access ranges. As currently defined, + this routine will reject the "expansion bus" address range(s). + To make those ranges useable, someone must implement code to detect + whether there's anything connected to the expansion bus. */ + +static int +mem_safe (unsigned char *addr) +{ +#define BAD_RANGE_ONE_START ((unsigned char *) 0x600000) +#define BAD_RANGE_ONE_END ((unsigned char *) 0xa00000) +#define BAD_RANGE_TWO_START ((unsigned char *) 0xff680000) +#define BAD_RANGE_TWO_END ((unsigned char *) 0xff800000) + + if (addr < BAD_RANGE_ONE_START) + return 1; /* safe */ + if (addr < BAD_RANGE_ONE_END) + return 0; /* unsafe */ + if (addr < BAD_RANGE_TWO_START) + return 1; /* safe */ + if (addr < BAD_RANGE_TWO_END) + return 0; /* unsafe */ +} + +/* These are separate functions so that they are so short and sweet + that the compiler won't save any registers (if there is a fault + to mem_fault, they won't get restored, so there better not be any + saved). */ +static int +get_char (unsigned char *addr) +{ +#if 1 + if (mem_fault_routine && !mem_safe (addr)) + { + mem_fault_routine (); + return 0; + } +#endif + return *addr; +} + +static void +set_char (unsigned char *addr, unsigned char val) +{ +#if 1 + if (mem_fault_routine && !mem_safe (addr)) + { + mem_fault_routine (); + return; + } +#endif + *addr = val; +} + +/* Convert the memory pointed to by mem into hex, placing result in buf. + Return a pointer to the last char put in buf (null). + If MAY_FAULT is non-zero, then we should set mem_err in response to + a fault; if zero treat a fault like any other fault in the stub. */ + +static unsigned char * +mem2hex (unsigned char *mem, unsigned char *buf, int count, int may_fault) +{ + int i; + unsigned char ch; + + if (may_fault) + mem_fault_routine = set_mem_err; + for (i = 0; i < count; i++) + { + ch = get_char (mem++); + if (may_fault && mem_err) + return (buf); + *buf++ = hexchars[ch >> 4]; + *buf++ = hexchars[ch % 16]; + } + *buf = 0; + if (may_fault) + mem_fault_routine = 0; + return (buf); +} + +/* Convert the hex array pointed to by buf into binary to be placed in mem. + Return a pointer to the character AFTER the last byte written. */ + +static unsigned char * +hex2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault) +{ + int i; + unsigned char ch; + + if (may_fault) + mem_fault_routine = set_mem_err; + for (i = 0; i < count; i++) + { + ch = hex (*buf++) << 4; + ch = ch + hex (*buf++); + set_char (mem++, ch); + if (may_fault && mem_err) + return (mem); + } + if (may_fault) + mem_fault_routine = 0; + return (mem); +} + +/* Convert the binary stream in BUF to memory. + + Gdb will escape $, #, and the escape char (0x7d). + COUNT is the total number of bytes to write into + memory. */ +static unsigned char * +bin2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault) +{ + int i; + unsigned char ch; + + if (may_fault) + mem_fault_routine = set_mem_err; + for (i = 0; i < count; i++) + { + /* Check for any escaped characters. Be paranoid and + only unescape chars that should be escaped. */ + if (*buf == 0x7d) + { + switch (*(buf + 1)) + { + case 0x3: /* # */ + case 0x4: /* $ */ + case 0x5d: /* escape char */ + buf++; + *buf |= 0x20; + break; + default: + /* nothing */ + break; + } + } + + set_char (mem++, *buf++); + + if (may_fault && mem_err) + return mem; + } + + if (may_fault) + mem_fault_routine = 0; + return mem; +} + +/* this function takes the m32r exception vector and attempts to + translate this number into a unix compatible signal value */ + +static int +computeSignal (int exceptionVector) +{ + int sigval; + switch (exceptionVector) + { + case 0: + sigval = 23; + break; /* I/O trap */ + case 1: + sigval = 5; + break; /* breakpoint */ + case 2: + sigval = 5; + break; /* breakpoint */ + case 3: + sigval = 5; + break; /* breakpoint */ + case 4: + sigval = 5; + break; /* breakpoint */ + case 5: + sigval = 5; + break; /* breakpoint */ + case 6: + sigval = 5; + break; /* breakpoint */ + case 7: + sigval = 5; + break; /* breakpoint */ + case 8: + sigval = 5; + break; /* breakpoint */ + case 9: + sigval = 5; + break; /* breakpoint */ + case 10: + sigval = 5; + break; /* breakpoint */ + case 11: + sigval = 5; + break; /* breakpoint */ + case 12: + sigval = 5; + break; /* breakpoint */ + case 13: + sigval = 5; + break; /* breakpoint */ + case 14: + sigval = 5; + break; /* breakpoint */ + case 15: + sigval = 5; + break; /* breakpoint */ + case 16: + sigval = 10; + break; /* BUS ERROR (alignment) */ + case 17: + sigval = 2; + break; /* INTerrupt */ + default: + sigval = 7; + break; /* "software generated" */ + } + return (sigval); +} + +/**********************************************/ +/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */ +/* RETURN NUMBER OF CHARS PROCESSED */ +/**********************************************/ +static int +hexToInt (unsigned char **ptr, int *intValue) +{ + int numChars = 0; + int hexValue; + + *intValue = 0; + while (**ptr) + { + hexValue = hex (**ptr); + if (hexValue >= 0) + { + *intValue = (*intValue << 4) | hexValue; + numChars++; + } + else + break; + (*ptr)++; + } + return (numChars); +} + +/* + Table of branch instructions: + + 10B6 RTE return from trap or exception + 1FCr JMP jump + 1ECr JL jump and link + 7Fxx BRA branch + FFxxxxxx BRA branch (long) + B09rxxxx BNEZ branch not-equal-zero + Br1rxxxx BNE branch not-equal + 7Dxx BNC branch not-condition + FDxxxxxx BNC branch not-condition (long) + B0Arxxxx BLTZ branch less-than-zero + B0Crxxxx BLEZ branch less-equal-zero + 7Exx BL branch and link + FExxxxxx BL branch and link (long) + B0Drxxxx BGTZ branch greater-than-zero + B0Brxxxx BGEZ branch greater-equal-zero + B08rxxxx BEQZ branch equal-zero + Br0rxxxx BEQ branch equal + 7Cxx BC branch condition + FCxxxxxx BC branch condition (long) + */ + +static int +isShortBranch (unsigned char *instr) +{ + unsigned char instr0 = instr[0] & 0x7F; /* mask off high bit */ + + if (instr0 == 0x10 && instr[1] == 0xB6) /* RTE */ + return 1; /* return from trap or exception */ + + if (instr0 == 0x1E || instr0 == 0x1F) /* JL or JMP */ + if ((instr[1] & 0xF0) == 0xC0) + return 2; /* jump thru a register */ + + if (instr0 == 0x7C || instr0 == 0x7D || /* BC, BNC, BL, BRA */ + instr0 == 0x7E || instr0 == 0x7F) + return 3; /* eight bit PC offset */ + + return 0; +} + +static int +isLongBranch (unsigned char *instr) +{ + if (instr[0] == 0xFC || instr[0] == 0xFD || /* BRA, BNC, BL, BC */ + instr[0] == 0xFE || instr[0] == 0xFF) /* 24 bit relative */ + return 4; + if ((instr[0] & 0xF0) == 0xB0) /* 16 bit relative */ + { + if ((instr[1] & 0xF0) == 0x00 || /* BNE, BEQ */ + (instr[1] & 0xF0) == 0x10) + return 5; + if (instr[0] == 0xB0) /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ, BEQZ */ + if ((instr[1] & 0xF0) == 0x80 || (instr[1] & 0xF0) == 0x90 || + (instr[1] & 0xF0) == 0xA0 || (instr[1] & 0xF0) == 0xB0 || + (instr[1] & 0xF0) == 0xC0 || (instr[1] & 0xF0) == 0xD0) + return 6; + } + return 0; +} + +/* if address is NOT on a 4-byte boundary, or high-bit of instr is zero, + then it's a 2-byte instruction, else it's a 4-byte instruction. */ + +#define INSTRUCTION_SIZE(addr) \ + ((((int) addr & 2) || (((unsigned char *) addr)[0] & 0x80) == 0) ? 2 : 4) + +static int +isBranch (unsigned char *instr) +{ + if (INSTRUCTION_SIZE (instr) == 2) + return isShortBranch (instr); + else + return isLongBranch (instr); +} + +static int +willBranch (unsigned char *instr, int branchCode) +{ + switch (branchCode) + { + case 0: + return 0; /* not a branch */ + case 1: + return 1; /* RTE */ + case 2: + return 1; /* JL or JMP */ + case 3: /* BC, BNC, BL, BRA (short) */ + case 4: /* BC, BNC, BL, BRA (long) */ + switch (instr[0] & 0x0F) + { + case 0xC: /* Branch if Condition Register */ + return (registers[CBR] != 0); + case 0xD: /* Branch if NOT Condition Register */ + return (registers[CBR] == 0); + case 0xE: /* Branch and Link */ + case 0xF: /* Branch (unconditional) */ + return 1; + default: /* oops? */ + return 0; + } + case 5: /* BNE, BEQ */ + switch (instr[1] & 0xF0) + { + case 0x00: /* Branch if r1 equal to r2 */ + return (registers[instr[0] & 0x0F] == registers[instr[1] & 0x0F]); + case 0x10: /* Branch if r1 NOT equal to r2 */ + return (registers[instr[0] & 0x0F] != registers[instr[1] & 0x0F]); + default: /* oops? */ + return 0; + } + case 6: /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ */ + switch (instr[1] & 0xF0) + { + case 0x80: /* Branch if reg equal to zero */ + return (registers[instr[1] & 0x0F] == 0); + case 0x90: /* Branch if reg NOT equal to zero */ + return (registers[instr[1] & 0x0F] != 0); + case 0xA0: /* Branch if reg less than zero */ + return (registers[instr[1] & 0x0F] < 0); + case 0xB0: /* Branch if reg greater or equal to zero */ + return (registers[instr[1] & 0x0F] >= 0); + case 0xC0: /* Branch if reg less than or equal to zero */ + return (registers[instr[1] & 0x0F] <= 0); + case 0xD0: /* Branch if reg greater than zero */ + return (registers[instr[1] & 0x0F] > 0); + default: /* oops? */ + return 0; + } + default: /* oops? */ + return 0; + } +} + +static int +branchDestination (unsigned char *instr, int branchCode) +{ + switch (branchCode) + { + default: + case 0: /* not a branch */ + return 0; + case 1: /* RTE */ + return registers[BPC] & ~3; /* pop BPC into PC */ + case 2: /* JL or JMP */ + return registers[instr[1] & 0x0F] & ~3; /* jump thru a register */ + case 3: /* BC, BNC, BL, BRA (short, 8-bit relative offset) */ + return (((int) instr) & ~3) + ((char) instr[1] << 2); + case 4: /* BC, BNC, BL, BRA (long, 24-bit relative offset) */ + return ((int) instr + + ((((char) instr[1] << 16) | (instr[2] << 8) | (instr[3])) << + 2)); + case 5: /* BNE, BEQ (16-bit relative offset) */ + case 6: /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ (ditto) */ + return ((int) instr + ((((char) instr[2] << 8) | (instr[3])) << 2)); + } + + /* An explanatory note: in the last three return expressions, I have + cast the most-significant byte of the return offset to char. + What this accomplishes is sign extension. If the other + less-significant bytes were signed as well, they would get sign + extended too and, if negative, their leading bits would clobber + the bits of the more-significant bytes ahead of them. There are + other ways I could have done this, but sign extension from + odd-sized integers is always a pain. */ +} + +static void +branchSideEffects (unsigned char *instr, int branchCode) +{ + switch (branchCode) + { + case 1: /* RTE */ + return; /* I <THINK> this is already handled... */ + case 2: /* JL (or JMP) */ + case 3: /* BL (or BC, BNC, BRA) */ + case 4: + if ((instr[0] & 0x0F) == 0x0E) /* branch/jump and link */ + registers[R14] = (registers[PC] & ~3) + 4; + return; + default: /* any other branch has no side effects */ + return; + } +} + +static struct STEPPING_CONTEXT +{ + int stepping; /* true when we've started a single-step */ + unsigned long target_addr; /* the instr we're trying to execute */ + unsigned long target_size; /* the size of the target instr */ + unsigned long noop_addr; /* where we've inserted a no-op, if any */ + unsigned long trap1_addr; /* the trap following the target instr */ + unsigned long trap2_addr; /* the trap at a branch destination, if any */ + unsigned short noop_save; /* instruction overwritten by our no-op */ + unsigned short trap1_save; /* instruction overwritten by trap1 */ + unsigned short trap2_save; /* instruction overwritten by trap2 */ + unsigned short continue_p; /* true if NOT returning to gdb after step */ +} stepping; + +/* Function: prepare_to_step + Called from handle_exception to prepare the user program to single-step. + Places a trap instruction after the target instruction, with special + extra handling for branch instructions and for instructions in the + second half-word of a word. + + Returns: True if we should actually execute the instruction; + False if we are going to emulate executing the instruction, + in which case we simply report to GDB that the instruction + has already been executed. */ + +#define TRAP1 0x10f1; /* trap #1 instruction */ +#define NOOP 0x7000; /* noop instruction */ + +static unsigned short trap1 = TRAP1; +static unsigned short noop = NOOP; + +static int +prepare_to_step (continue_p) + int continue_p; /* if this isn't REALLY a single-step (see below) */ +{ + unsigned long pc = registers[PC]; + int branchCode = isBranch ((unsigned char *) pc); + unsigned char *p; + + /* zero out the stepping context + (paranoia -- it should already be zeroed) */ + for (p = (unsigned char *) &stepping; + p < ((unsigned char *) &stepping) + sizeof (stepping); p++) + *p = 0; + + if (branchCode != 0) /* next instruction is a branch */ + { + branchSideEffects ((unsigned char *) pc, branchCode); + if (willBranch ((unsigned char *) pc, branchCode)) + registers[PC] = branchDestination ((unsigned char *) pc, branchCode); + else + registers[PC] = pc + INSTRUCTION_SIZE (pc); + return 0; /* branch "executed" -- just notify GDB */ + } + else if (((int) pc & 2) != 0) /* "second-slot" instruction */ + { + /* insert no-op before pc */ + stepping.noop_addr = pc - 2; + stepping.noop_save = *(unsigned short *) stepping.noop_addr; + *(unsigned short *) stepping.noop_addr = noop; + /* insert trap after pc */ + stepping.trap1_addr = pc + 2; + stepping.trap1_save = *(unsigned short *) stepping.trap1_addr; + *(unsigned short *) stepping.trap1_addr = trap1; + } + else /* "first-slot" instruction */ + { + /* insert trap after pc */ + stepping.trap1_addr = pc + INSTRUCTION_SIZE (pc); + stepping.trap1_save = *(unsigned short *) stepping.trap1_addr; + *(unsigned short *) stepping.trap1_addr = trap1; + } + /* "continue_p" means that we are actually doing a continue, and not + being requested to single-step by GDB. Sometimes we have to do + one single-step before continuing, because the PC is on a half-word + boundary. There's no way to simply resume at such an address. */ + stepping.continue_p = continue_p; + stepping.stepping = 1; /* starting a single-step */ + return 1; +} + +/* Function: finish_from_step + Called from handle_exception to finish up when the user program + returns from a single-step. Replaces the instructions that had + been overwritten by traps or no-ops, + + Returns: True if we should notify GDB that the target stopped. + False if we only single-stepped because we had to before we + could continue (ie. we were trying to continue at a + half-word boundary). In that case don't notify GDB: + just "continue continuing". */ + +static int +finish_from_step (void) +{ + if (stepping.stepping) /* anything to do? */ + { + int continue_p = stepping.continue_p; + unsigned char *p; + + if (stepping.noop_addr) /* replace instr "under" our no-op */ + *(unsigned short *) stepping.noop_addr = stepping.noop_save; + if (stepping.trap1_addr) /* replace instr "under" our trap */ + *(unsigned short *) stepping.trap1_addr = stepping.trap1_save; + if (stepping.trap2_addr) /* ditto our other trap, if any */ + *(unsigned short *) stepping.trap2_addr = stepping.trap2_save; + + for (p = (unsigned char *) &stepping; /* zero out the stepping context */ + p < ((unsigned char *) &stepping) + sizeof (stepping); p++) + *p = 0; + + return !(continue_p); + } + else /* we didn't single-step, therefore this must be a legitimate stop */ + return 1; +} + +struct PSWreg +{ /* separate out the bit flags in the PSW register */ + int pad1:16; + int bsm:1; + int bie:1; + int pad2:5; + int bc:1; + int sm:1; + int ie:1; + int pad3:5; + int c:1; +} *psw; + +/* Upon entry the value for LR to save has been pushed. + We unpush that so that the value for the stack pointer saved is correct. + Upon entry, all other registers are assumed to have not been modified + since the interrupt/trap occured. */ + +asm ("\n\ +stash_registers:\n\ + push r0\n\ + push r1\n\ + seth r1, #shigh(registers)\n\ + add3 r1, r1, #low(registers)\n\ + pop r0 ; r1\n\ + st r0, @(4,r1)\n\ + pop r0 ; r0\n\ + st r0, @r1\n\ + addi r1, #4 ; only add 4 as subsequent saves are `pre inc'\n\ + st r2, @+r1\n\ + st r3, @+r1\n\ + st r4, @+r1\n\ + st r5, @+r1\n\ + st r6, @+r1\n\ + st r7, @+r1\n\ + st r8, @+r1\n\ + st r9, @+r1\n\ + st r10, @+r1\n\ + st r11, @+r1\n\ + st r12, @+r1\n\ + st r13, @+r1 ; fp\n\ + pop r0 ; lr (r14)\n\ + st r0, @+r1\n\ + st sp, @+r1 ; sp contains right value at this point\n\ + mvfc r0, cr0\n\ + st r0, @+r1 ; cr0 == PSW\n\ + mvfc r0, cr1\n\ + st r0, @+r1 ; cr1 == CBR\n\ + mvfc r0, cr2\n\ + st r0, @+r1 ; cr2 == SPI\n\ + mvfc r0, cr3\n\ + st r0, @+r1 ; cr3 == SPU\n\ + mvfc r0, cr6\n\ + st r0, @+r1 ; cr6 == BPC\n\ + st r0, @+r1 ; PC == BPC\n\ + mvfaclo r0\n\ + st r0, @+r1 ; ACCL\n\ + mvfachi r0\n\ + st r0, @+r1 ; ACCH\n\ + jmp lr"); + +/* C routine to clean up what stash_registers did. + It is called after calling stash_registers. + This is separate from stash_registers as we want to do this in C + but doing stash_registers in C isn't straightforward. */ + +static void +cleanup_stash (void) +{ + psw = (struct PSWreg *) ®isters[PSW]; /* fields of PSW register */ + psw->sm = psw->bsm; /* fix up pre-trap values of psw fields */ + psw->ie = psw->bie; + psw->c = psw->bc; + registers[CBR] = psw->bc; /* fix up pre-trap "C" register */ + +#if 0 /* FIXME: Was in previous version. Necessary? + (Remember that we use the "rte" insn to return from the + trap/interrupt so the values of bsm, bie, bc are important. */ + psw->bsm = psw->bie = psw->bc = 0; /* zero post-trap values */ +#endif + + /* FIXME: Copied from previous version. This can probably be deleted + since methinks stash_registers has already done this. */ + registers[PC] = registers[BPC]; /* pre-trap PC */ + + /* FIXME: Copied from previous version. Necessary? */ + if (psw->sm) /* copy R15 into (psw->sm ? SPU : SPI) */ + registers[SPU] = registers[R15]; + else + registers[SPI] = registers[R15]; +} + +asm ("\n\ +restore_and_return:\n\ + seth r0, #shigh(registers+8)\n\ + add3 r0, r0, #low(registers+8)\n\ + ld r2, @r0+ ; restore r2\n\ + ld r3, @r0+ ; restore r3\n\ + ld r4, @r0+ ; restore r4\n\ + ld r5, @r0+ ; restore r5\n\ + ld r6, @r0+ ; restore r6\n\ + ld r7, @r0+ ; restore r7\n\ + ld r8, @r0+ ; restore r8\n\ + ld r9, @r0+ ; restore r9\n\ + ld r10, @r0+ ; restore r10\n\ + ld r11, @r0+ ; restore r11\n\ + ld r12, @r0+ ; restore r12\n\ + ld r13, @r0+ ; restore r13\n\ + ld r14, @r0+ ; restore r14\n\ + ld r15, @r0+ ; restore r15\n\ + ld r1, @r0+ ; restore cr0 == PSW\n\ + mvtc r1, cr0\n\ + ld r1, @r0+ ; restore cr1 == CBR (no-op, because it's read only)\n\ + mvtc r1, cr1\n\ + ld r1, @r0+ ; restore cr2 == SPI\n\ + mvtc r1, cr2\n\ + ld r1, @r0+ ; restore cr3 == SPU\n\ + mvtc r1, cr3\n\ + addi r0, #4 ; skip BPC\n\ + ld r1, @r0+ ; restore cr6 (BPC) == PC\n\ + mvtc r1, cr6\n\ + ld r1, @r0+ ; restore ACCL\n\ + mvtaclo r1\n\ + ld r1, @r0+ ; restore ACCH\n\ + mvtachi r1\n\ + seth r0, #shigh(registers)\n\ + add3 r0, r0, #low(registers)\n\ + ld r1, @(4,r0) ; restore r1\n\ + ld r0, @r0 ; restore r0\n\ + rte"); + +/* General trap handler, called after the registers have been stashed. + NUM is the trap/exception number. */ + +static void +process_exception (int num) +{ + cleanup_stash (); + asm volatile ("\n\ + seth r1, #shigh(stackPtr)\n\ + add3 r1, r1, #low(stackPtr)\n\ + ld r15, @r1 ; setup local stack (protect user stack)\n\ + mv r0, %0\n\ + bl handle_exception\n\ + bl restore_and_return"::"r" (num):"r0", "r1"); +} + +void _catchException0 (); + +asm ("\n\ +_catchException0:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #0\n\ + bl process_exception"); + +void _catchException1 (); + +asm ("\n\ +_catchException1:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + bl cleanup_stash\n\ + seth r1, #shigh(stackPtr)\n\ + add3 r1, r1, #low(stackPtr)\n\ + ld r15, @r1 ; setup local stack (protect user stack)\n\ + seth r1, #shigh(registers + 21*4) ; PC\n\ + add3 r1, r1, #low(registers + 21*4)\n\ + ld r0, @r1\n\ + addi r0, #-4 ; back up PC for breakpoint trap.\n\ + st r0, @r1 ; FIXME: what about bp in right slot?\n\ + ldi r0, #1\n\ + bl handle_exception\n\ + bl restore_and_return"); + +void _catchException2 (); + +asm ("\n\ +_catchException2:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #2\n\ + bl process_exception"); + +void _catchException3 (); + +asm ("\n\ +_catchException3:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #3\n\ + bl process_exception"); + +void _catchException4 (); + +asm ("\n\ +_catchException4:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #4\n\ + bl process_exception"); + +void _catchException5 (); + +asm ("\n\ +_catchException5:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #5\n\ + bl process_exception"); + +void _catchException6 (); + +asm ("\n\ +_catchException6:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #6\n\ + bl process_exception"); + +void _catchException7 (); + +asm ("\n\ +_catchException7:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #7\n\ + bl process_exception"); + +void _catchException8 (); + +asm ("\n\ +_catchException8:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #8\n\ + bl process_exception"); + +void _catchException9 (); + +asm ("\n\ +_catchException9:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #9\n\ + bl process_exception"); + +void _catchException10 (); + +asm ("\n\ +_catchException10:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #10\n\ + bl process_exception"); + +void _catchException11 (); + +asm ("\n\ +_catchException11:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #11\n\ + bl process_exception"); + +void _catchException12 (); + +asm ("\n\ +_catchException12:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #12\n\ + bl process_exception"); + +void _catchException13 (); + +asm ("\n\ +_catchException13:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #13\n\ + bl process_exception"); + +void _catchException14 (); + +asm ("\n\ +_catchException14:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #14\n\ + bl process_exception"); + +void _catchException15 (); + +asm ("\n\ +_catchException15:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #15\n\ + bl process_exception"); + +void _catchException16 (); + +asm ("\n\ +_catchException16:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #16\n\ + bl process_exception"); + +void _catchException17 (); + +asm ("\n\ +_catchException17:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #17\n\ + bl process_exception"); + + +/* this function is used to set up exception handlers for tracing and + breakpoints */ +void +set_debug_traps (void) +{ + /* extern void remcomHandler(); */ + int i; + + for (i = 0; i < 18; i++) /* keep a copy of old vectors */ + if (save_vectors[i] == 0) /* only copy them the first time */ + save_vectors[i] = getExceptionHandler (i); + + stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1]; + + exceptionHandler (0, _catchException0); + exceptionHandler (1, _catchException1); + exceptionHandler (2, _catchException2); + exceptionHandler (3, _catchException3); + exceptionHandler (4, _catchException4); + exceptionHandler (5, _catchException5); + exceptionHandler (6, _catchException6); + exceptionHandler (7, _catchException7); + exceptionHandler (8, _catchException8); + exceptionHandler (9, _catchException9); + exceptionHandler (10, _catchException10); + exceptionHandler (11, _catchException11); + exceptionHandler (12, _catchException12); + exceptionHandler (13, _catchException13); + exceptionHandler (14, _catchException14); + exceptionHandler (15, _catchException15); + exceptionHandler (16, _catchException16); + /* exceptionHandler (17, _catchException17); */ + + initialized = 1; +} + +/* This function will generate a breakpoint exception. It is used at the + beginning of a program to sync up with a debugger and can be used + otherwise as a quick means to stop program execution and "break" into + the debugger. */ + +#define BREAKPOINT() asm volatile (" trap #2"); + +void +breakpoint (void) +{ + if (initialized) + BREAKPOINT (); +} + +/* STDOUT section: + Stuff pertaining to simulating stdout by sending chars to gdb to be echoed. + Functions: gdb_putchar(char ch) + gdb_puts(char *str) + gdb_write(char *str, int len) + gdb_error(char *format, char *parm) + */ + +/* Function: gdb_putchar(int) + Make gdb write a char to stdout. + Returns: the char */ + +static int +gdb_putchar (int ch) +{ + char buf[4]; + + buf[0] = 'O'; + buf[1] = hexchars[ch >> 4]; + buf[2] = hexchars[ch & 0x0F]; + buf[3] = 0; + putpacket (buf); + return ch; +} + +/* Function: gdb_write(char *, int) + Make gdb write n bytes to stdout (not assumed to be null-terminated). + Returns: number of bytes written */ + +static int +gdb_write (char *data, int len) +{ + char *buf, *cpy; + int i; + + buf = remcomOutBuffer; + buf[0] = 'O'; + i = 0; + while (i < len) + { + for (cpy = buf + 1; + i < len && cpy < buf + sizeof (remcomOutBuffer) - 3; i++) + { + *cpy++ = hexchars[data[i] >> 4]; + *cpy++ = hexchars[data[i] & 0x0F]; + } + *cpy = 0; + putpacket (buf); + } + return len; +} + +/* Function: gdb_puts(char *) + Make gdb write a null-terminated string to stdout. + Returns: the length of the string */ + +static int +gdb_puts (char *str) +{ + return gdb_write (str, strlen (str)); +} + +/* Function: gdb_error(char *, char *) + Send an error message to gdb's stdout. + First string may have 1 (one) optional "%s" in it, which + will cause the optional second string to be inserted. */ + +static void +gdb_error (char *format, char *parm) +{ + char buf[400], *cpy; + int len; + + if (remote_debug) + { + if (format && *format) + len = strlen (format); + else + return; /* empty input */ + + if (parm && *parm) + len += strlen (parm); + + for (cpy = buf; *format;) + { + if (format[0] == '%' && format[1] == 's') /* include second string */ + { + format += 2; /* advance two chars instead of just one */ + while (parm && *parm) + *cpy++ = *parm++; + } + else + *cpy++ = *format++; + } + *cpy = '\0'; + gdb_puts (buf); + } +} + +static unsigned char * +strcpy (unsigned char *dest, const unsigned char *src) +{ + unsigned char *ret = dest; + + if (dest && src) + { + while (*src) + *dest++ = *src++; + *dest = 0; + } + return ret; +} + +static int +strlen (const unsigned char *src) +{ + int ret; + + for (ret = 0; *src; src++) + ret++; + + return ret; +} + +#if 0 +void +exit (code) + int code; +{ + _exit (code); +} + +int +atexit (void *p) +{ + return 0; +} + +void +abort (void) +{ + _exit (1); +} +#endif diff --git a/gdb/m32r-tdep.c b/gdb/m32r-tdep.c index 93edbf9..a40f67d 100644 --- a/gdb/m32r-tdep.c +++ b/gdb/m32r-tdep.c @@ -1,708 +1,989 @@ -// OBSOLETE /* Target-dependent code for the Mitsubishi m32r for GDB, the GNU debugger. -// OBSOLETE -// OBSOLETE Copyright 1996, 1998, 1999, 2000, 2001, 2003 Free Software -// OBSOLETE Foundation, Inc. -// OBSOLETE -// OBSOLETE This file is part of GDB. -// OBSOLETE -// OBSOLETE This program is free software; you can redistribute it and/or modify -// OBSOLETE it under the terms of the GNU General Public License as published by -// OBSOLETE the Free Software Foundation; either version 2 of the License, or -// OBSOLETE (at your option) any later version. -// OBSOLETE -// OBSOLETE This program is distributed in the hope that it will be useful, -// OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of -// OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// OBSOLETE GNU General Public License for more details. -// OBSOLETE -// OBSOLETE You should have received a copy of the GNU General Public License -// OBSOLETE along with this program; if not, write to the Free Software -// OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, -// OBSOLETE Boston, MA 02111-1307, USA. */ -// OBSOLETE -// OBSOLETE #include "defs.h" -// OBSOLETE #include "frame.h" -// OBSOLETE #include "inferior.h" -// OBSOLETE #include "target.h" -// OBSOLETE #include "value.h" -// OBSOLETE #include "bfd.h" -// OBSOLETE #include "gdb_string.h" -// OBSOLETE #include "gdbcore.h" -// OBSOLETE #include "symfile.h" -// OBSOLETE #include "regcache.h" -// OBSOLETE -// OBSOLETE /* Function: m32r_use_struct_convention -// OBSOLETE Return nonzero if call_function should allocate stack space for a -// OBSOLETE struct return? */ -// OBSOLETE int -// OBSOLETE m32r_use_struct_convention (int gcc_p, struct type *type) -// OBSOLETE { -// OBSOLETE return (TYPE_LENGTH (type) > 8); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: frame_find_saved_regs -// OBSOLETE Return the frame_saved_regs structure for the frame. -// OBSOLETE Doesn't really work for dummy frames, but it does pass back -// OBSOLETE an empty frame_saved_regs, so I guess that's better than total failure */ -// OBSOLETE -// OBSOLETE void -// OBSOLETE m32r_frame_find_saved_regs (struct frame_info *fi, -// OBSOLETE struct frame_saved_regs *regaddr) -// OBSOLETE { -// OBSOLETE memcpy (regaddr, &fi->fsr, sizeof (struct frame_saved_regs)); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Turn this on if you want to see just how much instruction decoding -// OBSOLETE if being done, its quite a lot -// OBSOLETE */ -// OBSOLETE #if 0 -// OBSOLETE static void -// OBSOLETE dump_insn (char *commnt, CORE_ADDR pc, int insn) -// OBSOLETE { -// OBSOLETE printf_filtered (" %s %08x %08x ", -// OBSOLETE commnt, (unsigned int) pc, (unsigned int) insn); -// OBSOLETE TARGET_PRINT_INSN (pc, &tm_print_insn_info); -// OBSOLETE printf_filtered ("\n"); -// OBSOLETE } -// OBSOLETE #define insn_debug(args) { printf_filtered args; } -// OBSOLETE #else -// OBSOLETE #define dump_insn(a,b,c) {} -// OBSOLETE #define insn_debug(args) {} -// OBSOLETE #endif -// OBSOLETE -// OBSOLETE #define DEFAULT_SEARCH_LIMIT 44 -// OBSOLETE -// OBSOLETE /* Function: scan_prologue -// OBSOLETE This function decodes the target function prologue to determine -// OBSOLETE 1) the size of the stack frame, and 2) which registers are saved on it. -// OBSOLETE It saves the offsets of saved regs in the frame_saved_regs argument, -// OBSOLETE and returns the frame size. */ -// OBSOLETE -// OBSOLETE /* -// OBSOLETE The sequence it currently generates is: -// OBSOLETE -// OBSOLETE if (varargs function) { ddi sp,#n } -// OBSOLETE push registers -// OBSOLETE if (additional stack <= 256) { addi sp,#-stack } -// OBSOLETE else if (additional stack < 65k) { add3 sp,sp,#-stack -// OBSOLETE -// OBSOLETE } else if (additional stack) { -// OBSOLETE seth sp,#(stack & 0xffff0000) -// OBSOLETE or3 sp,sp,#(stack & 0x0000ffff) -// OBSOLETE sub sp,r4 -// OBSOLETE } -// OBSOLETE if (frame pointer) { -// OBSOLETE mv sp,fp -// OBSOLETE } -// OBSOLETE -// OBSOLETE These instructions are scheduled like everything else, so you should stop at -// OBSOLETE the first branch instruction. -// OBSOLETE -// OBSOLETE */ -// OBSOLETE -// OBSOLETE /* This is required by skip prologue and by m32r_init_extra_frame_info. -// OBSOLETE The results of decoding a prologue should be cached because this -// OBSOLETE thrashing is getting nuts. -// OBSOLETE I am thinking of making a container class with two indexes, name and -// OBSOLETE address. It may be better to extend the symbol table. -// OBSOLETE */ -// OBSOLETE -// OBSOLETE static void -// OBSOLETE decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, CORE_ADDR *pl_endptr, /* var parameter */ -// OBSOLETE unsigned long *framelength, struct frame_info *fi, -// OBSOLETE struct frame_saved_regs *fsr) -// OBSOLETE { -// OBSOLETE unsigned long framesize; -// OBSOLETE int insn; -// OBSOLETE int op1; -// OBSOLETE int maybe_one_more = 0; -// OBSOLETE CORE_ADDR after_prologue = 0; -// OBSOLETE CORE_ADDR after_stack_adjust = 0; -// OBSOLETE CORE_ADDR current_pc; -// OBSOLETE -// OBSOLETE -// OBSOLETE framesize = 0; -// OBSOLETE after_prologue = 0; -// OBSOLETE insn_debug (("rd prolog l(%d)\n", scan_limit - current_pc)); -// OBSOLETE -// OBSOLETE for (current_pc = start_pc; current_pc < scan_limit; current_pc += 2) -// OBSOLETE { -// OBSOLETE -// OBSOLETE insn = read_memory_unsigned_integer (current_pc, 2); -// OBSOLETE dump_insn ("insn-1", current_pc, insn); /* MTZ */ -// OBSOLETE -// OBSOLETE /* If this is a 32 bit instruction, we dont want to examine its -// OBSOLETE immediate data as though it were an instruction */ -// OBSOLETE if (current_pc & 0x02) -// OBSOLETE { /* Clear the parallel execution bit from 16 bit instruction */ -// OBSOLETE if (maybe_one_more) -// OBSOLETE { /* The last instruction was a branch, usually terminates -// OBSOLETE the series, but if this is a parallel instruction, -// OBSOLETE it may be a stack framing instruction */ -// OBSOLETE if (!(insn & 0x8000)) -// OBSOLETE { -// OBSOLETE insn_debug (("Really done")); -// OBSOLETE break; /* nope, we are really done */ -// OBSOLETE } -// OBSOLETE } -// OBSOLETE insn &= 0x7fff; /* decode this instruction further */ -// OBSOLETE } -// OBSOLETE else -// OBSOLETE { -// OBSOLETE if (maybe_one_more) -// OBSOLETE break; /* This isnt the one more */ -// OBSOLETE if (insn & 0x8000) -// OBSOLETE { -// OBSOLETE insn_debug (("32 bit insn\n")); -// OBSOLETE if (current_pc == scan_limit) -// OBSOLETE scan_limit += 2; /* extend the search */ -// OBSOLETE current_pc += 2; /* skip the immediate data */ -// OBSOLETE if (insn == 0x8faf) /* add3 sp, sp, xxxx */ -// OBSOLETE /* add 16 bit sign-extended offset */ -// OBSOLETE { -// OBSOLETE insn_debug (("stack increment\n")); -// OBSOLETE framesize += -((short) read_memory_unsigned_integer (current_pc, 2)); -// OBSOLETE } -// OBSOLETE else -// OBSOLETE { -// OBSOLETE if (((insn >> 8) == 0xe4) && /* ld24 r4, xxxxxx; sub sp, r4 */ -// OBSOLETE read_memory_unsigned_integer (current_pc + 2, 2) == 0x0f24) -// OBSOLETE { /* subtract 24 bit sign-extended negative-offset */ -// OBSOLETE dump_insn ("insn-2", current_pc + 2, insn); -// OBSOLETE insn = read_memory_unsigned_integer (current_pc - 2, 4); -// OBSOLETE dump_insn ("insn-3(l4)", current_pc - 2, insn); -// OBSOLETE if (insn & 0x00800000) /* sign extend */ -// OBSOLETE insn |= 0xff000000; /* negative */ -// OBSOLETE else -// OBSOLETE insn &= 0x00ffffff; /* positive */ -// OBSOLETE framesize += insn; -// OBSOLETE } -// OBSOLETE } -// OBSOLETE after_prologue = current_pc; -// OBSOLETE continue; -// OBSOLETE } -// OBSOLETE } -// OBSOLETE op1 = insn & 0xf000; /* isolate just the first nibble */ -// OBSOLETE -// OBSOLETE if ((insn & 0xf0ff) == 0x207f) -// OBSOLETE { /* st reg, @-sp */ -// OBSOLETE int regno; -// OBSOLETE insn_debug (("push\n")); -// OBSOLETE #if 0 /* No, PUSH FP is not an indication that we will use a frame pointer. */ -// OBSOLETE if (((insn & 0xffff) == 0x2d7f) && fi) -// OBSOLETE fi->using_frame_pointer = 1; -// OBSOLETE #endif -// OBSOLETE framesize += 4; -// OBSOLETE #if 0 -// OBSOLETE /* Why should we increase the scan limit, just because we did a push? -// OBSOLETE And if there is a reason, surely we would only want to do it if we -// OBSOLETE had already reached the scan limit... */ -// OBSOLETE if (current_pc == scan_limit) -// OBSOLETE scan_limit += 2; -// OBSOLETE #endif -// OBSOLETE regno = ((insn >> 8) & 0xf); -// OBSOLETE if (fsr) /* save_regs offset */ -// OBSOLETE fsr->regs[regno] = framesize; -// OBSOLETE after_prologue = 0; -// OBSOLETE continue; -// OBSOLETE } -// OBSOLETE if ((insn >> 8) == 0x4f) /* addi sp, xx */ -// OBSOLETE /* add 8 bit sign-extended offset */ -// OBSOLETE { -// OBSOLETE int stack_adjust = (char) (insn & 0xff); -// OBSOLETE -// OBSOLETE /* there are probably two of these stack adjustments: -// OBSOLETE 1) A negative one in the prologue, and -// OBSOLETE 2) A positive one in the epilogue. -// OBSOLETE We are only interested in the first one. */ -// OBSOLETE -// OBSOLETE if (stack_adjust < 0) -// OBSOLETE { -// OBSOLETE framesize -= stack_adjust; -// OBSOLETE after_prologue = 0; -// OBSOLETE /* A frameless function may have no "mv fp, sp". -// OBSOLETE In that case, this is the end of the prologue. */ -// OBSOLETE after_stack_adjust = current_pc + 2; -// OBSOLETE } -// OBSOLETE continue; -// OBSOLETE } -// OBSOLETE if (insn == 0x1d8f) -// OBSOLETE { /* mv fp, sp */ -// OBSOLETE if (fi) -// OBSOLETE fi->using_frame_pointer = 1; /* fp is now valid */ -// OBSOLETE insn_debug (("done fp found\n")); -// OBSOLETE after_prologue = current_pc + 2; -// OBSOLETE break; /* end of stack adjustments */ -// OBSOLETE } -// OBSOLETE if (insn == 0x7000) /* Nop looks like a branch, continue explicitly */ -// OBSOLETE { -// OBSOLETE insn_debug (("nop\n")); -// OBSOLETE after_prologue = current_pc + 2; -// OBSOLETE continue; /* nop occurs between pushes */ -// OBSOLETE } -// OBSOLETE /* End of prolog if any of these are branch instructions */ -// OBSOLETE if ((op1 == 0x7000) -// OBSOLETE || (op1 == 0xb000) -// OBSOLETE || (op1 == 0xf000)) -// OBSOLETE { -// OBSOLETE after_prologue = current_pc; -// OBSOLETE insn_debug (("Done: branch\n")); -// OBSOLETE maybe_one_more = 1; -// OBSOLETE continue; -// OBSOLETE } -// OBSOLETE /* Some of the branch instructions are mixed with other types */ -// OBSOLETE if (op1 == 0x1000) -// OBSOLETE { -// OBSOLETE int subop = insn & 0x0ff0; -// OBSOLETE if ((subop == 0x0ec0) || (subop == 0x0fc0)) -// OBSOLETE { -// OBSOLETE insn_debug (("done: jmp\n")); -// OBSOLETE after_prologue = current_pc; -// OBSOLETE maybe_one_more = 1; -// OBSOLETE continue; /* jmp , jl */ -// OBSOLETE } -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE if (current_pc >= scan_limit) -// OBSOLETE { -// OBSOLETE if (pl_endptr) -// OBSOLETE { -// OBSOLETE #if 1 -// OBSOLETE if (after_stack_adjust != 0) -// OBSOLETE /* We did not find a "mv fp,sp", but we DID find -// OBSOLETE a stack_adjust. Is it safe to use that as the -// OBSOLETE end of the prologue? I just don't know. */ -// OBSOLETE { -// OBSOLETE *pl_endptr = after_stack_adjust; -// OBSOLETE if (framelength) -// OBSOLETE *framelength = framesize; -// OBSOLETE } -// OBSOLETE else -// OBSOLETE #endif -// OBSOLETE /* We reached the end of the loop without finding the end -// OBSOLETE of the prologue. No way to win -- we should report failure. -// OBSOLETE The way we do that is to return the original start_pc. -// OBSOLETE GDB will set a breakpoint at the start of the function (etc.) */ -// OBSOLETE *pl_endptr = start_pc; -// OBSOLETE } -// OBSOLETE return; -// OBSOLETE } -// OBSOLETE if (after_prologue == 0) -// OBSOLETE after_prologue = current_pc; -// OBSOLETE -// OBSOLETE insn_debug ((" framesize %d, firstline %08x\n", framesize, after_prologue)); -// OBSOLETE if (framelength) -// OBSOLETE *framelength = framesize; -// OBSOLETE if (pl_endptr) -// OBSOLETE *pl_endptr = after_prologue; -// OBSOLETE } /* decode_prologue */ -// OBSOLETE -// OBSOLETE /* Function: skip_prologue -// OBSOLETE Find end of function prologue */ -// OBSOLETE -// OBSOLETE CORE_ADDR -// OBSOLETE m32r_skip_prologue (CORE_ADDR pc) -// OBSOLETE { -// OBSOLETE CORE_ADDR func_addr, func_end; -// OBSOLETE struct symtab_and_line sal; -// OBSOLETE -// OBSOLETE /* See what the symbol table says */ -// OBSOLETE -// OBSOLETE if (find_pc_partial_function (pc, NULL, &func_addr, &func_end)) -// OBSOLETE { -// OBSOLETE sal = find_pc_line (func_addr, 0); -// OBSOLETE -// OBSOLETE if (sal.line != 0 && sal.end <= func_end) -// OBSOLETE { -// OBSOLETE -// OBSOLETE insn_debug (("BP after prologue %08x\n", sal.end)); -// OBSOLETE func_end = sal.end; -// OBSOLETE } -// OBSOLETE else -// OBSOLETE /* Either there's no line info, or the line after the prologue is after -// OBSOLETE the end of the function. In this case, there probably isn't a -// OBSOLETE prologue. */ -// OBSOLETE { -// OBSOLETE insn_debug (("No line info, line(%x) sal_end(%x) funcend(%x)\n", -// OBSOLETE sal.line, sal.end, func_end)); -// OBSOLETE func_end = min (func_end, func_addr + DEFAULT_SEARCH_LIMIT); -// OBSOLETE } -// OBSOLETE } -// OBSOLETE else -// OBSOLETE func_end = pc + DEFAULT_SEARCH_LIMIT; -// OBSOLETE decode_prologue (pc, func_end, &sal.end, 0, 0, 0); -// OBSOLETE return sal.end; -// OBSOLETE } -// OBSOLETE -// OBSOLETE static unsigned long -// OBSOLETE m32r_scan_prologue (struct frame_info *fi, struct frame_saved_regs *fsr) -// OBSOLETE { -// OBSOLETE struct symtab_and_line sal; -// OBSOLETE CORE_ADDR prologue_start, prologue_end, current_pc; -// OBSOLETE unsigned long framesize = 0; -// OBSOLETE -// OBSOLETE /* this code essentially duplicates skip_prologue, -// OBSOLETE but we need the start address below. */ -// OBSOLETE -// OBSOLETE if (find_pc_partial_function (fi->pc, NULL, &prologue_start, &prologue_end)) -// OBSOLETE { -// OBSOLETE sal = find_pc_line (prologue_start, 0); -// OBSOLETE -// OBSOLETE if (sal.line == 0) /* no line info, use current PC */ -// OBSOLETE if (prologue_start == entry_point_address ()) -// OBSOLETE return 0; -// OBSOLETE } -// OBSOLETE else -// OBSOLETE { -// OBSOLETE prologue_start = fi->pc; -// OBSOLETE prologue_end = prologue_start + 48; /* We're in the boondocks: -// OBSOLETE allow for 16 pushes, an add, -// OBSOLETE and "mv fp,sp" */ -// OBSOLETE } -// OBSOLETE #if 0 -// OBSOLETE prologue_end = min (prologue_end, fi->pc); -// OBSOLETE #endif -// OBSOLETE insn_debug (("fipc(%08x) start(%08x) end(%08x)\n", -// OBSOLETE fi->pc, prologue_start, prologue_end)); -// OBSOLETE prologue_end = min (prologue_end, prologue_start + DEFAULT_SEARCH_LIMIT); -// OBSOLETE decode_prologue (prologue_start, prologue_end, &prologue_end, &framesize, -// OBSOLETE fi, fsr); -// OBSOLETE return framesize; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: init_extra_frame_info -// OBSOLETE This function actually figures out the frame address for a given pc and -// OBSOLETE sp. This is tricky on the m32r because we sometimes don't use an explicit -// OBSOLETE frame pointer, and the previous stack pointer isn't necessarily recorded -// OBSOLETE on the stack. The only reliable way to get this info is to -// OBSOLETE examine the prologue. */ -// OBSOLETE -// OBSOLETE void -// OBSOLETE m32r_init_extra_frame_info (struct frame_info *fi) -// OBSOLETE { -// OBSOLETE int reg; -// OBSOLETE -// OBSOLETE if (fi->next) -// OBSOLETE fi->pc = FRAME_SAVED_PC (fi->next); -// OBSOLETE -// OBSOLETE memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs); -// OBSOLETE -// OBSOLETE if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) -// OBSOLETE { -// OBSOLETE /* We need to setup fi->frame here because run_stack_dummy gets it wrong -// OBSOLETE by assuming it's always FP. */ -// OBSOLETE fi->frame = deprecated_read_register_dummy (fi->pc, fi->frame, -// OBSOLETE SP_REGNUM); -// OBSOLETE fi->framesize = 0; -// OBSOLETE return; -// OBSOLETE } -// OBSOLETE else -// OBSOLETE { -// OBSOLETE fi->using_frame_pointer = 0; -// OBSOLETE fi->framesize = m32r_scan_prologue (fi, &fi->fsr); -// OBSOLETE -// OBSOLETE if (!fi->next) -// OBSOLETE if (fi->using_frame_pointer) -// OBSOLETE { -// OBSOLETE fi->frame = read_register (FP_REGNUM); -// OBSOLETE } -// OBSOLETE else -// OBSOLETE fi->frame = read_register (SP_REGNUM); -// OBSOLETE else -// OBSOLETE /* fi->next means this is not the innermost frame */ if (fi->using_frame_pointer) -// OBSOLETE /* we have an FP */ -// OBSOLETE if (fi->next->fsr.regs[FP_REGNUM] != 0) /* caller saved our FP */ -// OBSOLETE fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4); -// OBSOLETE for (reg = 0; reg < NUM_REGS; reg++) -// OBSOLETE if (fi->fsr.regs[reg] != 0) -// OBSOLETE fi->fsr.regs[reg] = fi->frame + fi->framesize - fi->fsr.regs[reg]; -// OBSOLETE } -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: m32r_virtual_frame_pointer -// OBSOLETE Return the register that the function uses for a frame pointer, -// OBSOLETE plus any necessary offset to be applied to the register before -// OBSOLETE any frame pointer offsets. */ -// OBSOLETE -// OBSOLETE void -// OBSOLETE m32r_virtual_frame_pointer (CORE_ADDR pc, long *reg, long *offset) -// OBSOLETE { -// OBSOLETE struct frame_info *fi = deprecated_frame_xmalloc (); -// OBSOLETE struct cleanup *old_chain = make_cleanup (xfree, fi); -// OBSOLETE -// OBSOLETE /* Set up a dummy frame_info. */ -// OBSOLETE fi->next = NULL; -// OBSOLETE fi->prev = NULL; -// OBSOLETE fi->frame = 0; -// OBSOLETE fi->pc = pc; -// OBSOLETE -// OBSOLETE /* Analyze the prolog and fill in the extra info. */ -// OBSOLETE m32r_init_extra_frame_info (fi); -// OBSOLETE -// OBSOLETE /* Results will tell us which type of frame it uses. */ -// OBSOLETE if (fi->using_frame_pointer) -// OBSOLETE { -// OBSOLETE *reg = FP_REGNUM; -// OBSOLETE *offset = 0; -// OBSOLETE } -// OBSOLETE else -// OBSOLETE { -// OBSOLETE *reg = SP_REGNUM; -// OBSOLETE *offset = 0; -// OBSOLETE } -// OBSOLETE do_cleanups (old_chain); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: find_callers_reg -// OBSOLETE Find REGNUM on the stack. Otherwise, it's in an active register. One thing -// OBSOLETE we might want to do here is to check REGNUM against the clobber mask, and -// OBSOLETE somehow flag it as invalid if it isn't saved on the stack somewhere. This -// OBSOLETE would provide a graceful failure mode when trying to get the value of -// OBSOLETE caller-saves registers for an inner frame. */ -// OBSOLETE -// OBSOLETE CORE_ADDR -// OBSOLETE m32r_find_callers_reg (struct frame_info *fi, int regnum) -// OBSOLETE { -// OBSOLETE for (; fi; fi = fi->next) -// OBSOLETE if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) -// OBSOLETE return deprecated_read_register_dummy (fi->pc, fi->frame, regnum); -// OBSOLETE else if (fi->fsr.regs[regnum] != 0) -// OBSOLETE return read_memory_integer (fi->fsr.regs[regnum], -// OBSOLETE REGISTER_RAW_SIZE (regnum)); -// OBSOLETE return read_register (regnum); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: frame_chain Given a GDB frame, determine the address of -// OBSOLETE the calling function's frame. This will be used to create a new -// OBSOLETE GDB frame struct, and then INIT_EXTRA_FRAME_INFO and -// OBSOLETE DEPRECATED_INIT_FRAME_PC will be called for the new frame. For -// OBSOLETE m32r, we save the frame size when we initialize the frame_info. */ -// OBSOLETE -// OBSOLETE CORE_ADDR -// OBSOLETE m32r_frame_chain (struct frame_info *fi) -// OBSOLETE { -// OBSOLETE CORE_ADDR fn_start, callers_pc, fp; -// OBSOLETE -// OBSOLETE /* is this a dummy frame? */ -// OBSOLETE if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) -// OBSOLETE return fi->frame; /* dummy frame same as caller's frame */ -// OBSOLETE -// OBSOLETE /* is caller-of-this a dummy frame? */ -// OBSOLETE callers_pc = FRAME_SAVED_PC (fi); /* find out who called us: */ -// OBSOLETE fp = m32r_find_callers_reg (fi, FP_REGNUM); -// OBSOLETE if (DEPRECATED_PC_IN_CALL_DUMMY (callers_pc, fp, fp)) -// OBSOLETE return fp; /* dummy frame's frame may bear no relation to ours */ -// OBSOLETE -// OBSOLETE if (find_pc_partial_function (fi->pc, 0, &fn_start, 0)) -// OBSOLETE if (fn_start == entry_point_address ()) -// OBSOLETE return 0; /* in _start fn, don't chain further */ -// OBSOLETE if (fi->framesize == 0) -// OBSOLETE { -// OBSOLETE printf_filtered ("cannot determine frame size @ %s , pc(%s)\n", -// OBSOLETE paddr (fi->frame), -// OBSOLETE paddr (fi->pc)); -// OBSOLETE return 0; -// OBSOLETE } -// OBSOLETE insn_debug (("m32rx frame %08x\n", fi->frame + fi->framesize)); -// OBSOLETE return fi->frame + fi->framesize; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: push_return_address (pc) -// OBSOLETE Set up the return address for the inferior function call. -// OBSOLETE Necessary for targets that don't actually execute a JSR/BSR instruction -// OBSOLETE (ie. when using an empty CALL_DUMMY) */ -// OBSOLETE -// OBSOLETE CORE_ADDR -// OBSOLETE m32r_push_return_address (CORE_ADDR pc, CORE_ADDR sp) -// OBSOLETE { -// OBSOLETE write_register (RP_REGNUM, CALL_DUMMY_ADDRESS ()); -// OBSOLETE return sp; -// OBSOLETE } -// OBSOLETE -// OBSOLETE -// OBSOLETE /* Function: pop_frame -// OBSOLETE Discard from the stack the innermost frame, -// OBSOLETE restoring all saved registers. */ -// OBSOLETE -// OBSOLETE struct frame_info * -// OBSOLETE m32r_pop_frame (struct frame_info *frame) -// OBSOLETE { -// OBSOLETE int regnum; -// OBSOLETE -// OBSOLETE if (DEPRECATED_PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame)) -// OBSOLETE generic_pop_dummy_frame (); -// OBSOLETE else -// OBSOLETE { -// OBSOLETE for (regnum = 0; regnum < NUM_REGS; regnum++) -// OBSOLETE if (frame->fsr.regs[regnum] != 0) -// OBSOLETE write_register (regnum, -// OBSOLETE read_memory_integer (frame->fsr.regs[regnum], 4)); -// OBSOLETE -// OBSOLETE write_register (PC_REGNUM, FRAME_SAVED_PC (frame)); -// OBSOLETE write_register (SP_REGNUM, read_register (FP_REGNUM)); -// OBSOLETE if (read_register (PSW_REGNUM) & 0x80) -// OBSOLETE write_register (SPU_REGNUM, read_register (SP_REGNUM)); -// OBSOLETE else -// OBSOLETE write_register (SPI_REGNUM, read_register (SP_REGNUM)); -// OBSOLETE } -// OBSOLETE flush_cached_frames (); -// OBSOLETE return NULL; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: frame_saved_pc -// OBSOLETE Find the caller of this frame. We do this by seeing if RP_REGNUM is saved -// OBSOLETE in the stack anywhere, otherwise we get it from the registers. */ -// OBSOLETE -// OBSOLETE CORE_ADDR -// OBSOLETE m32r_frame_saved_pc (struct frame_info *fi) -// OBSOLETE { -// OBSOLETE if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) -// OBSOLETE return deprecated_read_register_dummy (fi->pc, fi->frame, PC_REGNUM); -// OBSOLETE else -// OBSOLETE return m32r_find_callers_reg (fi, RP_REGNUM); -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: push_arguments -// OBSOLETE Setup the function arguments for calling a function in the inferior. -// OBSOLETE -// OBSOLETE On the Mitsubishi M32R architecture, there are four registers (R0 to R3) -// OBSOLETE which are dedicated for passing function arguments. Up to the first -// OBSOLETE four arguments (depending on size) may go into these registers. -// OBSOLETE The rest go on the stack. -// OBSOLETE -// OBSOLETE Arguments that are smaller than 4 bytes will still take up a whole -// OBSOLETE register or a whole 32-bit word on the stack, and will be -// OBSOLETE right-justified in the register or the stack word. This includes -// OBSOLETE chars, shorts, and small aggregate types. -// OBSOLETE -// OBSOLETE Arguments of 8 bytes size are split between two registers, if -// OBSOLETE available. If only one register is available, the argument will -// OBSOLETE be split between the register and the stack. Otherwise it is -// OBSOLETE passed entirely on the stack. Aggregate types with sizes between -// OBSOLETE 4 and 8 bytes are passed entirely on the stack, and are left-justified -// OBSOLETE within the double-word (as opposed to aggregates smaller than 4 bytes -// OBSOLETE which are right-justified). -// OBSOLETE -// OBSOLETE Aggregates of greater than 8 bytes are first copied onto the stack, -// OBSOLETE and then a pointer to the copy is passed in the place of the normal -// OBSOLETE argument (either in a register if available, or on the stack). -// OBSOLETE -// OBSOLETE Functions that must return an aggregate type can return it in the -// OBSOLETE normal return value registers (R0 and R1) if its size is 8 bytes or -// OBSOLETE less. For larger return values, the caller must allocate space for -// OBSOLETE the callee to copy the return value to. A pointer to this space is -// OBSOLETE passed as an implicit first argument, always in R0. */ -// OBSOLETE -// OBSOLETE CORE_ADDR -// OBSOLETE m32r_push_arguments (int nargs, struct value **args, CORE_ADDR sp, -// OBSOLETE unsigned char struct_return, CORE_ADDR struct_addr) -// OBSOLETE { -// OBSOLETE int stack_offset, stack_alloc; -// OBSOLETE int argreg; -// OBSOLETE int argnum; -// OBSOLETE struct type *type; -// OBSOLETE CORE_ADDR regval; -// OBSOLETE char *val; -// OBSOLETE char valbuf[4]; -// OBSOLETE int len; -// OBSOLETE int odd_sized_struct; -// OBSOLETE -// OBSOLETE /* first force sp to a 4-byte alignment */ -// OBSOLETE sp = sp & ~3; -// OBSOLETE -// OBSOLETE argreg = ARG0_REGNUM; -// OBSOLETE /* The "struct return pointer" pseudo-argument goes in R0 */ -// OBSOLETE if (struct_return) -// OBSOLETE write_register (argreg++, struct_addr); -// OBSOLETE -// OBSOLETE /* Now make sure there's space on the stack */ -// OBSOLETE for (argnum = 0, stack_alloc = 0; -// OBSOLETE argnum < nargs; argnum++) -// OBSOLETE stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3); -// OBSOLETE sp -= stack_alloc; /* make room on stack for args */ -// OBSOLETE -// OBSOLETE -// OBSOLETE /* Now load as many as possible of the first arguments into -// OBSOLETE registers, and push the rest onto the stack. There are 16 bytes -// OBSOLETE in four registers available. Loop thru args from first to last. */ -// OBSOLETE -// OBSOLETE argreg = ARG0_REGNUM; -// OBSOLETE for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++) -// OBSOLETE { -// OBSOLETE type = VALUE_TYPE (args[argnum]); -// OBSOLETE len = TYPE_LENGTH (type); -// OBSOLETE memset (valbuf, 0, sizeof (valbuf)); -// OBSOLETE if (len < 4) -// OBSOLETE { /* value gets right-justified in the register or stack word */ -// OBSOLETE memcpy (valbuf + (4 - len), -// OBSOLETE (char *) VALUE_CONTENTS (args[argnum]), len); -// OBSOLETE val = valbuf; -// OBSOLETE } -// OBSOLETE else -// OBSOLETE val = (char *) VALUE_CONTENTS (args[argnum]); -// OBSOLETE -// OBSOLETE if (len > 4 && (len & 3) != 0) -// OBSOLETE odd_sized_struct = 1; /* such structs go entirely on stack */ -// OBSOLETE else -// OBSOLETE odd_sized_struct = 0; -// OBSOLETE while (len > 0) -// OBSOLETE { -// OBSOLETE if (argreg > ARGLAST_REGNUM || odd_sized_struct) -// OBSOLETE { /* must go on the stack */ -// OBSOLETE write_memory (sp + stack_offset, val, 4); -// OBSOLETE stack_offset += 4; -// OBSOLETE } -// OBSOLETE /* NOTE WELL!!!!! This is not an "else if" clause!!! -// OBSOLETE That's because some *&^%$ things get passed on the stack -// OBSOLETE AND in the registers! */ -// OBSOLETE if (argreg <= ARGLAST_REGNUM) -// OBSOLETE { /* there's room in a register */ -// OBSOLETE regval = extract_address (val, REGISTER_RAW_SIZE (argreg)); -// OBSOLETE write_register (argreg++, regval); -// OBSOLETE } -// OBSOLETE /* Store the value 4 bytes at a time. This means that things -// OBSOLETE larger than 4 bytes may go partly in registers and partly -// OBSOLETE on the stack. */ -// OBSOLETE len -= REGISTER_RAW_SIZE (argreg); -// OBSOLETE val += REGISTER_RAW_SIZE (argreg); -// OBSOLETE } -// OBSOLETE } -// OBSOLETE return sp; -// OBSOLETE } -// OBSOLETE -// OBSOLETE /* Function: fix_call_dummy -// OBSOLETE If there is real CALL_DUMMY code (eg. on the stack), this function -// OBSOLETE has the responsability to insert the address of the actual code that -// OBSOLETE is the target of the target function call. */ -// OBSOLETE -// OBSOLETE void -// OBSOLETE m32r_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, -// OBSOLETE struct value **args, struct type *type, int gcc_p) -// OBSOLETE { -// OBSOLETE /* ld24 r8, <(imm24) fun> */ -// OBSOLETE *(unsigned long *) (dummy) = (fun & 0x00ffffff) | 0xe8000000; -// OBSOLETE } -// OBSOLETE -// OBSOLETE -// OBSOLETE /* Function: m32r_write_sp -// OBSOLETE Because SP is really a read-only register that mirrors either SPU or SPI, -// OBSOLETE we must actually write one of those two as well, depending on PSW. */ -// OBSOLETE -// OBSOLETE void -// OBSOLETE m32r_write_sp (CORE_ADDR val) -// OBSOLETE { -// OBSOLETE unsigned long psw = read_register (PSW_REGNUM); -// OBSOLETE -// OBSOLETE if (psw & 0x80) /* stack mode: user or interrupt */ -// OBSOLETE write_register (SPU_REGNUM, val); -// OBSOLETE else -// OBSOLETE write_register (SPI_REGNUM, val); -// OBSOLETE write_register (SP_REGNUM, val); -// OBSOLETE } -// OBSOLETE -// OBSOLETE void -// OBSOLETE _initialize_m32r_tdep (void) -// OBSOLETE { -// OBSOLETE tm_print_insn = print_insn_m32r; -// OBSOLETE } +/* Target-dependent code for Renesas M32R, for GDB. + + Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003 Free Software + Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#include "defs.h" +#include "frame.h" +#include "frame-unwind.h" +#include "frame-base.h" +#include "symtab.h" +#include "gdbtypes.h" +#include "gdbcmd.h" +#include "gdbcore.h" +#include "gdb_string.h" +#include "value.h" +#include "inferior.h" +#include "symfile.h" +#include "objfiles.h" +#include "language.h" +#include "arch-utils.h" +#include "regcache.h" +#include "trad-frame.h" + +#include "gdb_assert.h" + +struct gdbarch_tdep +{ + /* gdbarch target dependent data here. Currently unused for M32R. */ +}; + +/* m32r register names. */ + +enum +{ + R0_REGNUM = 0, + R3_REGNUM = 3, + M32R_FP_REGNUM = 13, + LR_REGNUM = 14, + M32R_SP_REGNUM = 15, + PSW_REGNUM = 16, + M32R_PC_REGNUM = 21, + /* m32r calling convention. */ + ARG1_REGNUM = R0_REGNUM, + ARGN_REGNUM = R3_REGNUM, + RET1_REGNUM = R0_REGNUM, +}; + +/* Local functions */ + +extern void _initialize_m32r_tdep (void); + +static CORE_ADDR +m32r_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp) +{ + /* Align to the size of an instruction (so that they can safely be + pushed onto the stack. */ + return sp & ~3; +} + +/* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of + EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc + and TYPE is the type (which is known to be struct, union or array). + + The m32r returns anything less than 8 bytes in size in + registers. */ + +static int +m32r_use_struct_convention (int gcc_p, struct type *type) +{ + return (TYPE_LENGTH (type) > 8); +} + + +/* BREAKPOINT */ +#define M32R_BE_BREAKPOINT32 {0x10, 0xf1, 0x70, 0x00} +#define M32R_LE_BREAKPOINT32 {0xf1, 0x10, 0x00, 0x70} +#define M32R_BE_BREAKPOINT16 {0x10, 0xf1} +#define M32R_LE_BREAKPOINT16 {0xf1, 0x10} + +static int +m32r_memory_insert_breakpoint (CORE_ADDR addr, char *contents_cache) +{ + int val; + unsigned char *bp; + int bplen; + + bplen = (addr & 3) ? 2 : 4; + + /* Save the memory contents. */ + val = target_read_memory (addr, contents_cache, bplen); + if (val != 0) + return val; /* return error */ + + /* Determine appropriate breakpoint contents and size for this address. */ + if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + { + if (((addr & 3) == 0) && + ((contents_cache[0] & 0x80) || (contents_cache[2] & 0x80))) + { + static unsigned char insn[] = M32R_BE_BREAKPOINT32; + bp = insn; + bplen = sizeof (insn); + } + else + { + static unsigned char insn[] = M32R_BE_BREAKPOINT16; + bp = insn; + bplen = sizeof (insn); + } + } + else + { /* little-endian */ + if (((addr & 3) == 0) && + ((contents_cache[1] & 0x80) || (contents_cache[3] & 0x80))) + { + static unsigned char insn[] = M32R_LE_BREAKPOINT32; + bp = insn; + bplen = sizeof (insn); + } + else + { + static unsigned char insn[] = M32R_LE_BREAKPOINT16; + bp = insn; + bplen = sizeof (insn); + } + } + + /* Write the breakpoint. */ + val = target_write_memory (addr, (char *) bp, bplen); + return val; +} + +static int +m32r_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache) +{ + int val; + int bplen; + + /* Determine appropriate breakpoint contents and size for this address. */ + if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + { + if (((addr & 3) == 0) && + ((contents_cache[0] & 0x80) || (contents_cache[2] & 0x80))) + { + static unsigned char insn[] = M32R_BE_BREAKPOINT32; + bplen = sizeof (insn); + } + else + { + static unsigned char insn[] = M32R_BE_BREAKPOINT16; + bplen = sizeof (insn); + } + } + else + { + /* little-endian */ + if (((addr & 3) == 0) && + ((contents_cache[1] & 0x80) || (contents_cache[3] & 0x80))) + { + static unsigned char insn[] = M32R_BE_BREAKPOINT32; + bplen = sizeof (insn); + } + else + { + static unsigned char insn[] = M32R_BE_BREAKPOINT16; + bplen = sizeof (insn); + } + } + + /* Write contents. */ + val = target_write_memory (addr, contents_cache, bplen); + return val; +} + +static const unsigned char * +m32r_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) +{ + unsigned char *bp; + + /* Determine appropriate breakpoint. */ + if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + { + if ((*pcptr & 3) == 0) + { + static unsigned char insn[] = M32R_BE_BREAKPOINT32; + bp = insn; + *lenptr = sizeof (insn); + } + else + { + static unsigned char insn[] = M32R_BE_BREAKPOINT16; + bp = insn; + *lenptr = sizeof (insn); + } + } + else + { + if ((*pcptr & 3) == 0) + { + static unsigned char insn[] = M32R_LE_BREAKPOINT32; + bp = insn; + *lenptr = sizeof (insn); + } + else + { + static unsigned char insn[] = M32R_LE_BREAKPOINT16; + bp = insn; + *lenptr = sizeof (insn); + } + } + + return bp; +} + + +char *m32r_register_names[] = { + "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", + "r8", "r9", "r10", "r11", "r12", "fp", "lr", "sp", + "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch", + "evb" +}; + +static int +m32r_num_regs (void) +{ + return (sizeof (m32r_register_names) / sizeof (m32r_register_names[0])); +} + +static const char * +m32r_register_name (int reg_nr) +{ + if (reg_nr < 0) + return NULL; + if (reg_nr >= m32r_num_regs ()) + return NULL; + return m32r_register_names[reg_nr]; +} + + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +static struct type * +m32r_register_type (struct gdbarch *gdbarch, int reg_nr) +{ + if (reg_nr == M32R_PC_REGNUM) + return builtin_type_void_func_ptr; + else if (reg_nr == M32R_SP_REGNUM || reg_nr == M32R_FP_REGNUM) + return builtin_type_void_data_ptr; + else + return builtin_type_int32; +} + + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. + + Things always get returned in RET1_REGNUM, RET2_REGNUM. */ + +static void +m32r_store_return_value (struct type *type, struct regcache *regcache, + const void *valbuf) +{ + CORE_ADDR regval; + int len = TYPE_LENGTH (type); + + regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len); + regcache_cooked_write_unsigned (regcache, RET1_REGNUM, regval); + + if (len > 4) + { + regval = extract_unsigned_integer (valbuf + 4, len - 4); + regcache_cooked_write_unsigned (regcache, RET1_REGNUM + 1, regval); + } +} + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +static CORE_ADDR +m32r_extract_struct_value_address (struct regcache *regcache) +{ + ULONGEST addr; + regcache_cooked_read_unsigned (regcache, ARG1_REGNUM, &addr); + return addr; +} + + +/* This is required by skip_prologue. The results of decoding a prologue + should be cached because this thrashing is getting nuts. */ + +static void +decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, + CORE_ADDR *pl_endptr) +{ + unsigned long framesize; + int insn; + int op1; + int maybe_one_more = 0; + CORE_ADDR after_prologue = 0; + CORE_ADDR after_stack_adjust = 0; + CORE_ADDR current_pc; + + framesize = 0; + after_prologue = 0; + + for (current_pc = start_pc; current_pc < scan_limit; current_pc += 2) + { + insn = read_memory_unsigned_integer (current_pc, 2); + + /* If this is a 32 bit instruction, we dont want to examine its + immediate data as though it were an instruction */ + if (current_pc & 0x02) + { + /* Clear the parallel execution bit from 16 bit instruction */ + if (maybe_one_more) + { + /* The last instruction was a branch, usually terminates + the series, but if this is a parallel instruction, + it may be a stack framing instruction */ + if (!(insn & 0x8000)) + { + /* nope, we are really done */ + break; + } + } + /* decode this instruction further */ + insn &= 0x7fff; + } + else + { + if (maybe_one_more) + break; /* This isnt the one more */ + if (insn & 0x8000) + { + if (current_pc == scan_limit) + scan_limit += 2; /* extend the search */ + current_pc += 2; /* skip the immediate data */ + if (insn == 0x8faf) /* add3 sp, sp, xxxx */ + /* add 16 bit sign-extended offset */ + { + framesize += + -((short) read_memory_unsigned_integer (current_pc, 2)); + } + else + { + if (((insn >> 8) == 0xe4) && /* ld24 r4, xxxxxx; sub sp, r4 */ + read_memory_unsigned_integer (current_pc + 2, + 2) == 0x0f24) + /* subtract 24 bit sign-extended negative-offset */ + { + insn = read_memory_unsigned_integer (current_pc - 2, 4); + if (insn & 0x00800000) /* sign extend */ + insn |= 0xff000000; /* negative */ + else + insn &= 0x00ffffff; /* positive */ + framesize += insn; + } + } + after_prologue = current_pc; + continue; + } + } + op1 = insn & 0xf000; /* isolate just the first nibble */ + + if ((insn & 0xf0ff) == 0x207f) + { /* st reg, @-sp */ + int regno; + framesize += 4; + regno = ((insn >> 8) & 0xf); + after_prologue = 0; + continue; + } + if ((insn >> 8) == 0x4f) /* addi sp, xx */ + /* add 8 bit sign-extended offset */ + { + int stack_adjust = (char) (insn & 0xff); + + /* there are probably two of these stack adjustments: + 1) A negative one in the prologue, and + 2) A positive one in the epilogue. + We are only interested in the first one. */ + + if (stack_adjust < 0) + { + framesize -= stack_adjust; + after_prologue = 0; + /* A frameless function may have no "mv fp, sp". + In that case, this is the end of the prologue. */ + after_stack_adjust = current_pc + 2; + } + continue; + } + if (insn == 0x1d8f) + { /* mv fp, sp */ + after_prologue = current_pc + 2; + break; /* end of stack adjustments */ + } + /* Nop looks like a branch, continue explicitly */ + if (insn == 0x7000) + { + after_prologue = current_pc + 2; + continue; /* nop occurs between pushes */ + } + /* End of prolog if any of these are branch instructions */ + if ((op1 == 0x7000) || (op1 == 0xb000) || (op1 == 0xf000)) + { + after_prologue = current_pc; + maybe_one_more = 1; + continue; + } + /* Some of the branch instructions are mixed with other types */ + if (op1 == 0x1000) + { + int subop = insn & 0x0ff0; + if ((subop == 0x0ec0) || (subop == 0x0fc0)) + { + after_prologue = current_pc; + maybe_one_more = 1; + continue; /* jmp , jl */ + } + } + } + + if (current_pc >= scan_limit) + { + if (pl_endptr) + { + if (after_stack_adjust != 0) + /* We did not find a "mv fp,sp", but we DID find + a stack_adjust. Is it safe to use that as the + end of the prologue? I just don't know. */ + { + *pl_endptr = after_stack_adjust; + } + else + /* We reached the end of the loop without finding the end + of the prologue. No way to win -- we should report failure. + The way we do that is to return the original start_pc. + GDB will set a breakpoint at the start of the function (etc.) */ + *pl_endptr = start_pc; + } + return; + } + if (after_prologue == 0) + after_prologue = current_pc; + + if (pl_endptr) + *pl_endptr = after_prologue; +} /* decode_prologue */ + +/* Function: skip_prologue + Find end of function prologue */ + +#define DEFAULT_SEARCH_LIMIT 44 + +CORE_ADDR +m32r_skip_prologue (CORE_ADDR pc) +{ + CORE_ADDR func_addr, func_end; + struct symtab_and_line sal; + + /* See what the symbol table says */ + + if (find_pc_partial_function (pc, NULL, &func_addr, &func_end)) + { + sal = find_pc_line (func_addr, 0); + + if (sal.line != 0 && sal.end <= func_end) + { + func_end = sal.end; + } + else + /* Either there's no line info, or the line after the prologue is after + the end of the function. In this case, there probably isn't a + prologue. */ + { + func_end = min (func_end, func_addr + DEFAULT_SEARCH_LIMIT); + } + } + else + func_end = pc + DEFAULT_SEARCH_LIMIT; + decode_prologue (pc, func_end, &sal.end); + return sal.end; +} + + +struct m32r_unwind_cache +{ + /* The previous frame's inner most stack address. Used as this + frame ID's stack_addr. */ + CORE_ADDR prev_sp; + /* The frame's base, optionally used by the high-level debug info. */ + CORE_ADDR base; + int size; + /* How far the SP and r13 (FP) have been offset from the start of + the stack frame (as defined by the previous frame's stack + pointer). */ + LONGEST sp_offset; + LONGEST r13_offset; + int uses_frame; + /* Table indicating the location of each and every register. */ + struct trad_frame_saved_reg *saved_regs; +}; + +/* Put here the code to store, into fi->saved_regs, the addresses of + the saved registers of frame described by FRAME_INFO. This + includes special registers such as pc and fp saved in special ways + in the stack frame. sp is even more special: the address we return + for it IS the sp for the next frame. */ + +static struct m32r_unwind_cache * +m32r_frame_unwind_cache (struct frame_info *next_frame, + void **this_prologue_cache) +{ + CORE_ADDR pc; + ULONGEST prev_sp; + ULONGEST this_base; + unsigned long op; + int i; + struct m32r_unwind_cache *info; + + if ((*this_prologue_cache)) + return (*this_prologue_cache); + + info = FRAME_OBSTACK_ZALLOC (struct m32r_unwind_cache); + (*this_prologue_cache) = info; + info->saved_regs = trad_frame_alloc_saved_regs (next_frame); + + info->size = 0; + info->sp_offset = 0; + + info->uses_frame = 0; + for (pc = frame_func_unwind (next_frame); + pc > 0 && pc < frame_pc_unwind (next_frame); pc += 2) + { + if ((pc & 2) == 0) + { + op = get_frame_memory_unsigned (next_frame, pc, 4); + if ((op & 0x80000000) == 0x80000000) + { + /* 32-bit instruction */ + if ((op & 0xffff0000) == 0x8faf0000) + { + /* add3 sp,sp,xxxx */ + short n = op & 0xffff; + info->sp_offset += n; + } + else if (((op >> 8) == 0xe4) && /* ld24 r4, xxxxxx; sub sp, r4 */ + get_frame_memory_unsigned (next_frame, pc + 4, + 2) == 0x0f24) + { + unsigned long n = op & 0xffffff; + info->sp_offset += n; + pc += 2; + } + else + break; + + pc += 2; + continue; + } + } + + /* 16-bit instructions */ + op = get_frame_memory_unsigned (next_frame, pc, 2) & 0x7fff; + if ((op & 0xf0ff) == 0x207f) + { + /* st rn, @-sp */ + int regno = ((op >> 8) & 0xf); + info->sp_offset -= 4; + info->saved_regs[regno].addr = info->sp_offset; + } + else if ((op & 0xff00) == 0x4f00) + { + /* addi sp, xx */ + int n = (char) (op & 0xff); + info->sp_offset += n; + } + else if (op == 0x1d8f) + { + /* mv fp, sp */ + info->uses_frame = 1; + info->r13_offset = info->sp_offset; + } + else if (op == 0x7000) + /* nop */ + continue; + else + break; + } + + info->size = -info->sp_offset; + + /* Compute the previous frame's stack pointer (which is also the + frame's ID's stack address), and this frame's base pointer. */ + if (info->uses_frame) + { + /* The SP was moved to the FP. This indicates that a new frame + was created. Get THIS frame's FP value by unwinding it from + the next frame. */ + frame_unwind_unsigned_register (next_frame, M32R_FP_REGNUM, &this_base); + /* The FP points at the last saved register. Adjust the FP back + to before the first saved register giving the SP. */ + prev_sp = this_base + info->size; + } + else + { + /* Assume that the FP is this frame's SP but with that pushed + stack space added back. */ + frame_unwind_unsigned_register (next_frame, M32R_SP_REGNUM, &this_base); + prev_sp = this_base + info->size; + } + + /* Convert that SP/BASE into real addresses. */ + info->prev_sp = prev_sp; + info->base = this_base; + + /* Adjust all the saved registers so that they contain addresses and + not offsets. */ + for (i = 0; i < NUM_REGS - 1; i++) + if (trad_frame_addr_p (info->saved_regs, i)) + info->saved_regs[i].addr = (info->prev_sp + info->saved_regs[i].addr); + + /* The call instruction moves the caller's PC in the callee's LR. + Since this is an unwind, do the reverse. Copy the location of LR + into PC (the address / regnum) so that a request for PC will be + converted into a request for the LR. */ + info->saved_regs[M32R_PC_REGNUM] = info->saved_regs[LR_REGNUM]; + + /* The previous frame's SP needed to be computed. Save the computed + value. */ + trad_frame_set_value (info->saved_regs, M32R_SP_REGNUM, prev_sp); + + return info; +} + +static CORE_ADDR +m32r_read_pc (ptid_t ptid) +{ + ptid_t save_ptid; + CORE_ADDR pc; + + save_ptid = inferior_ptid; + inferior_ptid = ptid; + pc = (int) read_register (M32R_PC_REGNUM); + inferior_ptid = save_ptid; + return pc; +} + +static void +m32r_write_pc (CORE_ADDR val, ptid_t ptid) +{ + ptid_t save_ptid; + + save_ptid = inferior_ptid; + inferior_ptid = ptid; + write_register (M32R_PC_REGNUM, val); + inferior_ptid = save_ptid; +} + +static CORE_ADDR +m32r_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) +{ + ULONGEST sp; + frame_unwind_unsigned_register (next_frame, M32R_SP_REGNUM, &sp); + return sp; +} + + +static CORE_ADDR +m32r_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, + struct regcache *regcache, CORE_ADDR bp_addr, int nargs, + struct value **args, CORE_ADDR sp, int struct_return, + CORE_ADDR struct_addr) +{ + int stack_offset, stack_alloc; + int argreg = ARG1_REGNUM; + int argnum; + struct type *type; + enum type_code typecode; + CORE_ADDR regval; + char *val; + char valbuf[MAX_REGISTER_SIZE]; + int len; + int odd_sized_struct; + + /* first force sp to a 4-byte alignment */ + sp = sp & ~3; + + /* Set the return address. For the m32r, the return breakpoint is + always at BP_ADDR. */ + regcache_cooked_write_unsigned (regcache, LR_REGNUM, bp_addr); + + /* If STRUCT_RETURN is true, then the struct return address (in + STRUCT_ADDR) will consume the first argument-passing register. + Both adjust the register count and store that value. */ + if (struct_return) + { + regcache_cooked_write_unsigned (regcache, argreg, struct_addr); + argreg++; + } + + /* Now make sure there's space on the stack */ + for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++) + stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3); + sp -= stack_alloc; /* make room on stack for args */ + + for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++) + { + type = VALUE_TYPE (args[argnum]); + typecode = TYPE_CODE (type); + len = TYPE_LENGTH (type); + + memset (valbuf, 0, sizeof (valbuf)); + + /* Passes structures that do not fit in 2 registers by reference. */ + if (len > 8 + && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)) + { + store_unsigned_integer (valbuf, 4, VALUE_ADDRESS (args[argnum])); + typecode = TYPE_CODE_PTR; + len = 4; + val = valbuf; + } + else if (len < 4) + { + /* value gets right-justified in the register or stack word */ + memcpy (valbuf + (REGISTER_RAW_SIZE (argreg) - len), + (char *) VALUE_CONTENTS (args[argnum]), len); + val = valbuf; + } + else + val = (char *) VALUE_CONTENTS (args[argnum]); + + while (len > 0) + { + if (argreg > ARGN_REGNUM) + { + /* must go on the stack */ + write_memory (sp + stack_offset, val, 4); + stack_offset += 4; + } + else if (argreg <= ARGN_REGNUM) + { + /* there's room in a register */ + regval = + extract_unsigned_integer (val, REGISTER_RAW_SIZE (argreg)); + regcache_cooked_write_unsigned (regcache, argreg++, regval); + } + + /* Store the value 4 bytes at a time. This means that things + larger than 4 bytes may go partly in registers and partly + on the stack. */ + len -= REGISTER_RAW_SIZE (argreg); + val += REGISTER_RAW_SIZE (argreg); + } + } + + /* Finally, update the SP register. */ + regcache_cooked_write_unsigned (regcache, M32R_SP_REGNUM, sp); + + return sp; +} + + +/* Given a return value in `regbuf' with a type `valtype', + extract and copy its value into `valbuf'. */ + +static void +m32r_extract_return_value (struct type *type, struct regcache *regcache, + void *dst) +{ + bfd_byte *valbuf = dst; + int len = TYPE_LENGTH (type); + ULONGEST tmp; + + /* By using store_unsigned_integer we avoid having to do + anything special for small big-endian values. */ + regcache_cooked_read_unsigned (regcache, RET1_REGNUM, &tmp); + store_unsigned_integer (valbuf, (len > 4 ? len - 4 : len), tmp); + + /* Ignore return values more than 8 bytes in size because the m32r + returns anything more than 8 bytes in the stack. */ + if (len > 4) + { + regcache_cooked_read_unsigned (regcache, RET1_REGNUM + 1, &tmp); + store_unsigned_integer (valbuf + len - 4, 4, tmp); + } +} + + +static CORE_ADDR +m32r_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) +{ + ULONGEST pc; + frame_unwind_unsigned_register (next_frame, M32R_PC_REGNUM, &pc); + return pc; +} + +/* Given a GDB frame, determine the address of the calling function's + frame. This will be used to create a new GDB frame struct. */ + +static void +m32r_frame_this_id (struct frame_info *next_frame, + void **this_prologue_cache, struct frame_id *this_id) +{ + struct m32r_unwind_cache *info + = m32r_frame_unwind_cache (next_frame, this_prologue_cache); + CORE_ADDR base; + CORE_ADDR func; + struct minimal_symbol *msym_stack; + struct frame_id id; + + /* The FUNC is easy. */ + func = frame_func_unwind (next_frame); + + /* This is meant to halt the backtrace at "_start". Make sure we + don't halt it at a generic dummy frame. */ + if (inside_entry_file (func)) + return; + + /* Check if the stack is empty. */ + msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL); + if (msym_stack && info->base == SYMBOL_VALUE_ADDRESS (msym_stack)) + return; + + /* Hopefully the prologue analysis either correctly determined the + frame's base (which is the SP from the previous frame), or set + that base to "NULL". */ + base = info->prev_sp; + if (base == 0) + return; + + id = frame_id_build (base, func); + + /* Check that we're not going round in circles with the same frame + ID (but avoid applying the test to sentinel frames which do go + round in circles). Can't use frame_id_eq() as that doesn't yet + compare the frame's PC value. */ + if (frame_relative_level (next_frame) >= 0 + && get_frame_type (next_frame) != DUMMY_FRAME + && frame_id_eq (get_frame_id (next_frame), id)) + return; + + (*this_id) = id; +} + +static void +m32r_frame_prev_register (struct frame_info *next_frame, + void **this_prologue_cache, + int regnum, int *optimizedp, + enum lval_type *lvalp, CORE_ADDR *addrp, + int *realnump, void *bufferp) +{ + struct m32r_unwind_cache *info + = m32r_frame_unwind_cache (next_frame, this_prologue_cache); + trad_frame_prev_register (next_frame, info->saved_regs, regnum, + optimizedp, lvalp, addrp, realnump, bufferp); +} + +static const struct frame_unwind m32r_frame_unwind = { + NORMAL_FRAME, + m32r_frame_this_id, + m32r_frame_prev_register +}; + +static const struct frame_unwind * +m32r_frame_p (CORE_ADDR pc) +{ + return &m32r_frame_unwind; +} + +static CORE_ADDR +m32r_frame_base_address (struct frame_info *next_frame, void **this_cache) +{ + struct m32r_unwind_cache *info + = m32r_frame_unwind_cache (next_frame, this_cache); + return info->base; +} + +static const struct frame_base m32r_frame_base = { + &m32r_frame_unwind, + m32r_frame_base_address, + m32r_frame_base_address, + m32r_frame_base_address +}; + +/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that + dummy frame. The frame ID's base needs to match the TOS value + saved by save_dummy_frame_tos(), and the PC match the dummy frame's + breakpoint. */ + +static struct frame_id +m32r_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) +{ + return frame_id_build (m32r_unwind_sp (gdbarch, next_frame), + frame_pc_unwind (next_frame)); +} + + +static gdbarch_init_ftype m32r_gdbarch_init; + +static struct gdbarch * +m32r_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) +{ + struct gdbarch *gdbarch; + struct gdbarch_tdep *tdep; + + /* If there is already a candidate, use it. */ + arches = gdbarch_list_lookup_by_info (arches, &info); + if (arches != NULL) + return arches->gdbarch; + + /* Allocate space for the new architecture. */ + tdep = XMALLOC (struct gdbarch_tdep); + gdbarch = gdbarch_alloc (&info, tdep); + + set_gdbarch_read_pc (gdbarch, m32r_read_pc); + set_gdbarch_write_pc (gdbarch, m32r_write_pc); + set_gdbarch_unwind_sp (gdbarch, m32r_unwind_sp); + + set_gdbarch_num_regs (gdbarch, m32r_num_regs ()); + set_gdbarch_sp_regnum (gdbarch, M32R_SP_REGNUM); + set_gdbarch_register_name (gdbarch, m32r_register_name); + set_gdbarch_register_type (gdbarch, m32r_register_type); + + set_gdbarch_extract_return_value (gdbarch, m32r_extract_return_value); + set_gdbarch_push_dummy_call (gdbarch, m32r_push_dummy_call); + set_gdbarch_store_return_value (gdbarch, m32r_store_return_value); + set_gdbarch_extract_struct_value_address (gdbarch, + m32r_extract_struct_value_address); + set_gdbarch_use_struct_convention (gdbarch, m32r_use_struct_convention); + + set_gdbarch_skip_prologue (gdbarch, m32r_skip_prologue); + set_gdbarch_inner_than (gdbarch, core_addr_lessthan); + set_gdbarch_decr_pc_after_break (gdbarch, 0); + set_gdbarch_function_start_offset (gdbarch, 0); + set_gdbarch_breakpoint_from_pc (gdbarch, m32r_breakpoint_from_pc); + set_gdbarch_memory_insert_breakpoint (gdbarch, + m32r_memory_insert_breakpoint); + set_gdbarch_memory_remove_breakpoint (gdbarch, + m32r_memory_remove_breakpoint); + + set_gdbarch_frame_args_skip (gdbarch, 0); + set_gdbarch_frameless_function_invocation (gdbarch, + frameless_look_for_prologue); + + set_gdbarch_frame_align (gdbarch, m32r_frame_align); + + frame_unwind_append_predicate (gdbarch, m32r_frame_p); + frame_base_set_default (gdbarch, &m32r_frame_base); + + /* Methods for saving / extracting a dummy frame's ID. The ID's + stack address must match the SP value returned by + PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */ + set_gdbarch_unwind_dummy_id (gdbarch, m32r_unwind_dummy_id); + + /* Return the unwound PC value. */ + set_gdbarch_unwind_pc (gdbarch, m32r_unwind_pc); + + set_gdbarch_print_insn (gdbarch, print_insn_m32r); + + return gdbarch; +} + +void +_initialize_m32r_tdep (void) +{ + register_gdbarch_init (bfd_arch_m32r, m32r_gdbarch_init); +} |