2009-03-16 Jeff Johnston <jjohnstn@redhat.com>

        * m32r/m32r-stub.c: Replace with one from newer version of gdb.

1 files changed, 852 insertions, 822 deletions

diff --git a/libgloss/m32r/m32r-stub.c b/libgloss/m32r/m32r-stub.c
index 9fdf4969e..4d54f72d6 100644
--- a/libgloss/m32r/m32r-stub.c
+++ b/libgloss/m32r/m32r-stub.c
@@ -96,9 +96,9 @@
  *
  * 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   */
+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
@@ -106,53 +106,57 @@ extern void exceptionHandler();	/* assign an exception handler   */
  */
 #define BUFMAX 400
 
-static char initialized;  /* boolean flag. != 0 means we've been initialized */
+static char initialized;	/* boolean flag. != 0 means we've been initialized */
 
-int     remote_debug;
+int remote_debug;
 /*  debug >  0 prints ill-formed commands in valid packets & checksum errors */
 
-static const unsigned char hexchars[]="0123456789abcdef";
+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 };
+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 int remcomStack[STACKSIZE / sizeof (int)];
+static int *stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
 
 static unsigned int save_vectors[18];	/* previous exception vectors */
 
@@ -164,383 +168,387 @@ static volatile int mem_err = 0;
 int gdb_m32r_vector = -1;
 
 #if 0
-#include "syscall.h" /* for SYS_exit, SYS_write etc. */
+#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);
+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 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 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 *);
+static int strlen (const unsigned char *);
 
 /*
  * This function does all command procesing for interfacing to gdb.
  */
 
-void 
-handle_exception(int exceptionVector)
+void
+handle_exception (int exceptionVector)
 {
-  int    sigval, stepping;
-  int    addr, length, i;
-  unsigned char * ptr;
-  unsigned char   buf[16];
+  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 */
+  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);
+      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 );
+  sigval = computeSignal (exceptionVector);
 
   ptr = remcomOutBuffer;
- 
-  *ptr++ = 'T';         /* notify gdb with signo, PC, FP and SP */
+
+  *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 = 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 = 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 = mem2hex ((unsigned char *) &registers[R15], ptr, 4, 0);	/* SP */
   *ptr++ = ';';
   *ptr++ = 0;
- 
-  if (exceptionVector == 0)     /* simulated SYS call stuff */
+
+  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;
-      }
+      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);
+  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 */
+  while (1 == 1)
+    {
+      remcomOutBuffer[0] = 0;
+      ptr = getpacket ();
+      binary = 0;
+      switch (*ptr++)
 	{
-	  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");
+	default:		/* Unknown code.  Return an empty reply message. */
 	  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 */
+	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 (!prepare_to_step(0))	/* set up for single-step */
+	    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)
 	      {
-		/* 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;	
+		strcpy (remcomOutBuffer, "E02");
 	      }
 	  }
-	else	/* continuing, not single-stepping */
+	  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 */
 	  {
-	    /* 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);
+	    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;
+	  return;
 
-      case 'D':	/* Detach */
+	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 */
+	  /* 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;
+	  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))
+	case 'q':
+	  if (*ptr++ == 'C' &&
+	      *ptr++ == 'R' && *ptr++ == 'C' && *ptr++ == ':')
 	    {
-	      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);
-  }
+	      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_table[256] = { 0, 0 };
 
 static unsigned long
-crc32 (buf, len, crc)
-     unsigned char *buf;
-     int len;
-     unsigned long crc;
+crc32 (unsigned char *buf, int len, unsigned long crc)
 {
-  if (! crc32_table[1])
+  if (!crc32_table[1])
     {
       /* Initialize the CRC table and the decoding table. */
       int i, j;
@@ -562,20 +570,22 @@ crc32 (buf, len, crc)
   return crc;
 }
 
-static int 
-hex(ch)
-     unsigned char ch;
+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);
+  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 ()
+getpacket (void)
 {
   unsigned char *buffer = &remcomInBuffer[0];
   unsigned char checksum;
@@ -589,16 +599,16 @@ getpacket ()
       while ((ch = getDebugChar ()) != '$')
 	;
 
-retry:
+    retry:
       checksum = 0;
       xmitcsum = -1;
       count = 0;
 
       /* now, read until a # or end of buffer is found */
-      while (count < BUFMAX)
+      while (count < BUFMAX - 1)
 	{
 	  ch = getDebugChar ();
-          if (ch == '$')
+	  if (ch == '$')
 	    goto retry;
 	  if (ch == '#')
 	    break;
@@ -621,11 +631,11 @@ retry:
 		{
 		  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); 
+		  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 */
 	    }
@@ -650,37 +660,39 @@ retry:
 
 /* send the packet in buffer.  */
 
-static void 
-putpacket(buffer)
-     unsigned char *buffer;
+static void
+putpacket (unsigned char *buffer)
 {
   unsigned char checksum;
-  int  count;
+  int count;
   char ch;
 
   /*  $<packet info>#<checksum>. */
-  do {
-    putDebugChar('$');
-    checksum = 0;
-    count    = 0;
-
-    while (ch=buffer[count]) {
-      putDebugChar(ch);
-      checksum += ch;
-      count += 1;
+  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]);
     }
-    putDebugChar('#');
-    putDebugChar(hexchars[checksum >> 4]);
-    putDebugChar(hexchars[checksum % 16]);
-  } while (getDebugChar() != '+');
+  while (getDebugChar () != '+');
 }
 
 /* Address of a routine to RTE to if we get a memory fault.  */
 
-static void (*volatile mem_fault_routine)() = 0;
+static void (*volatile mem_fault_routine) () = 0;
 
 static void
-set_mem_err ()
+set_mem_err (void)
 {
   mem_err = 1;
 }
@@ -691,18 +703,21 @@ set_mem_err ()
    whether there's anything connected to the expansion bus. */
 
 static int
-mem_safe (addr)
-     unsigned char *addr;
+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 */
+  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
@@ -710,11 +725,10 @@ mem_safe (addr)
    to mem_fault, they won't get restored, so there better not be any
    saved).  */
 static int
-get_char (addr)
-     unsigned char *addr;
+get_char (unsigned char *addr)
 {
 #if 1
-  if (mem_fault_routine && !mem_safe(addr))
+  if (mem_fault_routine && !mem_safe (addr))
     {
       mem_fault_routine ();
       return 0;
@@ -724,9 +738,7 @@ get_char (addr)
 }
 
 static void
-set_char (addr, val)
-     unsigned char *addr;
-     unsigned char val;
+set_char (unsigned char *addr, unsigned char val)
 {
 #if 1
   if (mem_fault_routine && !mem_safe (addr))
@@ -744,55 +756,49 @@ set_char (addr, val)
    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;
+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];
-  }
+  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);
+  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;
+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);
-  }
+  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);
+  return (mem);
 }
 
 /* Convert the binary stream in BUF to memory.
@@ -801,11 +807,7 @@ hex2mem(buf, mem, count, may_fault)
    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;
+bin2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault)
 {
   int i;
   unsigned char ch;
@@ -817,25 +819,25 @@ bin2mem (buf, mem, count, may_fault)
       /* 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;
-            }
-        }
+	{
+	  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;
+	return mem;
     }
 
   if (may_fault)
@@ -846,32 +848,70 @@ bin2mem (buf, mem, count, may_fault)
 /* 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;
+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"        */
-  }
+  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);
 }
 
@@ -879,10 +919,8 @@ computeSignal(exceptionVector)
 /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
 /* RETURN NUMBER OF CHARS PROCESSED           */
 /**********************************************/
-static int 
-hexToInt(ptr, intValue)
-     unsigned char **ptr;
-     int *intValue;
+static int
+hexToInt (unsigned char **ptr, int *intValue)
 {
   int numChars = 0;
   int hexValue;
@@ -890,12 +928,12 @@ hexToInt(ptr, intValue)
   *intValue = 0;
   while (**ptr)
     {
-      hexValue = hex(**ptr);
-      if (hexValue >=0)
-        {
-	  *intValue = (*intValue <<4) | hexValue;
-	  numChars ++;
-        }
+      hexValue = hex (**ptr);
+      if (hexValue >= 0)
+	{
+	  *intValue = (*intValue << 4) | hexValue;
+	  numChars++;
+	}
       else
 	break;
       (*ptr)++;
@@ -927,40 +965,38 @@ hexToInt(ptr, intValue)
   FCxxxxxx	BC	branch condition (long)
   */
 
-static int 
-isShortBranch(instr)
-     unsigned char *instr;
+static int
+isShortBranch (unsigned char *instr)
 {
-  unsigned char instr0 = instr[0] & 0x7F;		/* mask off high bit */
+  unsigned char instr0 = instr[0] & 0x7F;	/* mask off high bit */
 
   if (instr0 == 0x10 && instr[1] == 0xB6)	/* RTE */
-    return 1;		/* return from trap or exception */
+    return 1;			/* return from trap or exception */
 
-  if (instr0 == 0x1E || instr0 == 0x1F)		/* JL or JMP */
+  if (instr0 == 0x1E || instr0 == 0x1F)	/* JL or JMP */
     if ((instr[1] & 0xF0) == 0xC0)
-      return 2;					/* jump thru a register */
+      return 2;			/* jump thru a register */
 
-  if (instr0 == 0x7C || instr0 == 0x7D || 	/* BC, BNC, BL, BRA */
+  if (instr0 == 0x7C || instr0 == 0x7D ||	/* BC, BNC, BL, BRA */
       instr0 == 0x7E || instr0 == 0x7F)
-    return 3;					/* eight bit PC offset */
+    return 3;			/* eight bit PC offset */
 
   return 0;
 }
 
 static int
-isLongBranch(instr)
-     unsigned char *instr;
+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[0] & 0xF0) == 0xB0)	/* 16 bit relative */
     {
-      if ((instr[1] & 0xF0) == 0x00 || 		/* BNE, BEQ */
+      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 || 
+	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;
@@ -975,27 +1011,28 @@ isLongBranch(instr)
     ((((int) addr & 2) || (((unsigned char *) addr)[0] & 0x80) == 0) ? 2 : 4)
 
 static int
-isBranch(instr)
-     unsigned char *instr;
+isBranch (unsigned char *instr)
 {
-  if (INSTRUCTION_SIZE(instr) == 2)
-    return isShortBranch(instr);
+  if (INSTRUCTION_SIZE (instr) == 2)
+    return isShortBranch (instr);
   else
-    return isLongBranch(instr);
+    return isLongBranch (instr);
 }
 
 static int
-willBranch(instr, branchCode)
-     unsigned char *instr;
+willBranch (unsigned char *instr, int branchCode)
 {
-  switch (branchCode) 
+  switch (branchCode)
     {
-    case 0:	return 0;	/* not a branch */
-    case 1:	return 1;	/* RTE */
-    case 2:	return 1;	/* JL or JMP    */
+    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) 
+      switch (instr[0] & 0x0F)
 	{
 	case 0xC:		/* Branch if Condition Register */
 	  return (registers[CBR] != 0);
@@ -1007,8 +1044,8 @@ willBranch(instr, branchCode)
 	default:		/* oops? */
 	  return 0;
 	}
-    case 5: 			/* BNE, BEQ */
-      switch (instr[1] & 0xF0) 
+    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]);
@@ -1017,8 +1054,8 @@ willBranch(instr, branchCode)
 	default:		/* oops? */
 	  return 0;
 	}
-    case 6: 			/* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ */
-      switch (instr[1] & 0xF0) 
+    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);
@@ -1040,27 +1077,28 @@ willBranch(instr, branchCode)
     }
 }
 
-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)); 
-  }
+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.
@@ -1073,9 +1111,7 @@ branchDestination(instr, branchCode)
 }
 
 static void
-branchSideEffects(instr, branchCode)
-     unsigned char *instr;
-     int branchCode;
+branchSideEffects (unsigned char *instr, int branchCode)
 {
   switch (branchCode)
     {
@@ -1084,7 +1120,7 @@ branchSideEffects(instr, branchCode)
     case 2:			/* JL (or JMP) */
     case 3:			/* BL (or BC, BNC, BRA) */
     case 4:
-      if ((instr[0] & 0x0F) == 0x0E)		/* branch/jump and link */
+      if ((instr[0] & 0x0F) == 0x0E)	/* branch/jump and link */
 	registers[R14] = (registers[PC] & ~3) + 4;
       return;
     default:			/* any other branch has no side effects */
@@ -1092,13 +1128,14 @@ branchSideEffects(instr, branchCode)
     }
 }
 
-static struct STEPPING_CONTEXT {
+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 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 */
@@ -1116,51 +1153,50 @@ static struct STEPPING_CONTEXT {
 	    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 */
+#define TRAP1  0x10f1;		/* trap #1 instruction */
+#define NOOP   0x7000;		/* noop    instruction */
 
 static unsigned short trap1 = TRAP1;
-static unsigned short noop  = NOOP;
+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) */
+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);
+  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 < ((unsigned char *) &stepping) + sizeof (stepping); p++)
     *p = 0;
 
-  if (branchCode != 0)			/* next instruction is a branch */
+  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);
+      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);
+	registers[PC] = pc + INSTRUCTION_SIZE (pc);
       return 0;			/* branch "executed" -- just notify GDB */
     }
-  else if (((int) pc & 2) != 0)		/* "second-slot" instruction */
+  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;
+      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_addr = pc + 2;
       stepping.trap1_save = *(unsigned short *) stepping.trap1_addr;
       *(unsigned short *) stepping.trap1_addr = trap1;
     }
-  else					/* "first-slot" instruction */
+  else				/* "first-slot" instruction */
     {
       /* insert trap  after  pc */
-      stepping.trap1_addr = pc + INSTRUCTION_SIZE(pc);	
+      stepping.trap1_addr = pc + INSTRUCTION_SIZE (pc);
       stepping.trap1_save = *(unsigned short *) stepping.trap1_addr;
       *(unsigned short *) stepping.trap1_addr = trap1;
     }
@@ -1169,7 +1205,7 @@ prepare_to_step(continue_p)
      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 */
+  stepping.stepping = 1;	/* starting a single-step */
   return 1;
 }
 
@@ -1185,7 +1221,7 @@ prepare_to_step(continue_p)
 	    just "continue continuing".  */
 
 static int
-finish_from_step()
+finish_from_step (void)
 {
   if (stepping.stepping)	/* anything to do? */
     {
@@ -1193,33 +1229,33 @@ finish_from_step()
       unsigned char *p;
 
       if (stepping.noop_addr)	/* replace instr "under" our no-op */
-	*(unsigned short *) stepping.noop_addr  = stepping.noop_save;
+	*(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    */
+      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 < ((unsigned char *) &stepping) + sizeof (stepping); p++)
 	*p = 0;
 
       return !(continue_p);
     }
-  else 	/* we didn't single-step, therefore this must be a legitimate stop */
+  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;
+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.
@@ -1227,47 +1263,47 @@ struct PSWreg {		/* separate out the bit flags in the PSW register */
    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
+asm ("\n\
+stash_registers:\n\
+	push r0\n\
+	push r1\n\
+	seth r1, #shigh(registers)\n\
+	add3 r1, r1, #low(registers)\n\
+	pop r0		; r1\n\
+	st r0, @(4,r1)\n\
+	pop r0		; r0\n\
+	st r0, @r1\n\
+	addi r1, #4	; only add 4 as subsequent saves are `pre inc'\n\
+	st r2, @+r1\n\
+	st r3, @+r1\n\
+	st r4, @+r1\n\
+	st r5, @+r1\n\
+	st r6, @+r1\n\
+	st r7, @+r1\n\
+	st r8, @+r1\n\
+	st r9, @+r1\n\
+	st r10, @+r1\n\
+	st r11, @+r1\n\
+	st r12, @+r1\n\
+	st r13, @+r1    ; fp\n\
+	pop r0		; lr (r14)\n\
+	st r0, @+r1\n\
+	st sp, @+r1	; sp contains right value at this point\n\
+	mvfc r0, cr0\n\
+	st r0, @+r1	; cr0 == PSW\n\
+	mvfc r0, cr1\n\
+	st r0, @+r1	; cr1 == CBR\n\
+	mvfc r0, cr2\n\
+	st r0, @+r1	; cr2 == SPI\n\
+	mvfc r0, cr3\n\
+	st r0, @+r1	; cr3 == SPU\n\
+	mvfc r0, cr6\n\
+	st r0, @+r1	; cr6 == BPC\n\
+	st r0, @+r1	; PC  == BPC\n\
+	mvfaclo r0\n\
+	st r0, @+r1	; ACCL\n\
+	mvfachi r0\n\
+	st r0, @+r1	; ACCH\n\
 	jmp lr");
 
 /* C routine to clean up what stash_registers did.
@@ -1276,17 +1312,17 @@ stash_registers:
    but doing stash_registers in C isn't straightforward.  */
 
 static void
-cleanup_stash ()
+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 */
+  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.  */
+#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
 
@@ -1301,267 +1337,265 @@ cleanup_stash ()
     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
+asm ("\n\
+restore_and_return:\n\
+	seth r0, #shigh(registers+8)\n\
+	add3 r0, r0, #low(registers+8)\n\
+	ld r2, @r0+	; restore r2\n\
+	ld r3, @r0+	; restore r3\n\
+	ld r4, @r0+	; restore r4\n\
+	ld r5, @r0+	; restore r5\n\
+	ld r6, @r0+	; restore r6\n\
+	ld r7, @r0+	; restore r7\n\
+	ld r8, @r0+	; restore r8\n\
+	ld r9, @r0+	; restore r9\n\
+	ld r10, @r0+	; restore r10\n\
+	ld r11, @r0+	; restore r11\n\
+	ld r12, @r0+	; restore r12\n\
+	ld r13, @r0+	; restore r13\n\
+	ld r14, @r0+	; restore r14\n\
+	ld r15, @r0+	; restore r15\n\
+	ld r1, @r0+	; restore cr0 == PSW\n\
+	mvtc r1, cr0\n\
+	ld r1, @r0+	; restore cr1 == CBR (no-op, because it's read only)\n\
+	mvtc r1, cr1\n\
+	ld r1, @r0+	; restore cr2 == SPI\n\
+	mvtc r1, cr2\n\
+	ld r1, @r0+	; restore cr3 == SPU\n\
+	mvtc r1, cr3\n\
+	addi r0, #4	; skip BPC\n\
+	ld r1, @r0+	; restore cr6 (BPC) == PC\n\
+	mvtc r1, cr6\n\
+	ld r1, @r0+	; restore ACCL\n\
+	mvtaclo r1\n\
+	ld r1, @r0+	; restore ACCH\n\
+	mvtachi r1\n\
+	seth r0, #shigh(registers)\n\
+	add3 r0, r0, #low(registers)\n\
+	ld r1, @(4,r0)	; restore r1\n\
+	ld r0, @r0	; restore r0\n\
 	rte");
 
 /* General trap handler, called after the registers have been stashed.
    NUM is the trap/exception number.  */
 
 static void
-process_exception (num)
-     int num;
+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");
+  asm volatile ("\n\
+	seth r1, #shigh(stackPtr)\n\
+	add3 r1, r1, #low(stackPtr)\n\
+	ld r15, @r1		; setup local stack (protect user stack)\n\
+	mv r0, %0\n\
+	bl handle_exception\n\
+	bl restore_and_return"::"r" (num):"r0", "r1");
 }
 
 void _catchException0 ();
 
-asm ("
-_catchException0:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #0
+asm ("\n\
+_catchException0:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #0\n\
 	bl process_exception");
 
 void _catchException1 ();
 
-asm ("
-_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
+asm ("\n\
+_catchException1:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	bl cleanup_stash\n\
+	seth r1, #shigh(stackPtr)\n\
+	add3 r1, r1, #low(stackPtr)\n\
+	ld r15, @r1		; setup local stack (protect user stack)\n\
+	seth r1, #shigh(registers + 21*4) ; PC\n\
+	add3 r1, r1, #low(registers + 21*4)\n\
+	ld r0, @r1\n\
+	addi r0, #-4		; back up PC for breakpoint trap.\n\
+	st r0, @r1		; FIXME: what about bp in right slot?\n\
+	ldi r0, #1\n\
+	bl handle_exception\n\
 	bl restore_and_return");
 
 void _catchException2 ();
 
-asm ("
-_catchException2:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #2
+asm ("\n\
+_catchException2:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #2\n\
 	bl process_exception");
 
 void _catchException3 ();
 
-asm ("
-_catchException3:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #3
+asm ("\n\
+_catchException3:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #3\n\
 	bl process_exception");
 
 void _catchException4 ();
 
-asm ("
-_catchException4:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #4
+asm ("\n\
+_catchException4:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #4\n\
 	bl process_exception");
 
 void _catchException5 ();
 
-asm ("
-_catchException5:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #5
+asm ("\n\
+_catchException5:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #5\n\
 	bl process_exception");
 
 void _catchException6 ();
 
-asm ("
-_catchException6:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #6
+asm ("\n\
+_catchException6:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #6\n\
 	bl process_exception");
 
 void _catchException7 ();
 
-asm ("
-_catchException7:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #7
+asm ("\n\
+_catchException7:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #7\n\
 	bl process_exception");
 
 void _catchException8 ();
 
-asm ("
-_catchException8:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #8
+asm ("\n\
+_catchException8:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #8\n\
 	bl process_exception");
 
 void _catchException9 ();
 
-asm ("
-_catchException9:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #9
+asm ("\n\
+_catchException9:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #9\n\
 	bl process_exception");
 
 void _catchException10 ();
 
-asm ("
-_catchException10:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #10
+asm ("\n\
+_catchException10:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #10\n\
 	bl process_exception");
 
 void _catchException11 ();
 
-asm ("
-_catchException11:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #11
+asm ("\n\
+_catchException11:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #11\n\
 	bl process_exception");
 
 void _catchException12 ();
 
-asm ("
-_catchException12:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #12
+asm ("\n\
+_catchException12:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #12\n\
 	bl process_exception");
 
 void _catchException13 ();
 
-asm ("
-_catchException13:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #13
+asm ("\n\
+_catchException13:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #13\n\
 	bl process_exception");
 
 void _catchException14 ();
 
-asm ("
-_catchException14:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #14
+asm ("\n\
+_catchException14:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #14\n\
 	bl process_exception");
 
 void _catchException15 ();
 
-asm ("
-_catchException15:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #15
+asm ("\n\
+_catchException15:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #15\n\
 	bl process_exception");
 
 void _catchException16 ();
 
-asm ("
-_catchException16:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #16
+asm ("\n\
+_catchException16:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #16\n\
 	bl process_exception");
 
 void _catchException17 ();
 
-asm ("
-_catchException17:
-	push lr
-	bl stash_registers
-	; Note that at this point the pushed value of `lr' has been popped
-	ldi r0, #17
+asm ("\n\
+_catchException17:\n\
+	push lr\n\
+	bl stash_registers\n\
+	; Note that at this point the pushed value of `lr' has been popped\n\
+	ldi r0, #17\n\
 	bl process_exception");
 
 
 /* this function is used to set up exception handlers for tracing and
    breakpoints */
-void 
-set_debug_traps()
+void
+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 */
+  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];
+  stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
 
   exceptionHandler (0, _catchException0);
   exceptionHandler (1, _catchException1);
@@ -1592,11 +1626,11 @@ set_debug_traps()
 
 #define BREAKPOINT() asm volatile ("	trap #2");
 
-void 
-breakpoint()
+void
+breakpoint (void)
 {
   if (initialized)
-    BREAKPOINT();
+    BREAKPOINT ();
 }
 
 /* STDOUT section:
@@ -1606,51 +1640,47 @@ breakpoint()
               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;
+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);
+  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;
+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++)
+      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);
+      putpacket (buf);
     }
   return len;
 }
@@ -1658,42 +1688,39 @@ gdb_write(data, 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;
+gdb_puts (char *str)
 {
-  return gdb_write(str, strlen(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;
+gdb_error (char *format, char *parm)
 {
   char buf[400], *cpy;
   int len;
- 
+
   if (remote_debug)
     {
       if (format && *format)
-	len = strlen(format);
+	len = strlen (format);
       else
-	return;             /* empty input */
+	return;			/* empty input */
 
       if (parm && *parm)
-	len += strlen(parm);
- 
-      for (cpy = buf; *format; )
+	len += strlen (parm);
+
+      for (cpy = buf; *format;)
 	{
-	  if (format[0] == '%' && format[1] == 's') /* include second string */
+	  if (format[0] == '%' && format[1] == 's')	/* include second string */
 	    {
-	      format += 2;          /* advance two chars instead of just one */
+	      format += 2;	/* advance two chars instead of just one */
 	      while (parm && *parm)
 		*cpy++ = *parm++;
 	    }
@@ -1701,10 +1728,10 @@ gdb_error(format, parm)
 	    *cpy++ = *format++;
 	}
       *cpy = '\0';
-      gdb_puts(buf);
+      gdb_puts (buf);
     }
 }
- 
+
 static unsigned char *
 strcpy (unsigned char *dest, const unsigned char *src)
 {
@@ -1731,18 +1758,21 @@ strlen (const unsigned char *src)
 }
 
 #if 0
-void exit (code)
+void
+exit (code)
      int code;
 {
   _exit (code);
 }
 
-int atexit (void *p)
+int
+atexit (void *p)
 {
   return 0;
 }
 
-void abort (void)
+void
+abort (void)
 {
   _exit (1);
 }