2008-11-17 Jeff Johnston <jjohnstn@redhat.com>

        * m32r/Makefile.in: Add building m32r-stub.o from local copy instead
        of up and over in gdb.
        * m32r/m32r-stub.c: New file copied from gdb.

2 files changed, 1750 insertions, 3 deletions

diff --git a/libgloss/m32r/Makefile.in b/libgloss/m32r/Makefile.in
index ea9eba3d8..12a1be60e 100644
--- a/libgloss/m32r/Makefile.in
+++ b/libgloss/m32r/Makefile.in
@@ -85,9 +85,6 @@ MONSPECS = mon.specs
 
 all: $(CRT0) $(LIBGLOSS) $(MONLIBGLOSS) $(GDBLIB) $(GDBSTUB)
 
-m32r-stub.o: $(srcdir)/$(MULTISRCTOP)../../gdb/m32r-stub.c
-	$(CC) -c $(CFLAGS) -o $@ $(srcdir)/$(MULTISRCTOP)../../gdb/m32r-stub.c
-
 libgloss.a: $(LIBOBJS)
 	$(AR) $(ARFLAGS) $@ $(LIBOBJS)
 	$(RANLIB) $@
@@ -126,6 +123,7 @@ config.status: configure
 # to support SunOS VPATH
 crt0.o: crt0.S
 m32r-lib.o: m32r-lib.c
+m32r-stub.o: m32r-stub.c
 chmod.o: chmod.c
 close.o: close.c
 exit.o: exit.c
diff --git a/libgloss/m32r/m32r-stub.c b/libgloss/m32r/m32r-stub.c
new file mode 100644
index 000000000..9fdf4969e
--- /dev/null
+++ b/libgloss/m32r/m32r-stub.c
@@ -0,0 +1,1749 @@
+/****************************************************************************
+
+		THIS SOFTWARE IS NOT COPYRIGHTED
+
+   HP offers the following for use in the public domain.  HP makes no
+   warranty with regard to the software or it's performance and the
+   user accepts the software "AS IS" with all faults.
+
+   HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
+   TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+****************************************************************************/
+
+/****************************************************************************
+ *  Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
+ *
+ *  Module name: remcom.c $
+ *  Revision: 1.34 $
+ *  Date: 91/03/09 12:29:49 $
+ *  Contributor:     Lake Stevens Instrument Division$
+ *
+ *  Description:     low level support for gdb debugger. $
+ *
+ *  Considerations:  only works on target hardware $
+ *
+ *  Written by:      Glenn Engel $
+ *  ModuleState:     Experimental $
+ *
+ *  NOTES:           See Below $
+ *
+ *  Modified for M32R by Michael Snyder, Cygnus Support.
+ *
+ *  To enable debugger support, two things need to happen.  One, a
+ *  call to set_debug_traps() is necessary in order to allow any breakpoints
+ *  or error conditions to be properly intercepted and reported to gdb.
+ *  Two, a breakpoint needs to be generated to begin communication.  This
+ *  is most easily accomplished by a call to breakpoint().  Breakpoint()
+ *  simulates a breakpoint by executing a trap #1.
+ *
+ *  The external function exceptionHandler() is
+ *  used to attach a specific handler to a specific M32R vector number.
+ *  It should use the same privilege level it runs at.  It should
+ *  install it as an interrupt gate so that interrupts are masked
+ *  while the handler runs.
+ *
+ *  Because gdb will sometimes write to the stack area to execute function
+ *  calls, this program cannot rely on using the supervisor stack so it
+ *  uses it's own stack area reserved in the int array remcomStack.
+ *
+ *************
+ *
+ *    The following gdb commands are supported:
+ *
+ * command          function                               Return value
+ *
+ *    g             return the value of the CPU registers  hex data or ENN
+ *    G             set the value of the CPU registers     OK or ENN
+ *
+ *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
+ *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
+ *    XAA..AA,LLLL: Write LLLL binary bytes at address     OK or ENN
+ *                  AA..AA
+ *
+ *    c             Resume at current address              SNN   ( signal NN)
+ *    cAA..AA       Continue at address AA..AA             SNN
+ *
+ *    s             Step one instruction                   SNN
+ *    sAA..AA       Step one instruction from AA..AA       SNN
+ *
+ *    k             kill
+ *
+ *    ?             What was the last sigval ?             SNN   (signal NN)
+ *
+ * All commands and responses are sent with a packet which includes a
+ * checksum.  A packet consists of
+ *
+ * $<packet info>#<checksum>.
+ *
+ * where
+ * <packet info> :: <characters representing the command or response>
+ * <checksum>    :: <two hex digits computed as modulo 256 sum of <packetinfo>>
+ *
+ * When a packet is received, it is first acknowledged with either '+' or '-'.
+ * '+' indicates a successful transfer.  '-' indicates a failed transfer.
+ *
+ * Example:
+ *
+ * Host:                  Reply:
+ * $m0,10#2a               +$00010203040506070809101112131415#42
+ *
+ ****************************************************************************/
+
+
+/************************************************************************
+ *
+ * external low-level support routines
+ */
+extern void putDebugChar();	/* write a single character      */
+extern int getDebugChar();	/* read and return a single char */
+extern void exceptionHandler();	/* assign an exception handler   */
+
+/*****************************************************************************
+ * BUFMAX defines the maximum number of characters in inbound/outbound buffers
+ * at least NUMREGBYTES*2 are needed for register packets 
+ */
+#define BUFMAX 400
+
+static char initialized;  /* boolean flag. != 0 means we've been initialized */
+
+int     remote_debug;
+/*  debug >  0 prints ill-formed commands in valid packets & checksum errors */
+
+static const unsigned char hexchars[]="0123456789abcdef";
+
+#define NUMREGS 24
+
+/* Number of bytes of registers.  */
+#define NUMREGBYTES (NUMREGS * 4)
+enum regnames { R0,  R1,  R2,  R3,  R4,  R5,  R6,   R7,
+		R8,  R9,  R10, R11, R12, R13, R14,  R15,
+		PSW, CBR, SPI, SPU, BPC, PC,  ACCL, ACCH };
+
+enum SYS_calls {
+  	SYS_null, 
+	SYS_exit,
+	SYS_open,
+	SYS_close,
+	SYS_read,
+	SYS_write,
+	SYS_lseek,
+	SYS_unlink,
+	SYS_getpid,
+	SYS_kill,
+	SYS_fstat,
+	SYS_sbrk,
+	SYS_fork,
+	SYS_execve,
+	SYS_wait4,
+	SYS_link,
+	SYS_chdir,
+	SYS_stat,
+	SYS_utime,
+	SYS_chown,
+	SYS_chmod,
+	SYS_time,
+	SYS_pipe };
+
+static int registers[NUMREGS];
+
+#define STACKSIZE 8096
+static unsigned char remcomInBuffer[BUFMAX];
+static unsigned char remcomOutBuffer[BUFMAX];
+static int  remcomStack[STACKSIZE/sizeof(int)];
+static int*  stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];
+
+static unsigned int save_vectors[18];	/* previous exception vectors */
+
+/* Indicate to caller of mem2hex or hex2mem that there has been an error. */
+static volatile int mem_err = 0;
+
+/* Store the vector number here (since GDB only gets the signal
+   number through the usual means, and that's not very specific).  */
+int gdb_m32r_vector = -1;
+
+#if 0
+#include "syscall.h" /* for SYS_exit, SYS_write etc. */
+#endif
+
+/* Global entry points:
+ */
+
+extern void handle_exception(int);
+extern void set_debug_traps(void);
+extern void breakpoint(void);
+
+/* Local functions:
+ */
+
+static int  computeSignal(int);
+static void putpacket(unsigned char *);
+static unsigned char *getpacket(void);
+
+static unsigned char *mem2hex(unsigned char *, unsigned char *, int, int);
+static unsigned char *hex2mem(unsigned char *, unsigned char *, int, int);
+static int  hexToInt(unsigned char **, int *);
+static unsigned char *bin2mem(unsigned char *, unsigned char *, int, int);
+static void stash_registers(void);
+static void restore_registers(void);
+static int  prepare_to_step(int);
+static int  finish_from_step(void);
+static unsigned long crc32 (unsigned char *, int, unsigned long);
+
+static void gdb_error(char *, char *);
+static int  gdb_putchar(int), gdb_puts(char *), gdb_write(char *, int);
+
+static unsigned char *strcpy (unsigned char *, const unsigned char *);
+static int   strlen (const unsigned char *);
+
+/*
+ * This function does all command procesing for interfacing to gdb.
+ */
+
+void 
+handle_exception(int exceptionVector)
+{
+  int    sigval, stepping;
+  int    addr, length, i;
+  unsigned char * ptr;
+  unsigned char   buf[16];
+  int binary;
+
+  if (!finish_from_step())
+    return;		/* "false step": let the target continue */
+
+  gdb_m32r_vector = exceptionVector;
+
+  if (remote_debug)
+    {
+      mem2hex((unsigned char *) &exceptionVector, buf, 4, 0);
+      gdb_error("Handle exception %s, ", buf);
+      mem2hex((unsigned char *) &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 (buf, len, crc)
+     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(ch)
+     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 ()
+{
+  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(buffer)
+     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 ()
+{
+  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 (addr)
+     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 (addr)
+     unsigned char *addr;
+{
+#if 1
+  if (mem_fault_routine && !mem_safe(addr))
+    {
+      mem_fault_routine ();
+      return 0;
+    }
+#endif
+  return *addr;
+}
+
+static void
+set_char (addr, val)
+     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(mem, buf, count, may_fault)
+     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(buf, mem, count, may_fault)
+     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 (buf, mem, count, may_fault)
+     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(exceptionVector)
+     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(ptr, intValue)
+     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(instr)
+     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(instr)
+     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(instr)
+     unsigned char *instr;
+{
+  if (INSTRUCTION_SIZE(instr) == 2)
+    return isShortBranch(instr);
+  else
+    return isLongBranch(instr);
+}
+
+static int
+willBranch(instr, branchCode)
+     unsigned char *instr;
+{
+  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(instr, branchCode) 
+     unsigned char *instr;
+{ 
+  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(instr, branchCode)
+     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()
+{
+  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 ()
+{
+  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
+	ld r1, @r0+	; restore cr0 == PSW
+	mvtc r1, cr0
+	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 (num)
+     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()
+{
+  /*  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()
+{
+  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(ch)
+     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(data, len)
+     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(str)
+     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(format, parm)
+     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