This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[patch/rfc] Eliminate the es1800 target


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
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 *) &registers[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 *)&registers[PC], ptr, 4, 0);     /* PC */
-  *ptr++ = ';';
- 
-  *ptr++ = hexchars[R13 >> 4];
-  *ptr++ = hexchars[R13 & 0xf];
-  *ptr++ = ':';
-  ptr = mem2hex((unsigned char *)&registers[R13], ptr, 4, 0);    /* FP */
-  *ptr++ = ';';
- 
-  *ptr++ = hexchars[R15 >> 4];
-  *ptr++ = hexchars[R15 & 0xf];
-  *ptr++ = ':';
-  ptr = mem2hex((unsigned char *)&registers[R15], ptr, 4, 0);    /* SP */
-  *ptr++ = ';';
-  *ptr++ = 0;
- 
-  if (exceptionVector == 0)     /* simulated SYS call stuff */
-    {
-      mem2hex((unsigned char *) &registers[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, &regno) && *ptr++ == '=')
-	    if (regno >= 0 && regno < NUMREGS)
-	      {
-		int stackmode;
-
-		hex2mem (ptr, (unsigned char *) &registers[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 *)&registers[PC], ptr, 4, 0);
-		*ptr++ = ';';
-
-		*ptr++ = hexchars[R13 >> 4];    /* send FP */
-		*ptr++ = hexchars[R13 & 0xf];
-		*ptr++ = ':';
-		ptr = mem2hex((unsigned char *)&registers[R13], ptr, 4, 0);
-		*ptr++ = ';';
-
-		*ptr++ = hexchars[R15 >> 4];    /* send SP */
-		*ptr++ = hexchars[R15 & 0xf];
-		*ptr++ = ':';
-		ptr = mem2hex((unsigned char *)&registers[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 *) &registers[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 *) &registers[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 *)&registers[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 *)&registers[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 *)&registers[R15], ptr, 4, 0);    /* SP */
+// OBSOLETE   *ptr++ = ';';
+// OBSOLETE   *ptr++ = 0;
+// OBSOLETE  
+// OBSOLETE   if (exceptionVector == 0)     /* simulated SYS call stuff */
+// OBSOLETE     {
+// OBSOLETE       mem2hex((unsigned char *) &registers[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, &regno) && *ptr++ == '=')
+// OBSOLETE 	    if (regno >= 0 && regno < NUMREGS)
+// OBSOLETE 	      {
+// OBSOLETE 		int stackmode;
+// OBSOLETE 
+// OBSOLETE 		hex2mem (ptr, (unsigned char *) &registers[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 *)&registers[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 *)&registers[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 *)&registers[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 *) &registers[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 ()

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]