* [patch/rfc] Eliminate the es1800 target
@ 2003-01-29 20:32 Andrew Cagney
2003-01-29 20:37 ` Daniel Jacobowitz
0 siblings, 1 reply; 5+ messages in thread
From: Andrew Cagney @ 2003-01-29 20:32 UTC (permalink / raw)
To: gdb-patches
[-- Attachment #1: Type: text/plain, Size: 242 bytes --]
Hello,
This code/target pre-dates the old Cygnus CVS repository (~89). Given
that I really don't believe that one of these beasties still exists, I'm
thinking of just removing it. (I tried and it doesn't compile).
Anyone object?
Andrew
[-- Attachment #2: diffs --]
[-- Type: text/plain, Size: 247896 bytes --]
2003-01-29 Andrew Cagney <ac131313@redhat.com>
* NEWS: Note that the m32r-*-elf* is obsolete.
* monitor.c (monitor_expect): Obsolete reference to m32r.
* configure.tgt: Mark m32r-*-elf* as obsolete.
* MAINTAINERS: Mark m32k as obsolete.
* m32r-rom.c: Obsolete file.
* config/m32r/m32r.mt: Obsolete file.
* config/m32r/tm-m32r.h: Obsolete file.
* m32r-stub.c: Obsolete file.
* m32r-tdep.c: Obsolete file.
Index: MAINTAINERS
===================================================================
RCS file: /cvs/src/src/gdb/MAINTAINERS,v
retrieving revision 1.219
diff -u -r1.219 MAINTAINERS
--- MAINTAINERS 20 Jan 2003 00:46:42 -0000 1.219
+++ MAINTAINERS 29 Jan 2003 19:10:10 -0000
@@ -96,9 +96,7 @@
(--target=ia64-elf broken)
Kevin Buettner kevinb@redhat.com
- m32r (--target=m32r-elf broken)
- Michael Snyder msnyder@redhat.com
- OBSOLETE candidate, not multi-arch
+ m32r (--target=m32r-elf OBSOLETE)
m68hc11 --target=m68hc11-elf ,-Werror ,
Stephane Carrez stcarrez@nerim.fr
Index: NEWS
===================================================================
RCS file: /cvs/src/src/gdb/NEWS,v
retrieving revision 1.98
diff -u -r1.98 NEWS
--- NEWS 22 Jan 2003 23:50:35 -0000 1.98
+++ NEWS 29 Jan 2003 19:10:10 -0000
@@ -32,6 +32,8 @@
configurations, the next release of GDB will have their sources
permanently REMOVED.
+Mitsubishi M32R/D w/simulator m32r-*-elf*
+
* REMOVED configurations and files
V850EA ISA
Index: configure.tgt
===================================================================
RCS file: /cvs/src/src/gdb/configure.tgt,v
retrieving revision 1.90
diff -u -r1.90 configure.tgt
--- configure.tgt 4 Jan 2003 23:47:12 -0000 1.90
+++ configure.tgt 29 Jan 2003 19:10:10 -0000
@@ -116,7 +116,7 @@
;;
ia64*-*-*) gdb_target=ia64 ;;
-m32r-*-elf*) gdb_target=m32r ;;
+# OBSOLETE m32r-*-elf*) gdb_target=m32r ;;
m68hc11*-*-*|m6811*-*-*) gdb_target=m68hc11 ;;
Index: m32r-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/m32r-rom.c,v
retrieving revision 1.9
diff -u -r1.9 m32r-rom.c
--- m32r-rom.c 10 Jun 2001 16:25:51 -0000 1.9
+++ m32r-rom.c 29 Jan 2003 19:10:10 -0000
@@ -1,626 +1,626 @@
-/* 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 Mitsubishi 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 */
-
-
-/*
- * 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.");
-}
+// 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 }
Index: m32r-stub.c
===================================================================
RCS file: /cvs/src/src/gdb/m32r-stub.c,v
retrieving revision 1.5
diff -u -r1.5 m32r-stub.c
--- m32r-stub.c 4 Oct 2002 22:17:36 -0000 1.5
+++ m32r-stub.c 29 Jan 2003 19:10:10 -0000
@@ -1,1718 +1,1718 @@
-/****************************************************************************
-
- 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;
-
- /* Do not call finish_from_step() if this is not a trap #1
- * (breakpoint trap). Without this check, the finish_from_step()
- * might interpret a system call trap as a single step trap. This
- * can happen if: the stub receives 's' and exits, but an interrupt
- * was pending; the interrupt is now handled and causes the stub to
- * be reentered because some function makes a system call.
- */
- if (exceptionVector == 1) /* Trap exception? */
- if (!finish_from_step()) /* Go see if stepping state needs update. */
- 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 ("
-stash_registers:
- push r0
- push r1
- seth r1, #shigh(registers)
- add3 r1, r1, #low(registers)
- pop r0 ; r1
- st r0, @(4,r1)
- pop r0 ; r0
- st r0, @r1
- addi r1, #4 ; only add 4 as subsequent saves are `pre inc'
- st r2, @+r1
- st r3, @+r1
- st r4, @+r1
- st r5, @+r1
- st r6, @+r1
- st r7, @+r1
- st r8, @+r1
- st r9, @+r1
- st r10, @+r1
- st r11, @+r1
- st r12, @+r1
- st r13, @+r1 ; fp
- pop r0 ; lr (r14)
- st r0, @+r1
- st sp, @+r1 ; sp contains right value at this point
- mvfc r0, cr0
- st r0, @+r1 ; cr0 == PSW
- mvfc r0, cr1
- st r0, @+r1 ; cr1 == CBR
- mvfc r0, cr2
- st r0, @+r1 ; cr2 == SPI
- mvfc r0, cr3
- st r0, @+r1 ; cr3 == SPU
- mvfc r0, cr6
- st r0, @+r1 ; cr6 == BPC
- st r0, @+r1 ; PC == BPC
- mvfaclo r0
- st r0, @+r1 ; ACCL
- mvfachi r0
- st r0, @+r1 ; ACCH
- 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 ("
-restore_and_return:
- seth r0, #shigh(registers+8)
- add3 r0, r0, #low(registers+8)
- ld r2, @r0+ ; restore r2
- ld r3, @r0+ ; restore r3
- ld r4, @r0+ ; restore r4
- ld r5, @r0+ ; restore r5
- ld r6, @r0+ ; restore r6
- ld r7, @r0+ ; restore r7
- ld r8, @r0+ ; restore r8
- ld r9, @r0+ ; restore r9
- ld r10, @r0+ ; restore r10
- ld r11, @r0+ ; restore r11
- ld r12, @r0+ ; restore r12
- ld r13, @r0+ ; restore r13
- ld r14, @r0+ ; restore r14
- ld r15, @r0+ ; restore r15
- addi r0, #4 ; don't restore PSW (rte will do it)
- ld r1, @r0+ ; restore cr1 == CBR (no-op, because it's read only)
- mvtc r1, cr1
- ld r1, @r0+ ; restore cr2 == SPI
- mvtc r1, cr2
- ld r1, @r0+ ; restore cr3 == SPU
- mvtc r1, cr3
- addi r0, #4 ; skip BPC
- ld r1, @r0+ ; restore cr6 (BPC) == PC
- mvtc r1, cr6
- ld r1, @r0+ ; restore ACCL
- mvtaclo r1
- ld r1, @r0+ ; restore ACCH
- mvtachi r1
- seth r0, #shigh(registers)
- add3 r0, r0, #low(registers)
- ld r1, @(4,r0) ; restore r1
- ld r0, @r0 ; restore r0
- 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 ("
- seth r1, #shigh(stackPtr)
- add3 r1, r1, #low(stackPtr)
- ld r15, @r1 ; setup local stack (protect user stack)
- mv r0, %0
- bl handle_exception
- bl restore_and_return"
- : : "r" (num) : "r0", "r1");
-}
-
-void _catchException0 ();
-
-asm ("
-_catchException0:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #0
- bl process_exception");
-
-void _catchException1 ();
-
-asm ("
-_catchException1:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- bl cleanup_stash
- seth r1, #shigh(stackPtr)
- add3 r1, r1, #low(stackPtr)
- ld r15, @r1 ; setup local stack (protect user stack)
- seth r1, #shigh(registers + 21*4) ; PC
- add3 r1, r1, #low(registers + 21*4)
- ld r0, @r1
- addi r0, #-4 ; back up PC for breakpoint trap.
- st r0, @r1 ; FIXME: what about bp in right slot?
- ldi r0, #1
- bl handle_exception
- bl restore_and_return");
-
-void _catchException2 ();
-
-asm ("
-_catchException2:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #2
- bl process_exception");
-
-void _catchException3 ();
-
-asm ("
-_catchException3:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #3
- bl process_exception");
-
-void _catchException4 ();
-
-asm ("
-_catchException4:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #4
- bl process_exception");
-
-void _catchException5 ();
-
-asm ("
-_catchException5:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #5
- bl process_exception");
-
-void _catchException6 ();
-
-asm ("
-_catchException6:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #6
- bl process_exception");
-
-void _catchException7 ();
-
-asm ("
-_catchException7:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #7
- bl process_exception");
-
-void _catchException8 ();
-
-asm ("
-_catchException8:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #8
- bl process_exception");
-
-void _catchException9 ();
-
-asm ("
-_catchException9:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #9
- bl process_exception");
-
-void _catchException10 ();
-
-asm ("
-_catchException10:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #10
- bl process_exception");
-
-void _catchException11 ();
-
-asm ("
-_catchException11:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #11
- bl process_exception");
-
-void _catchException12 ();
-
-asm ("
-_catchException12:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #12
- bl process_exception");
-
-void _catchException13 ();
-
-asm ("
-_catchException13:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #13
- bl process_exception");
-
-void _catchException14 ();
-
-asm ("
-_catchException14:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #14
- bl process_exception");
-
-void _catchException15 ();
-
-asm ("
-_catchException15:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #15
- bl process_exception");
-
-void _catchException16 ();
-
-asm ("
-_catchException16:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #16
- bl process_exception");
-
-void _catchException17 ();
-
-asm ("
-_catchException17:
- push lr
- bl stash_registers
- ; Note that at this point the pushed value of `lr' has been popped
- ldi r0, #17
- 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
+// 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
Index: m32r-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/m32r-tdep.c,v
retrieving revision 1.13
diff -u -r1.13 m32r-tdep.c
--- m32r-tdep.c 14 Jan 2003 00:49:04 -0000 1.13
+++ m32r-tdep.c 29 Jan 2003 19:10:10 -0000
@@ -1,708 +1,708 @@
-/* Target-dependent code for the Mitsubishi m32r for GDB, the GNU debugger.
-
- Copyright 1996, 1998, 1999, 2000, 2001, 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 "inferior.h"
-#include "target.h"
-#include "value.h"
-#include "bfd.h"
-#include "gdb_string.h"
-#include "gdbcore.h"
-#include "symfile.h"
-#include "regcache.h"
-
-/* Function: m32r_use_struct_convention
- Return nonzero if call_function should allocate stack space for a
- struct return? */
-int
-m32r_use_struct_convention (int gcc_p, struct type *type)
-{
- return (TYPE_LENGTH (type) > 8);
-}
-
-/* Function: frame_find_saved_regs
- Return the frame_saved_regs structure for the frame.
- Doesn't really work for dummy frames, but it does pass back
- an empty frame_saved_regs, so I guess that's better than total failure */
-
-void
-m32r_frame_find_saved_regs (struct frame_info *fi,
- struct frame_saved_regs *regaddr)
-{
- memcpy (regaddr, &fi->fsr, sizeof (struct frame_saved_regs));
-}
-
-/* Turn this on if you want to see just how much instruction decoding
- if being done, its quite a lot
- */
-#if 0
-static void
-dump_insn (char *commnt, CORE_ADDR pc, int insn)
-{
- printf_filtered (" %s %08x %08x ",
- commnt, (unsigned int) pc, (unsigned int) insn);
- TARGET_PRINT_INSN (pc, &tm_print_insn_info);
- printf_filtered ("\n");
-}
-#define insn_debug(args) { printf_filtered args; }
-#else
-#define dump_insn(a,b,c) {}
-#define insn_debug(args) {}
-#endif
-
-#define DEFAULT_SEARCH_LIMIT 44
-
-/* Function: scan_prologue
- This function decodes the target function prologue to determine
- 1) the size of the stack frame, and 2) which registers are saved on it.
- It saves the offsets of saved regs in the frame_saved_regs argument,
- and returns the frame size. */
-
-/*
- The sequence it currently generates is:
-
- if (varargs function) { ddi sp,#n }
- push registers
- if (additional stack <= 256) { addi sp,#-stack }
- else if (additional stack < 65k) { add3 sp,sp,#-stack
-
- } else if (additional stack) {
- seth sp,#(stack & 0xffff0000)
- or3 sp,sp,#(stack & 0x0000ffff)
- sub sp,r4
- }
- if (frame pointer) {
- mv sp,fp
- }
-
- These instructions are scheduled like everything else, so you should stop at
- the first branch instruction.
-
- */
-
-/* This is required by skip prologue and by m32r_init_extra_frame_info.
- The results of decoding a prologue should be cached because this
- thrashing is getting nuts.
- I am thinking of making a container class with two indexes, name and
- address. It may be better to extend the symbol table.
- */
-
-static void
-decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, CORE_ADDR *pl_endptr, /* var parameter */
- unsigned long *framelength, struct frame_info *fi,
- struct frame_saved_regs *fsr)
-{
- 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;
- insn_debug (("rd prolog l(%d)\n", scan_limit - current_pc));
-
- for (current_pc = start_pc; current_pc < scan_limit; current_pc += 2)
- {
-
- insn = read_memory_unsigned_integer (current_pc, 2);
- dump_insn ("insn-1", current_pc, insn); /* MTZ */
-
- /* 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))
- {
- insn_debug (("Really done"));
- break; /* nope, we are really done */
- }
- }
- insn &= 0x7fff; /* decode this instruction further */
- }
- else
- {
- if (maybe_one_more)
- break; /* This isnt the one more */
- if (insn & 0x8000)
- {
- insn_debug (("32 bit insn\n"));
- 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 */
- {
- insn_debug (("stack increment\n"));
- 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 */
- dump_insn ("insn-2", current_pc + 2, insn);
- insn = read_memory_unsigned_integer (current_pc - 2, 4);
- dump_insn ("insn-3(l4)", current_pc - 2, insn);
- 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;
- insn_debug (("push\n"));
-#if 0 /* No, PUSH FP is not an indication that we will use a frame pointer. */
- if (((insn & 0xffff) == 0x2d7f) && fi)
- fi->using_frame_pointer = 1;
-#endif
- framesize += 4;
-#if 0
-/* Why should we increase the scan limit, just because we did a push?
- And if there is a reason, surely we would only want to do it if we
- had already reached the scan limit... */
- if (current_pc == scan_limit)
- scan_limit += 2;
-#endif
- regno = ((insn >> 8) & 0xf);
- if (fsr) /* save_regs offset */
- fsr->regs[regno] = framesize;
- 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 */
- if (fi)
- fi->using_frame_pointer = 1; /* fp is now valid */
- insn_debug (("done fp found\n"));
- after_prologue = current_pc + 2;
- break; /* end of stack adjustments */
- }
- if (insn == 0x7000) /* Nop looks like a branch, continue explicitly */
- {
- insn_debug (("nop\n"));
- 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;
- insn_debug (("Done: branch\n"));
- 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))
- {
- insn_debug (("done: jmp\n"));
- after_prologue = current_pc;
- maybe_one_more = 1;
- continue; /* jmp , jl */
- }
- }
- }
-
- if (current_pc >= scan_limit)
- {
- if (pl_endptr)
- {
-#if 1
- 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;
- if (framelength)
- *framelength = framesize;
- }
- else
-#endif
- /* 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;
-
- insn_debug ((" framesize %d, firstline %08x\n", framesize, after_prologue));
- if (framelength)
- *framelength = framesize;
- if (pl_endptr)
- *pl_endptr = after_prologue;
-} /* decode_prologue */
-
-/* Function: skip_prologue
- Find end of function prologue */
-
-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)
- {
-
- insn_debug (("BP after prologue %08x\n", sal.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. */
- {
- insn_debug (("No line info, line(%x) sal_end(%x) funcend(%x)\n",
- sal.line, sal.end, func_end));
- func_end = min (func_end, func_addr + DEFAULT_SEARCH_LIMIT);
- }
- }
- else
- func_end = pc + DEFAULT_SEARCH_LIMIT;
- decode_prologue (pc, func_end, &sal.end, 0, 0, 0);
- return sal.end;
-}
-
-static unsigned long
-m32r_scan_prologue (struct frame_info *fi, struct frame_saved_regs *fsr)
-{
- struct symtab_and_line sal;
- CORE_ADDR prologue_start, prologue_end, current_pc;
- unsigned long framesize = 0;
-
- /* this code essentially duplicates skip_prologue,
- but we need the start address below. */
-
- if (find_pc_partial_function (fi->pc, NULL, &prologue_start, &prologue_end))
- {
- sal = find_pc_line (prologue_start, 0);
-
- if (sal.line == 0) /* no line info, use current PC */
- if (prologue_start == entry_point_address ())
- return 0;
- }
- else
- {
- prologue_start = fi->pc;
- prologue_end = prologue_start + 48; /* We're in the boondocks:
- allow for 16 pushes, an add,
- and "mv fp,sp" */
- }
-#if 0
- prologue_end = min (prologue_end, fi->pc);
-#endif
- insn_debug (("fipc(%08x) start(%08x) end(%08x)\n",
- fi->pc, prologue_start, prologue_end));
- prologue_end = min (prologue_end, prologue_start + DEFAULT_SEARCH_LIMIT);
- decode_prologue (prologue_start, prologue_end, &prologue_end, &framesize,
- fi, fsr);
- return framesize;
-}
-
-/* Function: init_extra_frame_info
- This function actually figures out the frame address for a given pc and
- sp. This is tricky on the m32r because we sometimes don't use an explicit
- frame pointer, and the previous stack pointer isn't necessarily recorded
- on the stack. The only reliable way to get this info is to
- examine the prologue. */
-
-void
-m32r_init_extra_frame_info (struct frame_info *fi)
-{
- int reg;
-
- if (fi->next)
- fi->pc = FRAME_SAVED_PC (fi->next);
-
- memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs);
-
- if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
- {
- /* We need to setup fi->frame here because run_stack_dummy gets it wrong
- by assuming it's always FP. */
- fi->frame = deprecated_read_register_dummy (fi->pc, fi->frame,
- SP_REGNUM);
- fi->framesize = 0;
- return;
- }
- else
- {
- fi->using_frame_pointer = 0;
- fi->framesize = m32r_scan_prologue (fi, &fi->fsr);
-
- if (!fi->next)
- if (fi->using_frame_pointer)
- {
- fi->frame = read_register (FP_REGNUM);
- }
- else
- fi->frame = read_register (SP_REGNUM);
- else
- /* fi->next means this is not the innermost frame */ if (fi->using_frame_pointer)
- /* we have an FP */
- if (fi->next->fsr.regs[FP_REGNUM] != 0) /* caller saved our FP */
- fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4);
- for (reg = 0; reg < NUM_REGS; reg++)
- if (fi->fsr.regs[reg] != 0)
- fi->fsr.regs[reg] = fi->frame + fi->framesize - fi->fsr.regs[reg];
- }
-}
-
-/* Function: m32r_virtual_frame_pointer
- Return the register that the function uses for a frame pointer,
- plus any necessary offset to be applied to the register before
- any frame pointer offsets. */
-
-void
-m32r_virtual_frame_pointer (CORE_ADDR pc, long *reg, long *offset)
-{
- struct frame_info *fi = deprecated_frame_xmalloc ();
- struct cleanup *old_chain = make_cleanup (xfree, fi);
-
- /* Set up a dummy frame_info. */
- fi->next = NULL;
- fi->prev = NULL;
- fi->frame = 0;
- fi->pc = pc;
-
- /* Analyze the prolog and fill in the extra info. */
- m32r_init_extra_frame_info (fi);
-
- /* Results will tell us which type of frame it uses. */
- if (fi->using_frame_pointer)
- {
- *reg = FP_REGNUM;
- *offset = 0;
- }
- else
- {
- *reg = SP_REGNUM;
- *offset = 0;
- }
- do_cleanups (old_chain);
-}
-
-/* Function: find_callers_reg
- Find REGNUM on the stack. Otherwise, it's in an active register. One thing
- we might want to do here is to check REGNUM against the clobber mask, and
- somehow flag it as invalid if it isn't saved on the stack somewhere. This
- would provide a graceful failure mode when trying to get the value of
- caller-saves registers for an inner frame. */
-
-CORE_ADDR
-m32r_find_callers_reg (struct frame_info *fi, int regnum)
-{
- for (; fi; fi = fi->next)
- if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
- return deprecated_read_register_dummy (fi->pc, fi->frame, regnum);
- else if (fi->fsr.regs[regnum] != 0)
- return read_memory_integer (fi->fsr.regs[regnum],
- REGISTER_RAW_SIZE (regnum));
- return read_register (regnum);
-}
-
-/* Function: frame_chain Given a GDB frame, determine the address of
- the calling function's frame. This will be used to create a new
- GDB frame struct, and then INIT_EXTRA_FRAME_INFO and
- DEPRECATED_INIT_FRAME_PC will be called for the new frame. For
- m32r, we save the frame size when we initialize the frame_info. */
-
-CORE_ADDR
-m32r_frame_chain (struct frame_info *fi)
-{
- CORE_ADDR fn_start, callers_pc, fp;
-
- /* is this a dummy frame? */
- if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
- return fi->frame; /* dummy frame same as caller's frame */
-
- /* is caller-of-this a dummy frame? */
- callers_pc = FRAME_SAVED_PC (fi); /* find out who called us: */
- fp = m32r_find_callers_reg (fi, FP_REGNUM);
- if (DEPRECATED_PC_IN_CALL_DUMMY (callers_pc, fp, fp))
- return fp; /* dummy frame's frame may bear no relation to ours */
-
- if (find_pc_partial_function (fi->pc, 0, &fn_start, 0))
- if (fn_start == entry_point_address ())
- return 0; /* in _start fn, don't chain further */
- if (fi->framesize == 0)
- {
- printf_filtered ("cannot determine frame size @ %s , pc(%s)\n",
- paddr (fi->frame),
- paddr (fi->pc));
- return 0;
- }
- insn_debug (("m32rx frame %08x\n", fi->frame + fi->framesize));
- return fi->frame + fi->framesize;
-}
-
-/* Function: push_return_address (pc)
- Set up the return address for the inferior function call.
- Necessary for targets that don't actually execute a JSR/BSR instruction
- (ie. when using an empty CALL_DUMMY) */
-
-CORE_ADDR
-m32r_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
-{
- write_register (RP_REGNUM, CALL_DUMMY_ADDRESS ());
- return sp;
-}
-
-
-/* Function: pop_frame
- Discard from the stack the innermost frame,
- restoring all saved registers. */
-
-struct frame_info *
-m32r_pop_frame (struct frame_info *frame)
-{
- int regnum;
-
- if (DEPRECATED_PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
- generic_pop_dummy_frame ();
- else
- {
- for (regnum = 0; regnum < NUM_REGS; regnum++)
- if (frame->fsr.regs[regnum] != 0)
- write_register (regnum,
- read_memory_integer (frame->fsr.regs[regnum], 4));
-
- write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
- write_register (SP_REGNUM, read_register (FP_REGNUM));
- if (read_register (PSW_REGNUM) & 0x80)
- write_register (SPU_REGNUM, read_register (SP_REGNUM));
- else
- write_register (SPI_REGNUM, read_register (SP_REGNUM));
- }
- flush_cached_frames ();
- return NULL;
-}
-
-/* Function: frame_saved_pc
- Find the caller of this frame. We do this by seeing if RP_REGNUM is saved
- in the stack anywhere, otherwise we get it from the registers. */
-
-CORE_ADDR
-m32r_frame_saved_pc (struct frame_info *fi)
-{
- if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
- return deprecated_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
- else
- return m32r_find_callers_reg (fi, RP_REGNUM);
-}
-
-/* Function: push_arguments
- Setup the function arguments for calling a function in the inferior.
-
- On the Mitsubishi M32R architecture, there are four registers (R0 to R3)
- which are dedicated for passing function arguments. Up to the first
- four arguments (depending on size) may go into these registers.
- The rest go on the stack.
-
- Arguments that are smaller than 4 bytes will still take up a whole
- register or a whole 32-bit word on the stack, and will be
- right-justified in the register or the stack word. This includes
- chars, shorts, and small aggregate types.
-
- Arguments of 8 bytes size are split between two registers, if
- available. If only one register is available, the argument will
- be split between the register and the stack. Otherwise it is
- passed entirely on the stack. Aggregate types with sizes between
- 4 and 8 bytes are passed entirely on the stack, and are left-justified
- within the double-word (as opposed to aggregates smaller than 4 bytes
- which are right-justified).
-
- Aggregates of greater than 8 bytes are first copied onto the stack,
- and then a pointer to the copy is passed in the place of the normal
- argument (either in a register if available, or on the stack).
-
- Functions that must return an aggregate type can return it in the
- normal return value registers (R0 and R1) if its size is 8 bytes or
- less. For larger return values, the caller must allocate space for
- the callee to copy the return value to. A pointer to this space is
- passed as an implicit first argument, always in R0. */
-
-CORE_ADDR
-m32r_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
- unsigned char struct_return, CORE_ADDR struct_addr)
-{
- int stack_offset, stack_alloc;
- int argreg;
- int argnum;
- struct type *type;
- CORE_ADDR regval;
- char *val;
- char valbuf[4];
- int len;
- int odd_sized_struct;
-
- /* first force sp to a 4-byte alignment */
- sp = sp & ~3;
-
- argreg = ARG0_REGNUM;
- /* The "struct return pointer" pseudo-argument goes in R0 */
- if (struct_return)
- write_register (argreg++, struct_addr);
-
- /* 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 */
-
-
- /* Now load as many as possible of the first arguments into
- registers, and push the rest onto the stack. There are 16 bytes
- in four registers available. Loop thru args from first to last. */
-
- argreg = ARG0_REGNUM;
- for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
- {
- type = VALUE_TYPE (args[argnum]);
- len = TYPE_LENGTH (type);
- memset (valbuf, 0, sizeof (valbuf));
- if (len < 4)
- { /* value gets right-justified in the register or stack word */
- memcpy (valbuf + (4 - len),
- (char *) VALUE_CONTENTS (args[argnum]), len);
- val = valbuf;
- }
- else
- val = (char *) VALUE_CONTENTS (args[argnum]);
-
- if (len > 4 && (len & 3) != 0)
- odd_sized_struct = 1; /* such structs go entirely on stack */
- else
- odd_sized_struct = 0;
- while (len > 0)
- {
- if (argreg > ARGLAST_REGNUM || odd_sized_struct)
- { /* must go on the stack */
- write_memory (sp + stack_offset, val, 4);
- stack_offset += 4;
- }
- /* NOTE WELL!!!!! This is not an "else if" clause!!!
- That's because some *&^%$ things get passed on the stack
- AND in the registers! */
- if (argreg <= ARGLAST_REGNUM)
- { /* there's room in a register */
- regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
- write_register (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);
- }
- }
- return sp;
-}
-
-/* Function: fix_call_dummy
- If there is real CALL_DUMMY code (eg. on the stack), this function
- has the responsability to insert the address of the actual code that
- is the target of the target function call. */
-
-void
-m32r_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
- struct value **args, struct type *type, int gcc_p)
-{
- /* ld24 r8, <(imm24) fun> */
- *(unsigned long *) (dummy) = (fun & 0x00ffffff) | 0xe8000000;
-}
-
-
-/* Function: m32r_write_sp
- Because SP is really a read-only register that mirrors either SPU or SPI,
- we must actually write one of those two as well, depending on PSW. */
-
-void
-m32r_write_sp (CORE_ADDR val)
-{
- unsigned long psw = read_register (PSW_REGNUM);
-
- if (psw & 0x80) /* stack mode: user or interrupt */
- write_register (SPU_REGNUM, val);
- else
- write_register (SPI_REGNUM, val);
- write_register (SP_REGNUM, val);
-}
-
-void
-_initialize_m32r_tdep (void)
-{
- tm_print_insn = print_insn_m32r;
-}
+// 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 }
Index: monitor.c
===================================================================
RCS file: /cvs/src/src/gdb/monitor.c,v
retrieving revision 1.36
diff -u -r1.36 monitor.c
--- monitor.c 12 Nov 2002 21:43:55 -0000 1.36
+++ monitor.c 29 Jan 2003 19:10:12 -0000
@@ -569,12 +569,14 @@
return 0;
}
}
- else if ((c == '\021' || c == '\023') &&
- (STREQ (targ_ops->to_shortname, "m32r")
- || STREQ (targ_ops->to_shortname, "mon2000")))
- { /* m32r monitor emits random DC1/DC3 chars */
- continue;
- }
+#if 0
+ // OBSOLETE else if ((c == '\021' || c == '\023') &&
+ // OBSOLETE (STREQ (targ_ops->to_shortname, "m32r")
+ // OBSOLETE || STREQ (targ_ops->to_shortname, "mon2000")))
+ // OBSOLETE { /* m32r monitor emits random DC1/DC3 chars */
+ // OBSOLETE continue;
+ // OBSOLETE }
+#endif
else
{
/* We got a character that doesn't match the string. We need to
Index: config/m32r/m32r.mt
===================================================================
RCS file: /cvs/src/src/gdb/config/m32r/m32r.mt,v
retrieving revision 1.4
diff -u -r1.4 m32r.mt
--- config/m32r/m32r.mt 4 May 2002 15:52:39 -0000 1.4
+++ config/m32r/m32r.mt 29 Jan 2003 19:10:12 -0000
@@ -1,5 +1,5 @@
-# Target: Mitsubishi m32r processor
-TDEPFILES= m32r-tdep.o monitor.o m32r-rom.o dsrec.o
-TM_FILE= tm-m32r.h
-SIM_OBS = remote-sim.o
-SIM = ../sim/m32r/libsim.a
+# OBSOLETE # Target: Mitsubishi m32r processor
+# OBSOLETE TDEPFILES= m32r-tdep.o monitor.o m32r-rom.o dsrec.o
+# OBSOLETE TM_FILE= tm-m32r.h
+# OBSOLETE SIM_OBS = remote-sim.o
+# OBSOLETE SIM = ../sim/m32r/libsim.a
Index: config/m32r/tm-m32r.h
===================================================================
RCS file: /cvs/src/src/gdb/config/m32r/tm-m32r.h,v
retrieving revision 1.15
diff -u -r1.15 tm-m32r.h
--- config/m32r/tm-m32r.h 5 Jan 2003 01:39:55 -0000 1.15
+++ config/m32r/tm-m32r.h 29 Jan 2003 19:10:12 -0000
@@ -1,231 +1,231 @@
-/* Parameters for execution on a Mitsubishi m32r processor.
- Copyright 1996, 1997, 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 "regcache.h"
-
-/* Used by mswin. */
-#define TARGET_M32R 1
-
-/* mvs_check REGISTER_NAMES */
-#define 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", \
- /* "cond", "sm", "bsm", "ie", "bie", "bcarry", */ \
-}
-/* mvs_check NUM_REGS */
-#define NUM_REGS 24
-
-/* mvs_check REGISTER_SIZE */
-#define REGISTER_SIZE 4
-/* mvs_check MAX_REGISTER_RAW_SIZE */
-#define MAX_REGISTER_RAW_SIZE 4
-
-/* mvs_check *_REGNUM */
-#define R0_REGNUM 0
-#define STRUCT_RETURN_REGNUM 0
-#define ARG0_REGNUM 0
-#define ARGLAST_REGNUM 3
-#define V0_REGNUM 0
-#define V1_REGNUM 1
-#define FP_REGNUM 13
-#define RP_REGNUM 14
-#define SP_REGNUM 15
-#define PSW_REGNUM 16
-#define CBR_REGNUM 17
-#define SPI_REGNUM 18
-#define SPU_REGNUM 19
-#define BPC_REGNUM 20
-#define PC_REGNUM 21
-#define ACCL_REGNUM 22
-#define ACCH_REGNUM 23
-
-/* mvs_check REGISTER_BYTES */
-#define REGISTER_BYTES (NUM_REGS * 4)
-
-/* mvs_check REGISTER_VIRTUAL_TYPE */
-#define REGISTER_VIRTUAL_TYPE(REG) builtin_type_int
-
-/* mvs_check REGISTER_BYTE */
-#define REGISTER_BYTE(REG) ((REG) * 4)
-/* mvs_check REGISTER_VIRTUAL_SIZE */
-#define REGISTER_VIRTUAL_SIZE(REG) 4
-/* mvs_check REGISTER_RAW_SIZE */
-#define REGISTER_RAW_SIZE(REG) 4
-
-/* mvs_check MAX_REGISTER_VIRTUAL_SIZE */
-#define MAX_REGISTER_VIRTUAL_SIZE 4
-
-/* mvs_check BREAKPOINT */
-#define BREAKPOINT {0x10, 0xf1}
-
-/* mvs_no_check FUNCTION_START_OFFSET */
-#define FUNCTION_START_OFFSET 0
-
-/* mvs_check DECR_PC_AFTER_BREAK */
-#define DECR_PC_AFTER_BREAK 0
-
-/* mvs_check INNER_THAN */
-#define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
-
-/* mvs_check SAVED_PC_AFTER_CALL */
-#define SAVED_PC_AFTER_CALL(fi) read_register (RP_REGNUM)
-
-struct frame_info;
-struct frame_saved_regs;
-struct type;
-struct value;
-
-/* Define other aspects of the stack frame.
- We keep the offsets of all saved registers, 'cause we need 'em a lot!
- We also keep the current size of the stack frame, and whether
- the frame pointer is valid (for frameless functions, and when we're
- still in the prologue of a function with a frame) */
-
-/* mvs_check EXTRA_FRAME_INFO */
-#define EXTRA_FRAME_INFO \
- struct frame_saved_regs fsr; \
- int framesize; \
- int using_frame_pointer;
-
-
-extern void m32r_init_extra_frame_info (struct frame_info *fi);
-/* mvs_check INIT_EXTRA_FRAME_INFO */
-#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) m32r_init_extra_frame_info (fi)
-/* mvs_no_check DEPRECATED_INIT_FRAME_PC */
-#define DEPRECATED_INIT_FRAME_PC init_frame_pc_noop
-
-extern void
-m32r_frame_find_saved_regs (struct frame_info *fi,
- struct frame_saved_regs *regaddr);
-
-/* Put here the code to store, into a struct frame_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. */
-
-/* mvs_check FRAME_FIND_SAVED_REGS */
-#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
- m32r_frame_find_saved_regs(frame_info, &(frame_saved_regs))
-
-extern CORE_ADDR m32r_frame_chain (struct frame_info *fi);
-/* mvs_check FRAME_CHAIN */
-#define FRAME_CHAIN(fi) m32r_frame_chain (fi)
-
-extern CORE_ADDR m32r_find_callers_reg (struct frame_info *fi, int regnum);
-extern CORE_ADDR m32r_frame_saved_pc (struct frame_info *);
-/* mvs_check FRAME_SAVED_PC */
-#define FRAME_SAVED_PC(fi) m32r_frame_saved_pc (fi)
-
-/* mvs_check DEPRECATED_EXTRACT_RETURN_VALUE */
-#define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE, REGBUF, VALBUF) \
- memcpy ((VALBUF), \
- (char *)(REGBUF) + REGISTER_BYTE (V0_REGNUM) + \
- ((TYPE_LENGTH (TYPE) > 4 ? 8 : 4) - TYPE_LENGTH (TYPE)), \
- TYPE_LENGTH (TYPE))
-
-/* mvs_check DEPRECATED_STORE_RETURN_VALUE */
-#define DEPRECATED_STORE_RETURN_VALUE(TYPE, VALBUF) \
- deprecated_write_register_bytes(REGISTER_BYTE (V0_REGNUM) + \
- ((TYPE_LENGTH (TYPE) > 4 ? 8:4) - TYPE_LENGTH (TYPE)),\
- (VALBUF), TYPE_LENGTH (TYPE));
-
-extern CORE_ADDR m32r_skip_prologue (CORE_ADDR pc);
-/* mvs_check SKIP_PROLOGUE */
-#define SKIP_PROLOGUE(pc) (m32r_skip_prologue (pc))
-
-/* mvs_no_check FRAME_ARGS_SKIP */
-#define FRAME_ARGS_SKIP 0
-
-/* mvs_no_check FRAME_ARGS_ADDRESS */
-#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)
-/* mvs_no_check FRAME_LOCALS_ADDRESS */
-#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
-/* mvs_no_check FRAME_NUM_ARGS */
-#define FRAME_NUM_ARGS(fi) (-1)
-
-extern void m32r_write_sp (CORE_ADDR val);
-#define TARGET_WRITE_SP m32r_write_sp
-
-
-
-
-
-
-/* struct passing and returning stuff */
-#define STORE_STRUCT_RETURN(STRUCT_ADDR, SP) \
- write_register (0, STRUCT_ADDR)
-
-extern use_struct_convention_fn m32r_use_struct_convention;
-#define USE_STRUCT_CONVENTION(GCC_P, TYPE) m32r_use_struct_convention (GCC_P, TYPE)
-
-#define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
- extract_address (REGBUF + REGISTER_BYTE (V0_REGNUM), \
- REGISTER_RAW_SIZE (V0_REGNUM))
-
-#define REG_STRUCT_HAS_ADDR(gcc_p,type) (TYPE_LENGTH (type) > 8)
-
-
-/* generic dummy frame stuff */
-
-#define PUSH_DUMMY_FRAME generic_push_dummy_frame ()
-#define DEPRECATED_PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
-
-
-/* target-specific dummy_frame stuff */
-
-extern struct frame_info *m32r_pop_frame (struct frame_info *frame);
-/* mvs_check POP_FRAME */
-#define POP_FRAME m32r_pop_frame (get_current_frame ())
-
-/* mvs_no_check STACK_ALIGN */
-/* #define STACK_ALIGN(x) ((x + 3) & ~3) */
-
-extern CORE_ADDR m32r_push_return_address (CORE_ADDR, CORE_ADDR);
-extern CORE_ADDR m32r_push_arguments (int nargs,
- struct value **args,
- CORE_ADDR sp,
- unsigned char struct_return,
- CORE_ADDR struct_addr);
-
-
-
-/* mvs_no_check PUSH_ARGUMENTS */
-#define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) \
- (m32r_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR))
-
-#define PUSH_RETURN_ADDRESS(PC, SP) m32r_push_return_address (PC, SP)
-
-/* override the standard get_saved_register function with
- one that takes account of generic CALL_DUMMY frames */
-#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
- deprecated_generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
-
-
-#define DEPRECATED_USE_GENERIC_DUMMY_FRAMES 1
-#define CALL_DUMMY {0}
-#define CALL_DUMMY_LENGTH (0)
-#define CALL_DUMMY_START_OFFSET (0)
-#define CALL_DUMMY_BREAKPOINT_OFFSET (0)
-#define FIX_CALL_DUMMY(DUMMY1, STARTADDR, FUNADDR, NARGS, ARGS, TYPE, GCCP)
-#define CALL_DUMMY_LOCATION AT_ENTRY_POINT
-#define CALL_DUMMY_ADDRESS() entry_point_address ()
+// OBSOLETE /* Parameters for execution on a Mitsubishi m32r processor.
+// OBSOLETE Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+// OBSOLETE Free Software 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 "regcache.h"
+// OBSOLETE
+// OBSOLETE /* Used by mswin. */
+// OBSOLETE #define TARGET_M32R 1
+// OBSOLETE
+// OBSOLETE /* mvs_check REGISTER_NAMES */
+// OBSOLETE #define REGISTER_NAMES \
+// OBSOLETE { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
+// OBSOLETE "r8", "r9", "r10", "r11", "r12", "fp", "lr", "sp", \
+// OBSOLETE "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch", \
+// OBSOLETE /* "cond", "sm", "bsm", "ie", "bie", "bcarry", */ \
+// OBSOLETE }
+// OBSOLETE /* mvs_check NUM_REGS */
+// OBSOLETE #define NUM_REGS 24
+// OBSOLETE
+// OBSOLETE /* mvs_check REGISTER_SIZE */
+// OBSOLETE #define REGISTER_SIZE 4
+// OBSOLETE /* mvs_check MAX_REGISTER_RAW_SIZE */
+// OBSOLETE #define MAX_REGISTER_RAW_SIZE 4
+// OBSOLETE
+// OBSOLETE /* mvs_check *_REGNUM */
+// OBSOLETE #define R0_REGNUM 0
+// OBSOLETE #define STRUCT_RETURN_REGNUM 0
+// OBSOLETE #define ARG0_REGNUM 0
+// OBSOLETE #define ARGLAST_REGNUM 3
+// OBSOLETE #define V0_REGNUM 0
+// OBSOLETE #define V1_REGNUM 1
+// OBSOLETE #define FP_REGNUM 13
+// OBSOLETE #define RP_REGNUM 14
+// OBSOLETE #define SP_REGNUM 15
+// OBSOLETE #define PSW_REGNUM 16
+// OBSOLETE #define CBR_REGNUM 17
+// OBSOLETE #define SPI_REGNUM 18
+// OBSOLETE #define SPU_REGNUM 19
+// OBSOLETE #define BPC_REGNUM 20
+// OBSOLETE #define PC_REGNUM 21
+// OBSOLETE #define ACCL_REGNUM 22
+// OBSOLETE #define ACCH_REGNUM 23
+// OBSOLETE
+// OBSOLETE /* mvs_check REGISTER_BYTES */
+// OBSOLETE #define REGISTER_BYTES (NUM_REGS * 4)
+// OBSOLETE
+// OBSOLETE /* mvs_check REGISTER_VIRTUAL_TYPE */
+// OBSOLETE #define REGISTER_VIRTUAL_TYPE(REG) builtin_type_int
+// OBSOLETE
+// OBSOLETE /* mvs_check REGISTER_BYTE */
+// OBSOLETE #define REGISTER_BYTE(REG) ((REG) * 4)
+// OBSOLETE /* mvs_check REGISTER_VIRTUAL_SIZE */
+// OBSOLETE #define REGISTER_VIRTUAL_SIZE(REG) 4
+// OBSOLETE /* mvs_check REGISTER_RAW_SIZE */
+// OBSOLETE #define REGISTER_RAW_SIZE(REG) 4
+// OBSOLETE
+// OBSOLETE /* mvs_check MAX_REGISTER_VIRTUAL_SIZE */
+// OBSOLETE #define MAX_REGISTER_VIRTUAL_SIZE 4
+// OBSOLETE
+// OBSOLETE /* mvs_check BREAKPOINT */
+// OBSOLETE #define BREAKPOINT {0x10, 0xf1}
+// OBSOLETE
+// OBSOLETE /* mvs_no_check FUNCTION_START_OFFSET */
+// OBSOLETE #define FUNCTION_START_OFFSET 0
+// OBSOLETE
+// OBSOLETE /* mvs_check DECR_PC_AFTER_BREAK */
+// OBSOLETE #define DECR_PC_AFTER_BREAK 0
+// OBSOLETE
+// OBSOLETE /* mvs_check INNER_THAN */
+// OBSOLETE #define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
+// OBSOLETE
+// OBSOLETE /* mvs_check SAVED_PC_AFTER_CALL */
+// OBSOLETE #define SAVED_PC_AFTER_CALL(fi) read_register (RP_REGNUM)
+// OBSOLETE
+// OBSOLETE struct frame_info;
+// OBSOLETE struct frame_saved_regs;
+// OBSOLETE struct type;
+// OBSOLETE struct value;
+// OBSOLETE
+// OBSOLETE /* Define other aspects of the stack frame.
+// OBSOLETE We keep the offsets of all saved registers, 'cause we need 'em a lot!
+// OBSOLETE We also keep the current size of the stack frame, and whether
+// OBSOLETE the frame pointer is valid (for frameless functions, and when we're
+// OBSOLETE still in the prologue of a function with a frame) */
+// OBSOLETE
+// OBSOLETE /* mvs_check EXTRA_FRAME_INFO */
+// OBSOLETE #define EXTRA_FRAME_INFO \
+// OBSOLETE struct frame_saved_regs fsr; \
+// OBSOLETE int framesize; \
+// OBSOLETE int using_frame_pointer;
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE extern void m32r_init_extra_frame_info (struct frame_info *fi);
+// OBSOLETE /* mvs_check INIT_EXTRA_FRAME_INFO */
+// OBSOLETE #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) m32r_init_extra_frame_info (fi)
+// OBSOLETE /* mvs_no_check DEPRECATED_INIT_FRAME_PC */
+// OBSOLETE #define DEPRECATED_INIT_FRAME_PC init_frame_pc_noop
+// OBSOLETE
+// OBSOLETE extern void
+// OBSOLETE m32r_frame_find_saved_regs (struct frame_info *fi,
+// OBSOLETE struct frame_saved_regs *regaddr);
+// OBSOLETE
+// OBSOLETE /* Put here the code to store, into a struct frame_saved_regs,
+// OBSOLETE the addresses of the saved registers of frame described by FRAME_INFO.
+// OBSOLETE This includes special registers such as pc and fp saved in special
+// OBSOLETE ways in the stack frame. sp is even more special:
+// OBSOLETE the address we return for it IS the sp for the next frame. */
+// OBSOLETE
+// OBSOLETE /* mvs_check FRAME_FIND_SAVED_REGS */
+// OBSOLETE #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
+// OBSOLETE m32r_frame_find_saved_regs(frame_info, &(frame_saved_regs))
+// OBSOLETE
+// OBSOLETE extern CORE_ADDR m32r_frame_chain (struct frame_info *fi);
+// OBSOLETE /* mvs_check FRAME_CHAIN */
+// OBSOLETE #define FRAME_CHAIN(fi) m32r_frame_chain (fi)
+// OBSOLETE
+// OBSOLETE extern CORE_ADDR m32r_find_callers_reg (struct frame_info *fi, int regnum);
+// OBSOLETE extern CORE_ADDR m32r_frame_saved_pc (struct frame_info *);
+// OBSOLETE /* mvs_check FRAME_SAVED_PC */
+// OBSOLETE #define FRAME_SAVED_PC(fi) m32r_frame_saved_pc (fi)
+// OBSOLETE
+// OBSOLETE /* mvs_check DEPRECATED_EXTRACT_RETURN_VALUE */
+// OBSOLETE #define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE, REGBUF, VALBUF) \
+// OBSOLETE memcpy ((VALBUF), \
+// OBSOLETE (char *)(REGBUF) + REGISTER_BYTE (V0_REGNUM) + \
+// OBSOLETE ((TYPE_LENGTH (TYPE) > 4 ? 8 : 4) - TYPE_LENGTH (TYPE)), \
+// OBSOLETE TYPE_LENGTH (TYPE))
+// OBSOLETE
+// OBSOLETE /* mvs_check DEPRECATED_STORE_RETURN_VALUE */
+// OBSOLETE #define DEPRECATED_STORE_RETURN_VALUE(TYPE, VALBUF) \
+// OBSOLETE deprecated_write_register_bytes(REGISTER_BYTE (V0_REGNUM) + \
+// OBSOLETE ((TYPE_LENGTH (TYPE) > 4 ? 8:4) - TYPE_LENGTH (TYPE)),\
+// OBSOLETE (VALBUF), TYPE_LENGTH (TYPE));
+// OBSOLETE
+// OBSOLETE extern CORE_ADDR m32r_skip_prologue (CORE_ADDR pc);
+// OBSOLETE /* mvs_check SKIP_PROLOGUE */
+// OBSOLETE #define SKIP_PROLOGUE(pc) (m32r_skip_prologue (pc))
+// OBSOLETE
+// OBSOLETE /* mvs_no_check FRAME_ARGS_SKIP */
+// OBSOLETE #define FRAME_ARGS_SKIP 0
+// OBSOLETE
+// OBSOLETE /* mvs_no_check FRAME_ARGS_ADDRESS */
+// OBSOLETE #define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)
+// OBSOLETE /* mvs_no_check FRAME_LOCALS_ADDRESS */
+// OBSOLETE #define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
+// OBSOLETE /* mvs_no_check FRAME_NUM_ARGS */
+// OBSOLETE #define FRAME_NUM_ARGS(fi) (-1)
+// OBSOLETE
+// OBSOLETE extern void m32r_write_sp (CORE_ADDR val);
+// OBSOLETE #define TARGET_WRITE_SP m32r_write_sp
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE /* struct passing and returning stuff */
+// OBSOLETE #define STORE_STRUCT_RETURN(STRUCT_ADDR, SP) \
+// OBSOLETE write_register (0, STRUCT_ADDR)
+// OBSOLETE
+// OBSOLETE extern use_struct_convention_fn m32r_use_struct_convention;
+// OBSOLETE #define USE_STRUCT_CONVENTION(GCC_P, TYPE) m32r_use_struct_convention (GCC_P, TYPE)
+// OBSOLETE
+// OBSOLETE #define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
+// OBSOLETE extract_address (REGBUF + REGISTER_BYTE (V0_REGNUM), \
+// OBSOLETE REGISTER_RAW_SIZE (V0_REGNUM))
+// OBSOLETE
+// OBSOLETE #define REG_STRUCT_HAS_ADDR(gcc_p,type) (TYPE_LENGTH (type) > 8)
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE /* generic dummy frame stuff */
+// OBSOLETE
+// OBSOLETE #define PUSH_DUMMY_FRAME generic_push_dummy_frame ()
+// OBSOLETE #define DEPRECATED_PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE /* target-specific dummy_frame stuff */
+// OBSOLETE
+// OBSOLETE extern struct frame_info *m32r_pop_frame (struct frame_info *frame);
+// OBSOLETE /* mvs_check POP_FRAME */
+// OBSOLETE #define POP_FRAME m32r_pop_frame (get_current_frame ())
+// OBSOLETE
+// OBSOLETE /* mvs_no_check STACK_ALIGN */
+// OBSOLETE /* #define STACK_ALIGN(x) ((x + 3) & ~3) */
+// OBSOLETE
+// OBSOLETE extern CORE_ADDR m32r_push_return_address (CORE_ADDR, CORE_ADDR);
+// OBSOLETE extern CORE_ADDR m32r_push_arguments (int nargs,
+// OBSOLETE struct value **args,
+// OBSOLETE CORE_ADDR sp,
+// OBSOLETE unsigned char struct_return,
+// OBSOLETE CORE_ADDR struct_addr);
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE /* mvs_no_check PUSH_ARGUMENTS */
+// OBSOLETE #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) \
+// OBSOLETE (m32r_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR))
+// OBSOLETE
+// OBSOLETE #define PUSH_RETURN_ADDRESS(PC, SP) m32r_push_return_address (PC, SP)
+// OBSOLETE
+// OBSOLETE /* override the standard get_saved_register function with
+// OBSOLETE one that takes account of generic CALL_DUMMY frames */
+// OBSOLETE #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+// OBSOLETE deprecated_generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE #define DEPRECATED_USE_GENERIC_DUMMY_FRAMES 1
+// OBSOLETE #define CALL_DUMMY {0}
+// OBSOLETE #define CALL_DUMMY_LENGTH (0)
+// OBSOLETE #define CALL_DUMMY_START_OFFSET (0)
+// OBSOLETE #define CALL_DUMMY_BREAKPOINT_OFFSET (0)
+// OBSOLETE #define FIX_CALL_DUMMY(DUMMY1, STARTADDR, FUNADDR, NARGS, ARGS, TYPE, GCCP)
+// OBSOLETE #define CALL_DUMMY_LOCATION AT_ENTRY_POINT
+// OBSOLETE #define CALL_DUMMY_ADDRESS() entry_point_address ()
^ permalink raw reply [flat|nested] 5+ messages in thread* Re: [patch/rfc] Eliminate the es1800 target
2003-01-29 20:32 [patch/rfc] Eliminate the es1800 target Andrew Cagney
@ 2003-01-29 20:37 ` Daniel Jacobowitz
2003-01-29 20:54 ` Andrew Cagney
0 siblings, 1 reply; 5+ messages in thread
From: Daniel Jacobowitz @ 2003-01-29 20:37 UTC (permalink / raw)
To: gdb-patches
On Wed, Jan 29, 2003 at 03:32:23PM -0500, Andrew Cagney wrote:
> Hello,
>
> This code/target pre-dates the old Cygnus CVS repository (~89). Given
> that I really don't believe that one of these beasties still exists, I'm
> thinking of just removing it. (I tried and it doesn't compile).
>
> Anyone object?
> Andrew
[wrong patch] but I certainly don't object; let's kill it!
--
Daniel Jacobowitz
MontaVista Software Debian GNU/Linux Developer
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [patch/rfc] Eliminate the es1800 target
2003-01-29 20:37 ` Daniel Jacobowitz
@ 2003-01-29 20:54 ` Andrew Cagney
2003-01-30 7:56 ` Eli Zaretskii
2003-01-31 16:32 ` Andrew Cagney
0 siblings, 2 replies; 5+ messages in thread
From: Andrew Cagney @ 2003-01-29 20:54 UTC (permalink / raw)
To: Daniel Jacobowitz; +Cc: gdb-patches
[-- Attachment #1: Type: text/plain, Size: 458 bytes --]
> On Wed, Jan 29, 2003 at 03:32:23PM -0500, Andrew Cagney wrote:
>
>> Hello,
>>
>> This code/target pre-dates the old Cygnus CVS repository (~89). Given
>> that I really don't believe that one of these beasties still exists, I'm
>> thinking of just removing it. (I tried and it doesn't compile).
>>
>> Anyone object?
>> Andrew
>
>
> [wrong patch] but I certainly don't object; let's kill it!
Grumph, the thing escaped. Lets try again ...
Andrew
[-- Attachment #2: diffs --]
[-- Type: text/plain, Size: 54458 bytes --]
2003-01-29 Andrew Cagney <ac131313@redhat.com>
* README: Remove reference to Ericsson 1800 monitor.
* Makefile.in (remote-es.o): Delete rule.
(ALLDEPFILES): Delete remote-es.c.
* remote-es.c: Delete file.
* config/m68k/es1800.mt: Delete file.
* config/djgpp/fnchange.lst: Update.
* configure.tgt: Delete m68*-ericsson-* target.
Index: doc/ChangeLog
2003-01-29 Andrew Cagney <ac131313@redhat.com>
* gdb.texinfo (M68K): Delete reference to es1800.
Index: Makefile.in
===================================================================
RCS file: /cvs/src/src/gdb/Makefile.in,v
retrieving revision 1.319
diff -u -r1.319 Makefile.in
--- Makefile.in 27 Jan 2003 21:41:39 -0000 1.319
+++ Makefile.in 29 Jan 2003 20:49:25 -0000
@@ -1384,7 +1384,7 @@
ppcnbsd-nat.o ppcnbsd-tdep.o \
procfs.c \
remote-array.c remote-e7000.c \
- remote-es.c remote-hms.c remote-mips.c \
+ remote-hms.c remote-mips.c \
remote-rdp.c remote-sim.c \
remote-st.c remote-utils.c dcache.c \
remote-vx.c \
@@ -2049,9 +2049,6 @@
remote-e7000.o: remote-e7000.c $(defs_h) $(gdbcore_h) $(gdbarch_h) \
$(inferior_h) $(target_h) $(value_h) $(command_h) $(gdb_string_h) \
$(gdbcmd_h) $(serial_h) $(remote_utils_h) $(symfile_h) $(regcache_h)
-remote-es.o: remote-es.c $(defs_h) $(gdb_string_h) $(frame_h) $(inferior_h) \
- $(target_h) $(command_h) $(symfile_h) $(remote_utils_h) $(gdbcore_h) \
- $(serial_h) $(regcache_h) $(value_h)
remote-est.o: remote-est.c $(defs_h) $(gdbcore_h) $(target_h) $(monitor_h) \
$(serial_h) $(regcache_h) $(m68k_tdep_h)
remote-hms.o: remote-hms.c $(defs_h) $(gdbcore_h) $(target_h) $(monitor_h) \
Index: README
===================================================================
RCS file: /cvs/src/src/gdb/README,v
retrieving revision 1.25
diff -u -r1.25 README
--- README 18 Jan 2003 17:43:14 -0000 1.25
+++ README 29 Jan 2003 20:49:25 -0000
@@ -464,7 +464,6 @@
remote-array.c Array Tech RAID controller
remote-e7000.c Hitachi E7000 ICE
- remote-es.c Ericsson 1800 monitor
remote-est.c EST emulator
remote-hms.c Hitachi Micro Systems H8/300 monitor
remote-mips.c MIPS remote debugging protocol
Index: configure.tgt
===================================================================
RCS file: /cvs/src/src/gdb/configure.tgt,v
retrieving revision 1.90
diff -u -r1.90 configure.tgt
--- configure.tgt 4 Jan 2003 23:47:12 -0000 1.90
+++ configure.tgt 29 Jan 2003 20:49:25 -0000
@@ -126,7 +126,6 @@
m68*-bull-sysv*) gdb_target=dpx2 ;;
m68*-att-*) gdb_target=3b1 ;;
m68*-cisco*-*) gdb_target=cisco ;;
-m68*-ericsson-*) gdb_target=es1800 ;;
m68*-motorola-*) gdb_target=delta68 ;;
m68*-netx-*) gdb_target=vxworks68 ;;
m68*-tandem-*) gdb_target=st2000 ;;
Index: remote-es.c
===================================================================
RCS file: remote-es.c
diff -N remote-es.c
--- remote-es.c 18 Jan 2003 15:55:52 -0000 1.25
+++ /dev/null 1 Jan 1970 00:00:00 -0000
@@ -1,2047 +0,0 @@
-/* Memory-access and commands for remote es1800 processes, for GDB.
-
- Copyright 1988, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
- 2001, 2002 Free Software Foundation, Inc.
-
- This file is added to GDB to make it possible to do debugging via an
- ES-1800 emulator. The code was originally written by Johan Holmberg
- TT/SJ Ericsson Telecom AB and later modified by Johan Henriksson
- TT/SJ. It was modified for gdb 4.0 by TX/DK Jan Nordenand by TX/DKG
- Harald Johansen.
-
- This file is part of GDB.
-
- GDB 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 1, or (at your option)
- any later version.
-
- GDB 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. */
-
-
-/* Emulator communication protocol.
- All values are encoded in ascii hex digits.
-
- Request
- Command
- Reply
- read registers:
- DR<cr>
- - 0 - - 1 - - 2 - - 3 - - 4 - - 5 - -- 6 - - 7 -
- D = XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX
- A = XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX
- PC = XXXXXX SSP = XXXXXX USP = XXXXXX SR = XXXXXXXX
- >
- Each byte of register data is described by two hex digits.
-
- write regs
- D0=XXXXXXXX<cr>
- >D1=XXXXXXXX<cr>
- >D2=XXXXXXXX<cr>
- >D3=XXXXXXXX<cr>
- >D4=XXXXXXXX<cr>
- >D5=XXXXXXXX<cr>
- >D6=XXXXXXXX<cr>
- >D7=XXXXXXXX<cr>
- >A0=XXXXXXXX<cr>
- >A1=XXXXXXXX<cr>
- >A2=XXXXXXXX<cr>
- >A3=XXXXXXXX<cr>
- >A4=XXXXXXXX<cr>
- >A5=XXXXXXXX<cr>
- >A6=XXXXXXXX<cr>
- >A7=XXXXXXXX<cr>
- >SR=XXXXXXXX<cr>
- >PC=XXXXXX<cr>
- >
- Each byte of register data is described by two hex digits.
-
- read mem
- @.BAA..AA
- $FFFFFFXX
- >
- AA..AA is address, XXXXXXX is the contents
-
- write mem
- @.BAA..AA=$XXXXXXXX
- >
- AA..AA is address, XXXXXXXX is data
-
- cont
- PC=$AA..AA
- >RBK
- R>
- AA..AA is address to resume. If AA..AA is omitted, resume at same address.
-
- step
- PC=$AA..AA
- >STP
- R>
- AA..AA is address to resume. If AA..AA is omitted, resume at same address.
-
- kill req
- STP
- >
- */
-
-
-#include <stdio.h>
-#include <signal.h>
-#include <sys/ioctl.h>
-#include <sys/file.h>
-#include <errno.h>
-#include <ctype.h>
-#include <setjmp.h>
-#include <fcntl.h>
-#include "defs.h"
-#include "gdb_string.h"
-#include "frame.h"
-#include "inferior.h"
-#include "target.h"
-#include "command.h"
-#include "symfile.h"
-#include "remote-utils.h"
-#include "gdbcore.h"
-#include "serial.h"
-#include "regcache.h"
-#include "value.h"
-
-/* Prototypes for local functions */
-
-static void es1800_child_detach (char *, int);
-
-static void es1800_child_open (char *, int);
-
-static void es1800_transparent (char *, int);
-
-static void es1800_create_inferior (char *, char *, char **);
-
-static void es1800_load (char *, int);
-
-static void es1800_kill (void);
-
-static int verify_break (int);
-
-static int es1800_remove_breakpoint (CORE_ADDR, char *);
-
-static int es1800_insert_breakpoint (CORE_ADDR, char *);
-
-static void es1800_files_info (struct target_ops *);
-
-static int es1800_xfer_inferior_memory (CORE_ADDR, char *, int, int,
- struct mem_attrib *,
- struct target_ops *);
-
-static void es1800_prepare_to_store (void);
-
-static ptid_t es1800_wait (ptid_t, struct target_waitstatus *);
-
-static void es1800_resume (ptid_t, int, enum target_signal);
-
-static void es1800_detach (char *, int);
-
-static void es1800_attach (char *, int);
-
-static int damn_b (char *);
-
-static void es1800_open (char *, int);
-
-static void es1800_timer (void);
-
-static void es1800_reset (char *);
-
-static void es1800_request_quit (void);
-
-static int readchar (void);
-
-static void expect (char *, int);
-
-static void expect_prompt (void);
-
-static void download (FILE *, int, int);
-
-#if 0
-static void bfd_copy (bfd *, bfd *);
-#endif
-
-static void get_break_addr (int, CORE_ADDR *);
-
-static int fromhex (int);
-
-static int tohex (int);
-
-static void es1800_close (int);
-
-static void es1800_fetch_registers (void);
-
-static void es1800_fetch_register (int);
-
-static void es1800_store_register (int);
-
-static void es1800_read_bytes (CORE_ADDR, char *, int);
-
-static void es1800_write_bytes (CORE_ADDR, char *, int);
-
-static void send_with_reply (char *, char *, int);
-
-static void send_command (char *);
-
-static void send (char *);
-
-static void getmessage (char *, int);
-
-static void es1800_mourn_inferior (void);
-
-static void es1800_create_break_insn (char *, int);
-
-static void es1800_init_break (char *, int);
-
-/* Local variables */
-
-/* FIXME: Convert this to use "set remotedebug" instead. */
-#define LOG_FILE "es1800.log"
-#if defined (LOG_FILE)
-static FILE *log_file;
-#endif
-
-extern struct target_ops es1800_ops; /* Forward decl */
-extern struct target_ops es1800_child_ops; /* Forward decl */
-
-static int kiodebug;
-static int timeout = 100;
-static char *savename; /* Name of i/o device used */
-static serial_ttystate es1800_saved_ttystate;
-static int es1800_fc_save; /* Save fcntl state */
-
-/* indicates that the emulator uses 32-bit data-adress (68020-mode)
- instead of 24-bit (68000 -mode) */
-
-static int m68020;
-
-#define MODE (m68020 ? "M68020" : "M68000" )
-#define ES1800_BREAK_VEC (0xf)
-
-/* Descriptor for I/O to remote machine. Initialize it to NULL so that
- es1800_open knows that we don't have a file open when the program
- starts. */
-
-static struct serial *es1800_desc = NULL;
-
-#define PBUFSIZ 1000
-#define HDRLEN sizeof("@.BAAAAAAAA=$VV\r")
-
-/* Maximum number of bytes to read/write at once. The value here
- is chosen to fill up a packet. */
-
-#define MAXBUFBYTES ((PBUFSIZ-150)*16/75 )
-
-static int es1800_break_vec = 0;
-static char es1800_break_insn[2];
-static long es1800_break_address;
-static void (*old_sigint) (); /* Old signal-handler for sigint */
-static jmp_buf interrupt;
-
-/* Local signalhandler to allow breaking tranfers or program run.
- Rely on global variables: old_sigint(), interrupt */
-
-static void
-es1800_request_quit (void)
-{
- /* restore original signalhandler */
- signal (SIGINT, old_sigint);
- longjmp (interrupt, 1);
-}
-
-
-/* Reset emulator.
- Sending reset character(octal 32) to emulator.
- quit - return to '(esgdb)' prompt or continue */
-
-static void
-es1800_reset (char *quit)
-{
- char buf[80];
-
- if (quit)
- {
- printf ("\nResetting emulator... ");
- }
- strcpy (buf, "\032");
- send (buf);
- expect_prompt ();
- if (quit)
- {
- error ("done\n");
- }
-}
-
-
-/* Open a connection to a remote debugger and push the new target
- onto the stack. Check if the emulator is responding and find out
- what kind of processor the emulator is connected to.
- Initiate the breakpoint handling in the emulator.
-
- name - the filename used for communication (ex. '/dev/tta')
- from_tty - says whether to be verbose or not */
-
-static void
-es1800_open (char *name, int from_tty)
-{
- char buf[PBUFSIZ];
- char *p;
- int i, fcflag;
-
- m68020 = 0;
-
- if (!name) /* no device name given in target command */
- {
- error_no_arg ("serial port device name");
- }
-
- target_preopen (from_tty);
- es1800_close (0);
-
- /* open the device and configure it for communication */
-
-#ifndef DEBUG_STDIN
-
- es1800_desc = serial_open (name);
- if (es1800_desc == NULL)
- {
- perror_with_name (name);
- }
- savename = savestring (name, strlen (name));
-
- es1800_saved_ttystate = serial_get_tty_state (es1800_desc);
-
- if ((fcflag = fcntl (deprecated_serial_fd (es1800_desc), F_GETFL, 0)) == -1)
- {
- perror_with_name ("fcntl serial");
- }
- es1800_fc_save = fcflag;
-
- fcflag = (fcflag & (FREAD | FWRITE)); /* mask out any funny stuff */
- if (fcntl (deprecated_serial_fd (es1800_desc), F_SETFL, fcflag) == -1)
- {
- perror_with_name ("fcntl serial");
- }
-
- if (baud_rate != -1)
- {
- if (serial_setbaudrate (es1800_desc, baud_rate))
- {
- serial_close (es1800_desc);
- perror_with_name (name);
- }
- }
-
- serial_raw (es1800_desc);
-
- /* If there is something sitting in the buffer we might take it as a
- response to a command, which would be bad. */
- serial_flush_input (es1800_desc);
-
-#endif /* DEBUG_STDIN */
-
- push_target (&es1800_ops); /* Switch to using remote target now */
- if (from_tty)
- {
- printf ("Remote ES1800 debugging using %s\n", name);
- }
-
-#if defined (LOG_FILE)
-
- log_file = fopen (LOG_FILE, "w");
- if (log_file == NULL)
- {
- perror_with_name (LOG_FILE);
- }
-
-#endif /* LOG_FILE */
-
- /* Hello? Are you there?, also check mode */
-
- /* send_with_reply( "DB 0 TO 1", buf, sizeof(buf)); */
- /* for (p = buf, i = 0; *p++ =='0';) *//* count the number of zeros */
- /* i++; */
-
- send ("\032");
- getmessage (buf, sizeof (buf)); /* send reset character */
-
- if (from_tty)
- {
- printf ("Checking mode.... ");
- }
- /* m68020 = (i==8); *//* if eight zeros then we are in m68020 mode */
-
- /* What kind of processor am i talking to ? */
- p = buf;
- while (*p++ != '\n')
- {;
- }
- while (*p++ != '\n')
- {;
- }
- while (*p++ != '\n')
- {;
- }
- for (i = 0; i < 20; i++, p++)
- {;
- }
- m68020 = !strncmp (p, "68020", 5);
- if (from_tty)
- {
- printf ("You are in %s(%c%c%c%c%c)-mode\n", MODE, p[0], p[1], p[2],
- p[3], p[4]);
- }
-
- /* if no init_break statement is present in .gdb file we have to check
- whether to download a breakpoint routine or not */
-
-#if 0
- if ((es1800_break_vec == 0) || (verify_break (es1800_break_vec) != 0)
- && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
- {
- CORE_ADDR memaddress;
- printf ("Give the start address of the breakpoint routine: ");
- scanf ("%li", &memaddress);
- es1800_init_break ((es1800_break_vec ? es1800_break_vec :
- ES1800_BREAK_VEC), memaddress);
- }
-#endif
-
-}
-
-/* Close out all files and local state before this target loses control.
- quitting - are we quitting gdb now? */
-
-static void
-es1800_close (int quitting)
-{
- if (es1800_desc != NULL)
- {
- printf ("\nClosing connection to emulator...\n");
- if (serial_set_tty_state (es1800_desc, es1800_saved_ttystate) < 0)
- print_sys_errmsg ("warning: unable to restore tty state", errno);
- fcntl (deprecated_serial_fd (es1800_desc), F_SETFL, es1800_fc_save);
- serial_close (es1800_desc);
- es1800_desc = NULL;
- }
- if (savename != NULL)
- {
- xfree (savename);
- }
- savename = NULL;
-
-#if defined (LOG_FILE)
-
- if (log_file != NULL)
- {
- if (ferror (log_file))
- {
- printf ("Error writing log file.\n");
- }
- if (fclose (log_file) != 0)
- {
- printf ("Error closing log file.\n");
- }
- log_file = NULL;
- }
-
-#endif /* LOG_FILE */
-
-}
-
-/* Attaches to a process on the target side
- proc_id - the id of the process to be attached.
- from_tty - says whether to be verbose or not */
-
-static void
-es1800_attach (char *args, int from_tty)
-{
- error ("Cannot attach to pid %s, this feature is not implemented yet.",
- args);
-}
-
-
-/* Takes a program previously attached to and detaches it.
- We better not have left any breakpoints
- in the program or it'll die when it hits one.
- Close the open connection to the remote debugger.
- Use this when you want to detach and do something else
- with your gdb.
-
- args - arguments given to the 'detach' command
- from_tty - says whether to be verbose or not */
-
-static void
-es1800_detach (char *args, int from_tty)
-{
- if (args)
- {
- error ("Argument given to \"detach\" when remotely debugging.");
- }
- pop_target ();
- if (from_tty)
- {
- printf ("Ending es1800 remote debugging.\n");
- }
-}
-
-
-/* Tell the remote machine to resume.
- step - single-step or run free
- siggnal - the signal value to be given to the target (0 = no signal) */
-
-static void
-es1800_resume (ptid_t ptid, int step, enum target_signal siggnal)
-{
- char buf[PBUFSIZ];
-
- if (siggnal)
- {
- error ("Can't send signals to a remote system.");
- }
- if (step)
- {
- strcpy (buf, "STP\r");
- send (buf);
- }
- else
- {
- send_command ("RBK");
- }
-}
-
-/* Wait until the remote machine stops, then return,
- storing status in STATUS just as `wait' would.
- status - */
-
-static ptid_t
-es1800_wait (ptid_t ptid, struct target_waitstatus *status)
-{
- unsigned char buf[PBUFSIZ];
- int old_timeout = timeout;
-
- status->kind = TARGET_WAITKIND_EXITED;
- status->value.integer = 0;
-
- timeout = 0; /* Don't time out -- user program is running. */
- if (!setjmp (interrupt))
- {
- old_sigint = signal (SIGINT, es1800_request_quit);
- while (1)
- {
- getmessage (buf, sizeof (buf));
- if (strncmp (buf, "\r\n* BREAK *", 11) == 0)
- {
- status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = TARGET_SIGNAL_TRAP;
- send_command ("STP"); /* Restore stack and PC and such */
- if (m68020)
- {
- send_command ("STP");
- }
- break;
- }
- if (strncmp (buf, "STP\r\n ", 6) == 0)
- {
- status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = TARGET_SIGNAL_TRAP;
- break;
- }
- if (buf[strlen (buf) - 2] == 'R')
- {
- printf ("Unexpected emulator reply: \n%s\n", buf);
- }
- else
- {
- printf ("Unexpected stop: \n%s\n", buf);
- status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = TARGET_SIGNAL_QUIT;
- break;
- }
- }
- }
- else
- {
- fflush (stdin);
- printf ("\nStopping emulator...");
- if (!setjmp (interrupt))
- {
- old_sigint = signal (SIGINT, es1800_request_quit);
- send_command ("STP");
- printf (" emulator stopped\n");
- status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = TARGET_SIGNAL_INT;
- }
- else
- {
- fflush (stdin);
- es1800_reset ((char *) 1);
- }
- }
- signal (SIGINT, old_sigint);
- timeout = old_timeout;
- return inferior_ptid;
-}
-
-
-/* Fetch register values from remote machine.
- regno - the register to be fetched (fetch all registers if -1) */
-
-static void
-es1800_fetch_register (int regno)
-{
- char buf[PBUFSIZ];
- int k;
- int r;
- char *p;
- static char regtab[18][4] =
- {
- "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
- "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
- "SR ", "PC "
- };
-
- if ((regno < 15) || (regno == 16) || (regno == 17))
- {
- r = regno * 4;
- send_with_reply (regtab[regno], buf, sizeof (buf));
- p = buf;
- for (k = 0; k < 4; k++)
- {
- if ((p[k * 2 + 1] == 0) || (p[k * 2 + 2] == 0))
- {
- error ("Emulator reply is too short: %s", buf);
- }
- deprecated_registers[r++] = (fromhex (p[k * 2 + 1]) * 16) + fromhex (p[k * 2 + 2]);
- }
- }
- else
- {
- es1800_fetch_registers ();
- }
-}
-
-/* Read the remote registers into REGISTERS.
- Always fetches all registers. */
-
-static void
-es1800_fetch_registers (void)
-{
- char buf[PBUFSIZ];
- char SR_buf[PBUFSIZ];
- int i;
- int k;
- int r;
- char *p;
-
- send_with_reply ("DR", buf, sizeof (buf));
-
- /* Reply is edited to a string that describes registers byte by byte,
- each byte encoded as two hex characters. */
-
- p = buf;
- r = 0;
-
- /* parsing row one - D0-D7-registers */
-
- while (*p++ != '\n')
- {;
- }
- for (i = 4; i < 70; i += (i == 39 ? 3 : 1))
- {
- for (k = 0; k < 4; k++)
- {
- if (p[i + 0] == 0 || p[i + 1] == 0)
- {
- error ("Emulator reply is too short: %s", buf);
- }
- deprecated_registers[r++] = (fromhex (p[i + 0]) * 16) + fromhex (p[i + 1]);
- i += 2;
- }
- }
- p += i;
-
- /* parsing row two - A0-A6-registers */
-
- while (*p++ != '\n')
- {;
- }
- for (i = 4; i < 61; i += (i == 39 ? 3 : 1))
- {
- for (k = 0; k < 4; k++)
- {
- if (p[i + 0] == 0 || p[i + 1] == 0)
- {
- error ("Emulator reply is too short: %s", buf);
- }
- deprecated_registers[r++] = (fromhex (p[i + 0])) * 16 + fromhex (p[i + 1]);
- i += 2;
- }
- }
- p += i;
-
- while (*p++ != '\n')
- {;
- }
-
- /* fetch SSP-, SR- and PC-registers */
-
- /* first - check STATUS-word and decide which stackpointer to use */
-
- send_with_reply ("SR", SR_buf, sizeof (SR_buf));
- p = SR_buf;
- p += 5;
-
- if (m68020)
- {
- if (*p == '3') /* use masterstackpointer MSP */
- {
- send_with_reply ("MSP", buf, sizeof (buf));
- }
- else if (*p == '2') /* use interruptstackpointer ISP */
- {
- send_with_reply ("ISP", buf, sizeof (buf));
- }
- else
- /* use userstackpointer USP */
- {
- send_with_reply ("USP", buf, sizeof (buf));
- }
- p = buf;
- for (k = 0; k < 4; k++)
- {
- if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
- {
- error ("Emulator reply is too short: %s", buf);
- }
- deprecated_registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
- }
-
- p = SR_buf;
- for (k = 0; k < 4; k++)
- {
- if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
- {
- error ("Emulator reply is too short: %s", buf);
- }
- deprecated_registers[r++] =
- fromhex (SR_buf[k * 2 + 1]) * 16 + fromhex (SR_buf[k * 2 + 2]);
- }
- send_with_reply ("PC", buf, sizeof (buf));
- p = buf;
- for (k = 0; k < 4; k++)
- {
- if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
- {
- error ("Emulator reply is too short: %s", buf);
- }
- deprecated_registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
- }
- }
- else
- /* 68000-mode */
- {
- if (*p == '2') /* use supervisorstackpointer SSP */
- {
- send_with_reply ("SSP", buf, sizeof (buf));
- }
- else
- /* use userstackpointer USP */
- {
- send_with_reply ("USP", buf, sizeof (buf));
- }
-
- /* fetch STACKPOINTER */
-
- p = buf;
- for (k = 0; k < 4; k++)
- {
- if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
- {
- error ("Emulator reply is too short: %s", buf);
- }
- deprecated_registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
- }
-
- /* fetch STATUS */
-
- p = SR_buf;
- for (k = 0; k < 4; k++)
- {
- if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
- {
- error ("Emulator reply is too short: %s", buf);
- }
- deprecated_registers[r++] =
- fromhex (SR_buf[k * 2 + 1]) * 16 + fromhex (SR_buf[k * 2 + 2]);
- }
-
- /* fetch PC */
-
- send_with_reply ("PC", buf, sizeof (buf));
- p = buf;
- for (k = 0; k < 4; k++)
- {
- if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
- {
- error ("Emulator reply is too short: %s", buf);
- }
- deprecated_registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
- }
- }
-}
-
-/* Store register value, located in REGISTER, on the target processor.
- regno - the register-number of the register to store
- (-1 means store them all)
- FIXME: Return errno value. */
-
-static void
-es1800_store_register (int regno)
-{
-
- static char regtab[18][4] =
- {
- "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
- "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
- "SR ", "PC "
- };
-
- char buf[PBUFSIZ];
- char SR_buf[PBUFSIZ];
- char stack_pointer[4];
- char *p;
- int i;
- int j;
- int k;
- unsigned char *r;
-
- r = (unsigned char *) deprecated_registers;
-
- if (regno == -1) /* write all registers */
- {
- j = 0;
- k = 18;
- }
- else
- /* write one register */
- {
- j = regno;
- k = regno + 1;
- r += regno * 4;
- }
-
- if ((regno == -1) || (regno == 15))
- {
- /* fetch current status */
- send_with_reply ("SR", SR_buf, sizeof (SR_buf));
- p = SR_buf;
- p += 5;
- if (m68020)
- {
- if (*p == '3') /* use masterstackpointer MSP */
- {
- strcpy (stack_pointer, "MSP");
- }
- else
- {
- if (*p == '2') /* use interruptstackpointer ISP */
- {
- strcpy (stack_pointer, "ISP");
- }
- else
- {
- strcpy (stack_pointer, "USP"); /* use userstackpointer USP */
- }
- }
- }
- else
- /* 68000-mode */
- {
- if (*p == '2') /* use supervisorstackpointer SSP */
- {
- strcpy (stack_pointer, "SSP");
- }
- else
- {
- strcpy (stack_pointer, "USP"); /* use userstackpointer USP */
- }
- }
- strcpy (regtab[15], stack_pointer);
- }
-
- for (i = j; i < k; i++)
- {
- buf[0] = regtab[i][0];
- buf[1] = regtab[i][1];
- buf[2] = regtab[i][2];
- buf[3] = '=';
- buf[4] = '$';
- buf[5] = tohex ((*r >> 4) & 0x0f);
- buf[6] = tohex (*r++ & 0x0f);
- buf[7] = tohex ((*r >> 4) & 0x0f);
- buf[8] = tohex (*r++ & 0x0f);
- buf[9] = tohex ((*r >> 4) & 0x0f);
- buf[10] = tohex (*r++ & 0x0f);
- buf[11] = tohex ((*r >> 4) & 0x0f);
- buf[12] = tohex (*r++ & 0x0f);
- buf[13] = 0;
-
- send_with_reply (buf, buf, sizeof (buf)); /* FIXME, reply not used? */
- }
-}
-
-
-/* Prepare to store registers. */
-
-static void
-es1800_prepare_to_store (void)
-{
- /* Do nothing, since we can store individual regs */
-}
-
-/* Convert hex digit A to a number. */
-
-static int
-fromhex (int a)
-{
- if (a >= '0' && a <= '9')
- {
- return a - '0';
- }
- else if (a >= 'a' && a <= 'f')
- {
- return a - 'a' + 10;
- }
- else if (a >= 'A' && a <= 'F')
- {
- return a - 'A' + 10;
- }
- else
- {
- error ("Reply contains invalid hex digit");
- }
- return (-1);
-}
-
-
-/* Convert number NIB to a hex digit. */
-
-static int
-tohex (int nib)
-{
- if (nib < 10)
- {
- return ('0' + nib);
- }
- else
- {
- return ('A' + nib - 10);
- }
-}
-
-/* Read or write LEN bytes from inferior memory at MEMADDR, transferring
- to or from debugger address MYADDR. Write to inferior if WRITE is
- nonzero. Returns length of data written or read; 0 for error.
-
- memaddr - the target's address
- myaddr - gdb's address
- len - number of bytes
- write - write if != 0 otherwise read
- tops - unused */
-
-static int
-es1800_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
- int write, struct mem_attrib *attrib,
- struct target_ops *target)
-{
- int origlen = len;
- int xfersize;
-
- while (len > 0)
- {
- xfersize = len > MAXBUFBYTES ? MAXBUFBYTES : len;
- if (write)
- {
- es1800_write_bytes (memaddr, myaddr, xfersize);
- }
- else
- {
- es1800_read_bytes (memaddr, myaddr, xfersize);
- }
- memaddr += xfersize;
- myaddr += xfersize;
- len -= xfersize;
- }
- return (origlen); /* no error possible */
-}
-
-
-/* Write memory data directly to the emulator.
- This does not inform the data cache; the data cache uses this.
- MEMADDR is the address in the remote memory space.
- MYADDR is the address of the buffer in our space.
- LEN is the number of bytes.
-
- memaddr - the target's address
- myaddr - gdb's address
- len - number of bytes */
-
-static void
-es1800_write_bytes (CORE_ADDR memaddr, char *myaddr, int len)
-{
- char buf[PBUFSIZ];
- int i;
- char *p;
-
- p = myaddr;
- for (i = 0; i < len; i++)
- {
- sprintf (buf, "@.B$%x=$%x", memaddr + i, (*p++) & 0xff);
- send_with_reply (buf, buf, sizeof (buf)); /* FIXME send_command? */
- }
-}
-
-
-/* Read memory data directly from the emulator.
- This does not use the data cache; the data cache uses this.
-
- memaddr - the target's address
- myaddr - gdb's address
- len - number of bytes */
-
-static void
-es1800_read_bytes (CORE_ADDR memaddr, char *myaddr, int len)
-{
- static int DB_tab[16] =
- {8, 11, 14, 17, 20, 23, 26, 29, 34, 37, 40, 43, 46, 49, 52, 55};
- char buf[PBUFSIZ];
- int i;
- int low_addr;
- char *p;
- char *b;
-
- if (len > PBUFSIZ / 2 - 1)
- {
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
- }
-
- if (len == 1) /* The emulator does not like expressions like: */
- {
- len = 2; /* DB.B $20018 TO $20018 */
- }
-
- /* Reply describes registers byte by byte, each byte encoded as two hex
- characters. */
-
- sprintf (buf, "DB.B $%x TO $%x", memaddr, memaddr + len - 1);
- send_with_reply (buf, buf, sizeof (buf));
- b = buf;
- low_addr = memaddr & 0x0f;
- for (i = low_addr; i < low_addr + len; i++)
- {
- if ((!(i % 16)) && i)
- { /* if (i = 16,32,48) */
- while (*p++ != '\n')
- {;
- }
- b = p;
- }
- p = b + DB_tab[i % 16] + (m68020 ? 2 : 0);
- if (p[0] == 32 || p[1] == 32)
- {
- error ("Emulator reply is too short: %s", buf);
- }
- myaddr[i - low_addr] = fromhex (p[0]) * 16 + fromhex (p[1]);
- }
-}
-
-/* Display information about the current target. TOPS is unused. */
-
-static void
-es1800_files_info (struct target_ops *tops)
-{
- printf ("ES1800 Attached to %s at %d baud in %s mode\n", savename, 19200,
- MODE);
-}
-
-
-/* We read the contents of the target location and stash it,
- then overwrite it with a breakpoint instruction.
-
- addr - is the target location in the target machine.
- contents_cache - is a pointer to memory allocated for saving the target contents.
- It is guaranteed by the caller to be long enough to save sizeof
- BREAKPOINT bytes.
-
- FIXME: This size is target_arch dependent and should be available in
- the target_arch transfer vector, if we ever have one... */
-
-static int
-es1800_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
- int val;
-
- val = target_read_memory (addr, contents_cache, sizeof (es1800_break_insn));
-
- if (val == 0)
- {
- val = target_write_memory (addr, es1800_break_insn,
- sizeof (es1800_break_insn));
- }
-
- return (val);
-}
-
-
-/* Write back the stashed instruction
-
- addr - is the target location in the target machine.
- contents_cache - is a pointer to memory allocated for saving the target contents.
- It is guaranteed by the caller to be long enough to save sizeof
- BREAKPOINT bytes. */
-
-static int
-es1800_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
-
- return (target_write_memory (addr, contents_cache,
- sizeof (es1800_break_insn)));
-}
-
-/* create_break_insn ()
- Primitive datastructures containing the es1800 breakpoint instruction */
-
-static void
-es1800_create_break_insn (char *ins, int vec)
-{
- if (vec == 15)
- {
- ins[0] = 0x4e;
- ins[1] = 0x4f;
- }
-}
-
-
-/* verify_break ()
- Seach for breakpoint routine in emulator memory.
- returns non-zero on failure
- vec - trap vector used for breakpoints */
-
-static int
-verify_break (int vec)
-{
- CORE_ADDR memaddress;
- char buf[8];
- char *instr = "NqNqNqNs"; /* breakpoint routine */
- int status;
-
- get_break_addr (vec, &memaddress);
-
- if (memaddress)
- {
- status = target_read_memory (memaddress, buf, 8);
- if (status != 0)
- {
- memory_error (status, memaddress);
- }
- return (strcmp (instr, buf));
- }
- return (-1);
-}
-
-
-/* get_break_addr ()
- find address of breakpoint routine
- vec - trap vector used for breakpoints
- addrp - store the address here */
-
-static void
-get_break_addr (int vec, CORE_ADDR *addrp)
-{
- CORE_ADDR memaddress = 0;
- int status;
- int k;
- char buf[PBUFSIZ];
- char base_addr[4];
- char *p;
-
- if (m68020)
- {
- send_with_reply ("VBR ", buf, sizeof (buf));
- p = buf;
- for (k = 0; k < 4; k++)
- {
- if ((p[k * 2 + 1] == 0) || (p[k * 2 + 2] == 0))
- {
- error ("Emulator reply is too short: %s", buf);
- }
- base_addr[k] = (fromhex (p[k * 2 + 1]) * 16) + fromhex (p[k * 2 + 2]);
- }
- /* base addr of exception vector table */
- memaddress = *((CORE_ADDR *) base_addr);
- }
-
- memaddress += (vec + 32) * 4; /* address of trap vector */
- status = target_read_memory (memaddress, (char *) addrp, 4);
- if (status != 0)
- {
- memory_error (status, memaddress);
- }
-}
-
-
-/* Kill an inferior process */
-
-static void
-es1800_kill (void)
-{
- if (!ptid_equal (inferior_ptid, null_ptid))
- {
- inferior_ptid = null_ptid;
- es1800_mourn_inferior ();
- }
-}
-
-
-/* Load a file to the ES1800 emulator.
- Converts the file from a.out format into Extended Tekhex format
- before the file is loaded.
- Also loads the trap routine, and sets the ES1800 breakpoint on it
- filename - the a.out to be loaded
- from_tty - says whether to be verbose or not
- FIXME Uses emulator overlay memory for trap routine */
-
-static void
-es1800_load (char *filename, int from_tty)
-{
-
- FILE *instream;
- char loadname[15];
- char buf[160];
- struct cleanup *old_chain;
- int es1800_load_format = 5;
-
- if (es1800_desc == NULL)
- {
- printf ("No emulator attached, type emulator-command first\n");
- return;
- }
-
- filename = tilde_expand (filename);
- make_cleanup (xfree, filename);
-
- switch (es1800_load_format)
- {
- case 2: /* Extended Tekhex */
- if (from_tty)
- {
- printf ("Converting \"%s\" to Extended Tekhex Format\n", filename);
- }
- sprintf (buf, "tekhex %s", filename);
- system (buf);
- sprintf (loadname, "out.hex");
- break;
-
- case 5: /* Motorola S-rec */
- if (from_tty)
- {
- printf ("Converting \"%s\" to Motorola S-record format\n",
- filename);
- }
- /* in the future the source code in copy (part of binutils-1.93) will
- be included in this file */
- sprintf (buf,
- "copy -s \"a.out-sunos-big\" -d \"srec\" %s /tmp/out.hex",
- filename);
- system (buf);
- sprintf (loadname, "/tmp/out.hex");
- break;
-
- default:
- error ("Downloading format not defined\n");
- }
-
- breakpoint_init_inferior ();
- inferior_ptid = null_ptid;
- if (from_tty)
- {
- printf ("Downloading \"%s\" to the ES 1800\n", filename);
- }
- if ((instream = fopen (loadname, "r")) == NULL)
- {
- perror_with_name ("fopen:");
- }
-
- old_chain = make_cleanup (fclose, instream);
- immediate_quit++;
-
- es1800_reset (0);
-
- download (instream, from_tty, es1800_load_format);
-
- /* if breakpoint routine is not present anymore we have to check
- whether to download a new breakpoint routine or not */
-
- if ((verify_break (es1800_break_vec) != 0)
- && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
- {
- char buf[128];
- printf ("Using break vector 0x%x\n", es1800_break_vec);
- sprintf (buf, "0x%x ", es1800_break_vec);
- printf ("Give the start address of the breakpoint routine: ");
- fgets (buf + strlen (buf), sizeof (buf) - strlen (buf), stdin);
- es1800_init_break (buf, 0);
- }
-
- do_cleanups (old_chain);
- expect_prompt ();
- readchar (); /* FIXME I am getting a ^G = 7 after the prompt */
- printf ("\n");
-
- if (fclose (instream) == EOF)
- {
- ;
- }
-
- if (es1800_load_format != 2)
- {
- sprintf (buf, "/usr/bin/rm %s", loadname);
- system (buf);
- }
-
- symbol_file_add_main (filename, from_tty); /* reading symbol table */
- immediate_quit--;
-}
-
-#if 0
-
-#define NUMCPYBYTES 20
-
-static void
-bfd_copy (bfd *from_bfd, bfd *to_bfd)
-{
- asection *p, *new;
- int i;
- char buf[NUMCPYBYTES];
-
- for (p = from_bfd->sections; p != NULL; p = p->next)
- {
- printf (" Copying section %s. Size = %x.\n", p->name, p->_cooked_size);
- printf (" vma = %x, offset = %x, output_sec = %x\n",
- p->vma, p->output_offset, p->output_section);
- new = bfd_make_section (to_bfd, p->name);
- if (p->_cooked_size &&
- !bfd_set_section_size (to_bfd, new, p->_cooked_size))
- {
- error ("Wrong BFD size!\n");
- }
- if (!bfd_set_section_flags (to_bfd, new, p->flags))
- {
- error ("bfd_set_section_flags");
- }
- new->vma = p->vma;
-
- for (i = 0; (i + NUMCPYBYTES) < p->_cooked_size; i += NUMCPYBYTES)
- {
- if (!bfd_get_section_contents (from_bfd, p, buf, (file_ptr) i,
- (bfd_size_type) NUMCPYBYTES))
- {
- error ("bfd_get_section_contents\n");
- }
- if (!bfd_set_section_contents (to_bfd, new, buf, (file_ptr) i,
- (bfd_size_type) NUMCPYBYTES))
- {
- error ("bfd_set_section_contents\n");
- }
- }
- bfd_get_section_contents (from_bfd, p, buf, (file_ptr) i,
- (bfd_size_type) (p->_cooked_size - i));
- bfd_set_section_contents (to_bfd, new, buf, (file_ptr) i,
- (bfd_size_type) (p->_cooked_size - i));
- }
-}
-
-#endif
-
-/* Start an process on the es1800 and set inferior_ptid to the new
- process' pid.
- execfile - the file to run
- args - arguments passed to the program
- env - the environment vector to pass */
-
-static void
-es1800_create_inferior (char *execfile, char *args, char **env)
-{
- int entry_pt;
- int pid;
-#if 0
- struct expression *expr;
- register struct cleanup *old_chain = 0;
- register value val;
-#endif
-
- if (args && *args)
- {
- error ("Can't pass arguments to remote ES1800 process");
- }
-
-#if 0
- if (query ("Use 'start' as entry point? "))
- {
- expr = parse_c_expression ("start");
- old_chain = make_cleanup (free_current_contents, &expr);
- val = evaluate_expression (expr);
- entry_pt = (val->location).address;
- }
- else
- {
- printf ("Enter the program's entry point (in hexadecimal): ");
- scanf ("%x", &entry_pt);
- }
-#endif
-
- if (execfile == 0 || exec_bfd == 0)
- {
- error ("No executable file specified");
- }
-
- entry_pt = (int) bfd_get_start_address (exec_bfd);
-
- pid = 42;
-
- /* Now that we have a child process, make it our target. */
-
- push_target (&es1800_child_ops);
-
- /* The "process" (board) is already stopped awaiting our commands, and
- the program is already downloaded. We just set its PC and go. */
-
- inferior_ptid = pid_to_ptid (pid); /* Needed for wait_for_inferior below */
-
- clear_proceed_status ();
-
- /* Tell wait_for_inferior that we've started a new process. */
-
- init_wait_for_inferior ();
-
- /* Set up the "saved terminal modes" of the inferior
- based on what modes we are starting it with. */
-
- target_terminal_init ();
-
- /* Install inferior's terminal modes. */
-
- target_terminal_inferior ();
-
- /* remote_start (args); */
- /* trap_expected = 0; */
- /* insert_step_breakpoint (); FIXME, do we need this? */
-
- /* Let 'er rip... */
- proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
-
-}
-
-
-/* The process has died, clean up. */
-
-static void
-es1800_mourn_inferior (void)
-{
- remove_breakpoints ();
- unpush_target (&es1800_child_ops);
- generic_mourn_inferior (); /* Do all the proper things now */
-}
-
-/* ES1800-protocol specific routines */
-
-/* Keep discarding input from the remote system, until STRING is found.
- Let the user break out immediately.
- string - the string to expect
- nowait - break out if string not the emulator's first respond otherwise
- read until string is found (== 0) */
-
-static void
-expect (char *string, int nowait)
-{
- char c;
- char *p = string;
-
- immediate_quit++;
- while (1)
- {
- c = readchar ();
- if (isalpha (c))
- {
- c = toupper (c);
- }
- if (c == toupper (*p))
- {
- p++;
- if (*p == '\0')
- {
- immediate_quit--;
- return;
- }
- }
- else if (!nowait)
- {
- p = string;
- }
- else
- {
- printf ("\'%s\' expected\n", string);
- printf ("char %d is %d", p - string, c);
- error ("\n");
- }
- }
-}
-
-/* Keep discarding input until we see the prompt. */
-
-static void
-expect_prompt (void)
-{
- expect (">", 0);
-}
-
-
-/* Read one character */
-
-#ifdef DEBUG_STDIN
-
-/* read from stdin */
-
-static int
-readchar (void)
-{
- char buf[1];
-
- buf[0] = '\0';
- printf ("readchar, give one character\n");
- read (0, buf, 1);
-
-#if defined (LOG_FILE)
- putc (buf[0] & 0x7f, log_file);
-#endif
-
- return (buf[0] & 0x7f);
-}
-
-#else /* !DEBUG_STDIN */
-
-/* Read a character from the remote system, doing all the fancy
- timeout stuff. */
-
-static int
-readchar (void)
-{
- int ch;
-
- ch = serial_readchar (es1800_desc, timeout);
-
- /* FIXME: doing an error() here will probably cause trouble, at least if from
- es1800_wait. */
- if (ch == SERIAL_TIMEOUT)
- error ("Timeout reading from remote system.");
- else if (ch == SERIAL_ERROR)
- perror_with_name ("remote read");
-
-#if defined (LOG_FILE)
- putc (ch & 0x7f, log_file);
- fflush (log_file);
-#endif
-
- return (ch);
-}
-
-#endif /* DEBUG_STDIN */
-
-
-/* Send a command to the emulator and save the reply.
- Report an error if we get an error reply.
- string - the es1800 command
- buf - containing the emulator reply on return
- len - size of buf */
-
-static void
-send_with_reply (char *string, char *buf, int len)
-{
- send (string);
- serial_write (es1800_desc, "\r", 1);
-
-#ifndef DEBUG_STDIN
- expect (string, 1);
- expect ("\r\n", 0);
-#endif
-
- getmessage (buf, len);
-}
-
-
-/* Send the command in STR to the emulator adding \r. check
- the echo for consistency.
- string - the es1800 command */
-
-static void
-send_command (char *string)
-{
- send (string);
- serial_write (es1800_desc, "\r", 1);
-
-#ifndef DEBUG_STDIN
- expect (string, 0);
- expect_prompt ();
-#endif
-
-}
-
-/* Send a string
- string - the es1800 command */
-
-static void
-send (char *string)
-{
- if (kiodebug)
- {
- fprintf_unfiltered (gdb_stderr, "Sending: %s\n", string);
- }
- serial_write (es1800_desc, string, strlen (string));
-}
-
-
-/* Read a message from the emulator and store it in BUF.
- buf - containing the emulator reply on return
- len - size of buf */
-
-static void
-getmessage (char *buf, int len)
-{
- char *bp;
- int c;
- int prompt_found = 0;
- extern kiodebug;
-
-#if defined (LOG_FILE)
- /* This is a convenient place to do this. The idea is to do it often
- enough that we never lose much data if we terminate abnormally. */
- fflush (log_file);
-#endif
-
- bp = buf;
- c = readchar ();
- do
- {
- if (c)
- {
- if (len-- < 2) /* char and terminaling NULL */
- {
- error ("input buffer overrun\n");
- }
- *bp++ = c;
- }
- c = readchar ();
- if ((c == '>') && (*(bp - 1) == ' '))
- {
- prompt_found = 1;
- }
- }
- while (!prompt_found);
- *bp = 0;
-
- if (kiodebug)
- {
- fprintf_unfiltered (gdb_stderr, "message received :%s\n", buf);
- }
-}
-
-static void
-download (FILE *instream, int from_tty, int format)
-{
- char c;
- char buf[160];
- int i = 0;
-
- send_command ("SET #2,$1A"); /* reset char = ^Z */
- send_command ("SET #3,$11,$13"); /* XON XOFF */
- if (format == 2)
- {
- send_command ("SET #26,#2");
- }
- else
- {
- send_command ("SET #26,#5"); /* Format=Extended Tekhex */
- }
- send_command ("DFB = $10");
- send_command ("PUR");
- send_command ("CES");
- send ("DNL\r");
- expect ("DNL", 1);
- if (from_tty)
- {
- printf (" 0 records loaded...\r");
- }
- while (fgets (buf, 160, instream))
- {
- send (buf);
- if (from_tty)
- {
- printf ("%5d\b\b\b\b\b", ++i);
- fflush (stdout);
- }
- if ((c = readchar ()) != 006)
- {
- error ("expected ACK");
- }
- }
- if (from_tty)
- {
- printf ("- All");
- }
-}
-
-/* Additional commands */
-
-#if defined (TIOCGETP) && defined (FNDELAY) && defined (EWOULDBLOCK)
-#define PROVIDE_TRANSPARENT
-#endif
-
-#ifdef PROVIDE_TRANSPARENT
-/* Talk directly to the emulator
- FIXME, uses busy wait, and is SUNOS (or at least BSD) specific */
-
-/*ARGSUSED */
-static void
-es1800_transparent (char *args, int from_tty)
-{
- int console;
- struct sgttyb modebl;
- int fcflag;
- int cc;
- struct sgttyb console_mode_save;
- int console_fc_save;
- int es1800_fc_save;
- int inputcnt = 80;
- char inputbuf[80];
- int consolecnt = 0;
- char consolebuf[80];
- int es1800_cnt = 0;
- char es1800_buf[80];
- int i;
-
- dont_repeat ();
- if (es1800_desc == NULL)
- {
- printf ("No emulator attached, type emulator-command first\n");
- return;
- }
-
- printf ("\n");
- printf ("You are now communicating directly with the ES 1800 emulator.\n");
- printf ("To leave this mode (transparent mode), press ^E.\n");
- printf ("\n");
- printf (" >");
- fflush (stdout);
-
- if ((console = open ("/dev/tty", O_RDWR)) == -1)
- {
- perror_with_name ("/dev/tty:");
- }
-
- if ((fcflag = fcntl (console, F_GETFL, 0)) == -1)
- {
- perror_with_name ("fcntl console");
- }
-
- console_fc_save = fcflag;
- fcflag = fcflag | FNDELAY;
-
- if (fcntl (console, F_SETFL, fcflag) == -1)
- {
- perror_with_name ("fcntl console");
- }
-
- if (ioctl (console, TIOCGETP, &modebl))
- {
- perror_with_name ("ioctl console");
- }
-
- console_mode_save = modebl;
- modebl.sg_flags = RAW;
-
- if (ioctl (console, TIOCSETP, &modebl))
- {
- perror_with_name ("ioctl console");
- }
-
- if ((fcflag = fcntl (deprecated_serial_fd (es1800_desc), F_GETFL, 0)) == -1)
- {
- perror_with_name ("fcntl serial");
- }
-
- es1800_fc_save = fcflag;
- fcflag = fcflag | FNDELAY;
-
- if (fcntl (deprecated_serial_fd (es1800_desc), F_SETFL, fcflag) == -1)
- {
- perror_with_name ("fcntl serial");
- }
-
- while (1)
- {
- cc = read (console, inputbuf, inputcnt);
- if (cc != -1)
- {
- if ((*inputbuf & 0x7f) == 0x05)
- {
- break;
- }
- for (i = 0; i < cc;)
- {
- es1800_buf[es1800_cnt++] = inputbuf[i++];
- }
- if ((cc = serial_write (es1800_desc, es1800_buf, es1800_cnt)) == -1)
- {
- perror_with_name ("FEL! write:");
- }
- es1800_cnt -= cc;
- if (es1800_cnt && cc)
- {
- for (i = 0; i < es1800_cnt; i++)
- {
- es1800_buf[i] = es1800_buf[cc + i];
- }
- }
- }
- else if (errno != EWOULDBLOCK)
- {
- perror_with_name ("FEL! read:");
- }
-
- cc = read (deprecated_serial_fd (es1800_desc), inputbuf, inputcnt);
- if (cc != -1)
- {
- for (i = 0; i < cc;)
- {
- consolebuf[consolecnt++] = inputbuf[i++];
- }
- if ((cc = write (console, consolebuf, consolecnt)) == -1)
- {
- perror_with_name ("FEL! write:");
- }
- consolecnt -= cc;
- if (consolecnt && cc)
- {
- for (i = 0; i < consolecnt; i++)
- {
- consolebuf[i] = consolebuf[cc + i];
- }
- }
- }
- else if (errno != EWOULDBLOCK)
- {
- perror_with_name ("FEL! read:");
- }
- }
-
- console_fc_save = console_fc_save & !FNDELAY;
- if (fcntl (console, F_SETFL, console_fc_save) == -1)
- {
- perror_with_name ("FEL! fcntl");
- }
-
- if (ioctl (console, TIOCSETP, &console_mode_save))
- {
- perror_with_name ("FEL! ioctl");
- }
-
- close (console);
-
- if (fcntl (deprecated_serial_fd (es1800_desc), F_SETFL, es1800_fc_save) == -1)
- {
- perror_with_name ("FEL! fcntl");
- }
-
- printf ("\n");
-
-}
-#endif /* PROVIDE_TRANSPARENT */
-
-static void
-es1800_init_break (char *args, int from_tty)
-{
- CORE_ADDR memaddress = 0;
- char buf[PBUFSIZ];
- char base_addr[4];
- char *space_index;
- char *p;
- int k;
-
- if (args == NULL)
- {
- error_no_arg ("a trap vector");
- }
-
- if (!(space_index = strchr (args, ' ')))
- {
- error ("Two arguments needed (trap vector and address of break routine).\n");
- }
-
- *space_index = '\0';
-
- es1800_break_vec = strtol (args, (char **) NULL, 0);
- es1800_break_address = parse_and_eval_address (space_index + 1);
-
- es1800_create_break_insn (es1800_break_insn, es1800_break_vec);
-
- if (m68020)
- {
- send_with_reply ("VBR ", buf, sizeof (buf));
- p = buf;
- for (k = 0; k < 4; k++)
- {
- if ((p[k * 2 + 1] == 0) || (p[k * 2 + 2] == 0))
- {
- error ("Emulator reply is too short: %s", buf);
- }
- base_addr[k] = (fromhex (p[k * 2 + 1]) * 16) + fromhex (p[k * 2 + 2]);
- }
- /* base addr of exception vector table */
- memaddress = *((CORE_ADDR *) base_addr);
- }
-
- memaddress += (es1800_break_vec + 32) * 4; /* address of trap vector */
-
- sprintf (buf, "@.L%lx=$%lx", memaddress, es1800_break_address);
- send_command (buf); /* set the address of the break routine in the */
- /* trap vector */
-
- sprintf (buf, "@.L%lx=$4E714E71", es1800_break_address); /* NOP; NOP */
- send_command (buf);
- sprintf (buf, "@.L%lx=$4E714E73", es1800_break_address + 4); /* NOP; RTE */
- send_command (buf);
-
- sprintf (buf, "AC2=$%lx", es1800_break_address + 4);
- /* breakpoint at es1800-break_address */
- send_command (buf);
- send_command ("WHEN AC2 THEN BRK"); /* ie in exception routine */
-
- if (from_tty)
- {
- printf ("Breakpoint (trap $%x) routine at address: %lx\n",
- es1800_break_vec, es1800_break_address);
- }
-}
-
-static void
-es1800_child_open (char *arg, int from_tty)
-{
- error ("Use the \"run\" command to start a child process.");
-}
-
-static void
-es1800_child_detach (char *args, int from_tty)
-{
- if (args)
- {
- error ("Argument given to \"detach\" when remotely debugging.");
- }
-
- pop_target ();
- if (from_tty)
- {
- printf ("Ending debugging the process %d.\n", PIDGET (inferior_ptid));
- }
-}
-
-
-/* Define the target subroutine names */
-
-struct target_ops es1800_ops;
-
-static void
-init_es1800_ops (void)
-{
- es1800_ops.to_shortname = "es1800";
- es1800_ops.to_longname = "Remote serial target in ES1800-emulator protocol";
- es1800_ops.to_doc = "Remote debugging on the es1800 emulator via a serial line.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
- es1800_ops.to_open = es1800_open;
- es1800_ops.to_close = es1800_close;
- es1800_ops.to_attach = es1800_attach;
- es1800_ops.to_detach = es1800_detach;
- es1800_ops.to_resume = es1800_resume;
- es1800_ops.to_prepare_to_store = es1800_prepare_to_store;
- es1800_ops.to_xfer_memory = es1800_xfer_inferior_memory;
- es1800_ops.to_files_info = es1800_files_info;
- es1800_ops.to_insert_breakpoint = es1800_insert_breakpoint;
- es1800_ops.to_remove_breakpoint = es1800_remove_breakpoint;
- es1800_ops.to_load = es1800_load;
- es1800_ops.to_create_inferior = es1800_create_inferior;
- es1800_ops.to_stratum = core_stratum;
- es1800_ops.to_has_memory = 1;
- es1800_ops.to_magic = OPS_MAGIC;
-}
-
-/* Define the target subroutine names */
-
-struct target_ops es1800_child_ops;
-
-static void
-init_es1800_child_ops (void)
-{
- es1800_child_ops.to_shortname = "es1800_process";
- es1800_child_ops.to_longname = "Remote serial target in ES1800-emulator protocol";
- es1800_child_ops.to_doc = "Remote debugging on the es1800 emulator via a serial line.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
- es1800_child_ops.to_open = es1800_child_open;
- es1800_child_ops.to_attach = es1800_attach;
- es1800_child_ops.to_detach = es1800_child_detach;
- es1800_child_ops.to_resume = es1800_resume;
- es1800_child_ops.to_wait = es1800_wait;
- es1800_child_ops.to_fetch_registers = es1800_fetch_register;
- es1800_child_ops.to_store_registers = es1800_store_register;
- es1800_child_ops.to_prepare_to_store = es1800_prepare_to_store;
- es1800_child_ops.to_xfer_memory = es1800_xfer_inferior_memory;
- es1800_child_ops.to_files_info = es1800_files_info;
- es1800_child_ops.to_insert_breakpoint = es1800_insert_breakpoint;
- es1800_child_ops.to_remove_breakpoint = es1800_remove_breakpoint;
- es1800_child_ops.to_kill = es1800_kill;
- es1800_child_ops.to_load = es1800_load;
- es1800_child_ops.to_create_inferior = es1800_create_inferior;
- es1800_child_ops.to_mourn_inferior = es1800_mourn_inferior;
- es1800_child_ops.to_stratum = process_stratum;
- es1800_child_ops.to_has_all_memory = 1;
- es1800_child_ops.to_has_memory = 1;
- es1800_child_ops.to_has_stack = 1;
- es1800_child_ops.to_has_registers = 1;
- es1800_child_ops.to_has_execution = 1;
- es1800_child_ops.to_magic = OPS_MAGIC;
-}
-
-void
-_initialize_es1800 (void)
-{
- init_es1800_ops ();
- init_es1800_child_ops ();
- add_target (&es1800_ops);
- add_target (&es1800_child_ops);
-#ifdef PROVIDE_TRANSPARENT
- add_com ("transparent", class_support, es1800_transparent,
- "Start transparent communication with the ES 1800 emulator.");
-#endif /* PROVIDE_TRANSPARENT */
- add_com ("init_break", class_support, es1800_init_break,
- "Download break routine and initialize break facility on ES 1800");
-}
Index: config/djgpp/fnchange.lst
===================================================================
RCS file: /cvs/src/src/gdb/config/djgpp/fnchange.lst,v
retrieving revision 1.43
diff -u -r1.43 fnchange.lst
--- config/djgpp/fnchange.lst 17 Jan 2003 16:56:52 -0000 1.43
+++ config/djgpp/fnchange.lst 29 Jan 2003 20:49:33 -0000
@@ -172,7 +172,6 @@
@V@/gdb/remote-array.c @V@/gdb/rmt-array.c
@V@/gdb/remote-e7000.c @V@/gdb/rmt-e7000.c
@V@/gdb/remote-eb.c @V@/gdb/rmt-eb.c
-@V@/gdb/remote-es.c @V@/gdb/rmt-es.c
@V@/gdb/remote-est.c @V@/gdb/rmt-est.c
@V@/gdb/remote-mips.c @V@/gdb/emt-mips.c
@V@/gdb/remote-mm.c @V@/gdb/emt-mm.c
Index: config/m68k/es1800.mt
===================================================================
RCS file: config/m68k/es1800.mt
diff -N config/m68k/es1800.mt
--- config/m68k/es1800.mt 16 Apr 1999 01:34:21 -0000 1.1.1.1
+++ /dev/null 1 Jan 1970 00:00:00 -0000
@@ -1,9 +0,0 @@
-# Target: Ericsson ES-1800 emulator (remote) for m68k.
-
-# remote-es.o should perhaps be part of the standard monitor.mt
-# configuration, if it is desirable to reduce the number of different
-# configurations. However, before that happens remote-es.c has to be
-# fixed to compile on a DOS host.
-
-TDEPFILES= m68k-tdep.o remote-es.o
-TM_FILE= tm-es1800.h
Index: doc/gdb.texinfo
===================================================================
RCS file: /cvs/src/src/gdb/doc/gdb.texinfo,v
retrieving revision 1.143
diff -u -r1.143 gdb.texinfo
--- doc/gdb.texinfo 29 Jan 2003 16:10:53 -0000 1.143
+++ doc/gdb.texinfo 29 Jan 2003 20:49:43 -0000
@@ -11831,19 +11831,6 @@
@end table
-If @value{GDBN} is configured with @code{m68*-ericsson-*}, it will
-instead have only a single special target command:
-
-@table @code
-
-@kindex target es1800
-@item target es1800 @var{dev}
-ES-1800 emulator for M68K.
-
-@end table
-
-[context?]
-
@table @code
@kindex target rombug
^ permalink raw reply [flat|nested] 5+ messages in thread* Re: [patch/rfc] Eliminate the es1800 target
2003-01-29 20:54 ` Andrew Cagney
@ 2003-01-30 7:56 ` Eli Zaretskii
2003-01-31 16:32 ` Andrew Cagney
1 sibling, 0 replies; 5+ messages in thread
From: Eli Zaretskii @ 2003-01-30 7:56 UTC (permalink / raw)
To: Andrew Cagney; +Cc: Daniel Jacobowitz, gdb-patches
On Wed, 29 Jan 2003, Andrew Cagney wrote:
> > On Wed, Jan 29, 2003 at 03:32:23PM -0500, Andrew Cagney wrote:
> >
> >> Hello,
> >>
> >> This code/target pre-dates the old Cygnus CVS repository (~89). Given
> >> that I really don't believe that one of these beasties still exists, I'm
> >> thinking of just removing it. (I tried and it doesn't compile).
> >>
> >> Anyone object?
The manual patch is approved.
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [patch/rfc] Eliminate the es1800 target
2003-01-29 20:54 ` Andrew Cagney
2003-01-30 7:56 ` Eli Zaretskii
@ 2003-01-31 16:32 ` Andrew Cagney
1 sibling, 0 replies; 5+ messages in thread
From: Andrew Cagney @ 2003-01-31 16:32 UTC (permalink / raw)
To: Andrew Cagney; +Cc: Daniel Jacobowitz, gdb-patches, Eli Zaretskii
I've checked this in.
Andrew
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2003-01-31 16:32 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2003-01-29 20:32 [patch/rfc] Eliminate the es1800 target Andrew Cagney
2003-01-29 20:37 ` Daniel Jacobowitz
2003-01-29 20:54 ` Andrew Cagney
2003-01-30 7:56 ` Eli Zaretskii
2003-01-31 16:32 ` Andrew Cagney
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox