gdb/stubs/m32r-stub.c

   1 /****************************************************************************
   2
   3                 THIS SOFTWARE IS NOT COPYRIGHTED
   4
   5    HP offers the following for use in the public domain.  HP makes no
   6    warranty with regard to the software or it's performance and the
   7    user accepts the software "AS IS" with all faults.
   8
   9    HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
  10    TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  11    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 ****************************************************************************/
  14
  15 /****************************************************************************
  16  *  Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
  17  *
  18  *  Module name: remcom.c $
  19  *  Revision: 1.34 $
  20  *  Date: 91/03/09 12:29:49 $
  21  *  Contributor:     Lake Stevens Instrument Division$
  22  *
  23  *  Description:     low level support for gdb debugger. $
  24  *
  25  *  Considerations:  only works on target hardware $
  26  *
  27  *  Written by:      Glenn Engel $
  28  *  ModuleState:     Experimental $
  29  *
  30  *  NOTES:           See Below $
  31  *
  32  *  Modified for M32R by Michael Snyder, Cygnus Support.
  33  *
  34  *  To enable debugger support, two things need to happen.  One, a
  35  *  call to set_debug_traps() is necessary in order to allow any breakpoints
  36  *  or error conditions to be properly intercepted and reported to gdb.
  37  *  Two, a breakpoint needs to be generated to begin communication.  This
  38  *  is most easily accomplished by a call to breakpoint().  Breakpoint()
  39  *  simulates a breakpoint by executing a trap #1.
  40  *
  41  *  The external function exceptionHandler() is
  42  *  used to attach a specific handler to a specific M32R vector number.
  43  *  It should use the same privilege level it runs at.  It should
  44  *  install it as an interrupt gate so that interrupts are masked
  45  *  while the handler runs.
  46  *
  47  *  Because gdb will sometimes write to the stack area to execute function
  48  *  calls, this program cannot rely on using the supervisor stack so it
  49  *  uses it's own stack area reserved in the int array remcomStack.
  50  *
  51  *************
  52  *
  53  *    The following gdb commands are supported:
  54  *
  55  * command          function                               Return value
  56  *
  57  *    g             return the value of the CPU registers  hex data or ENN
  58  *    G             set the value of the CPU registers     OK or ENN
  59  *
  60  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
  61  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
  62  *    XAA..AA,LLLL: Write LLLL binary bytes at address     OK or ENN
  63  *                  AA..AA
  64  *
  65  *    c             Resume at current address              SNN   ( signal NN)
  66  *    cAA..AA       Continue at address AA..AA             SNN
  67  *
  68  *    s             Step one instruction                   SNN
  69  *    sAA..AA       Step one instruction from AA..AA       SNN
  70  *
  71  *    k             kill
  72  *
  73  *    ?             What was the last sigval ?             SNN   (signal NN)
  74  *
  75  * All commands and responses are sent with a packet which includes a
  76  * checksum.  A packet consists of
  77  *
  78  * $<packet info>#<checksum>.
  79  *
  80  * where
  81  * <packet info> :: <characters representing the command or response>
  82  * <checksum>    :: <two hex digits computed as modulo 256 sum of <packetinfo>>
  83  *
  84  * When a packet is received, it is first acknowledged with either '+' or '-'.
  85  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
  86  *
  87  * Example:
  88  *
  89  * Host:                  Reply:
  90  * $m0,10#2a               +$00010203040506070809101112131415#42
  91  *
  92  ****************************************************************************/
  93
  94
  95 /************************************************************************
  96  *
  97  * external low-level support routines
  98  */
  99 extern void putDebugChar ();    /* write a single character      */
 100 extern int getDebugChar ();     /* read and return a single char */
 101 extern void exceptionHandler ();        /* assign an exception handler   */
 102
 103 /*****************************************************************************
 104  * BUFMAX defines the maximum number of characters in inbound/outbound buffers
 105  * at least NUMREGBYTES*2 are needed for register packets
 106  */
 107 #define BUFMAX 400
 108
 109 static char initialized;        /* boolean flag. != 0 means we've been initialized */
 110
 111 int remote_debug;
 112 /*  debug >  0 prints ill-formed commands in valid packets & checksum errors */
 113
 114 static const unsigned char hexchars[] = "0123456789abcdef";
 115
 116 #define NUMREGS 24
 117
 118 /* Number of bytes of registers.  */
 119 #define NUMREGBYTES (NUMREGS * 4)
 120 enum regnames
 121 { R0, R1, R2, R3, R4, R5, R6, R7,
 122   R8, R9, R10, R11, R12, R13, R14, R15,
 123   PSW, CBR, SPI, SPU, BPC, PC, ACCL, ACCH
 124 };
 125
 126 enum SYS_calls
 127 {
 128   SYS_null,
 129   SYS_exit,
 130   SYS_open,
 131   SYS_close,
 132   SYS_read,
 133   SYS_write,
 134   SYS_lseek,
 135   SYS_unlink,
 136   SYS_getpid,
 137   SYS_kill,
 138   SYS_fstat,
 139   SYS_sbrk,
 140   SYS_fork,
 141   SYS_execve,
 142   SYS_wait4,
 143   SYS_link,
 144   SYS_chdir,
 145   SYS_stat,
 146   SYS_utime,
 147   SYS_chown,
 148   SYS_chmod,
 149   SYS_time,
 150   SYS_pipe
 151 };
 152
 153 static int registers[NUMREGS];
 154
 155 #define STACKSIZE 8096
 156 static unsigned char remcomInBuffer[BUFMAX];
 157 static unsigned char remcomOutBuffer[BUFMAX];
 158 static int remcomStack[STACKSIZE / sizeof (int)];
 159 static int *stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
 160
 161 static unsigned int save_vectors[18];   /* previous exception vectors */
 162
 163 /* Indicate to caller of mem2hex or hex2mem that there has been an error. */
 164 static volatile int mem_err = 0;
 165
 166 /* Store the vector number here (since GDB only gets the signal
 167    number through the usual means, and that's not very specific).  */
 168 int gdb_m32r_vector = -1;
 169
 170 #if 0
 171 #include "syscall.h"            /* for SYS_exit, SYS_write etc. */
 172 #endif
 173
 174 /* Global entry points:
 175  */
 176
 177 extern void handle_exception (int);
 178 extern void set_debug_traps (void);
 179 extern void breakpoint (void);
 180
 181 /* Local functions:
 182  */
 183
 184 static int computeSignal (int);
 185 static void putpacket (unsigned char *);
 186 static unsigned char *getpacket (void);
 187
 188 static unsigned char *mem2hex (unsigned char *, unsigned char *, int, int);
 189 static unsigned char *hex2mem (unsigned char *, unsigned char *, int, int);
 190 static int hexToInt (unsigned char **, int *);
 191 static unsigned char *bin2mem (unsigned char *, unsigned char *, int, int);
 192 static void stash_registers (void);
 193 static void restore_registers (void);
 194 static int prepare_to_step (int);
 195 static int finish_from_step (void);
 196 static unsigned long crc32 (unsigned char *, int, unsigned long);
 197
 198 static void gdb_error (char *, char *);
 199 static int gdb_putchar (int), gdb_puts (char *), gdb_write (char *, int);
 200
 201 static unsigned char *strcpy (unsigned char *, const unsigned char *);
 202 static int strlen (const unsigned char *);
 203
 204 /*
 205  * This function does all command procesing for interfacing to gdb.
 206  */
 207
 208 void
 209 handle_exception (int exceptionVector)
 210 {
 211   int sigval, stepping;
 212   int addr, length, i;
 213   unsigned char *ptr;
 214   unsigned char buf[16];
 215   int binary;
 216
 217   if (!finish_from_step ())
 218     return;                     /* "false step": let the target continue */
 219
 220   gdb_m32r_vector = exceptionVector;
 221
 222   if (remote_debug)
 223     {
 224       mem2hex ((unsigned char *) &exceptionVector, buf, 4, 0);
 225       gdb_error ("Handle exception %s, ", buf);
 226       mem2hex ((unsigned char *) &registers[PC], buf, 4, 0);
 227       gdb_error ("PC == 0x%s\n", buf);
 228     }
 229
 230   /* reply to host that an exception has occurred */
 231   sigval = computeSignal (exceptionVector);
 232
 233   ptr = remcomOutBuffer;
 234
 235   *ptr++ = 'T';                 /* notify gdb with signo, PC, FP and SP */
 236   *ptr++ = hexchars[sigval >> 4];
 237   *ptr++ = hexchars[sigval & 0xf];
 238
 239   *ptr++ = hexchars[PC >> 4];
 240   *ptr++ = hexchars[PC & 0xf];
 241   *ptr++ = ':';
 242   ptr = mem2hex ((unsigned char *) &registers[PC], ptr, 4, 0);  /* PC */
 243   *ptr++ = ';';
 244
 245   *ptr++ = hexchars[R13 >> 4];
 246   *ptr++ = hexchars[R13 & 0xf];
 247   *ptr++ = ':';
 248   ptr = mem2hex ((unsigned char *) &registers[R13], ptr, 4, 0); /* FP */
 249   *ptr++ = ';';
 250
 251   *ptr++ = hexchars[R15 >> 4];
 252   *ptr++ = hexchars[R15 & 0xf];
 253   *ptr++ = ':';
 254   ptr = mem2hex ((unsigned char *) &registers[R15], ptr, 4, 0); /* SP */
 255   *ptr++ = ';';
 256   *ptr++ = 0;
 257
 258   if (exceptionVector == 0)     /* simulated SYS call stuff */
 259     {
 260       mem2hex ((unsigned char *) &registers[PC], buf, 4, 0);
 261       switch (registers[R0])
 262         {
 263         case SYS_exit:
 264           gdb_error ("Target program has exited at %s\n", buf);
 265           ptr = remcomOutBuffer;
 266           *ptr++ = 'W';
 267           sigval = registers[R1] & 0xff;
 268           *ptr++ = hexchars[sigval >> 4];
 269           *ptr++ = hexchars[sigval & 0xf];
 270           *ptr++ = 0;
 271           break;
 272         case SYS_open:
 273           gdb_error ("Target attempts SYS_open call at %s\n", buf);
 274           break;
 275         case SYS_close:
 276           gdb_error ("Target attempts SYS_close call at %s\n", buf);
 277           break;
 278         case SYS_read:
 279           gdb_error ("Target attempts SYS_read call at %s\n", buf);
 280           break;
 281         case SYS_write:
 282           if (registers[R1] == 1 ||     /* write to stdout  */
 283               registers[R1] == 2)       /* write to stderr  */
 284             {                   /* (we can do that) */
 285               registers[R0] =
 286                 gdb_write ((void *) registers[R2], registers[R3]);
 287               return;
 288             }
 289           else
 290             gdb_error ("Target attempts SYS_write call at %s\n", buf);
 291           break;
 292         case SYS_lseek:
 293           gdb_error ("Target attempts SYS_lseek call at %s\n", buf);
 294           break;
 295         case SYS_unlink:
 296           gdb_error ("Target attempts SYS_unlink call at %s\n", buf);
 297           break;
 298         case SYS_getpid:
 299           gdb_error ("Target attempts SYS_getpid call at %s\n", buf);
 300           break;
 301         case SYS_kill:
 302           gdb_error ("Target attempts SYS_kill call at %s\n", buf);
 303           break;
 304         case SYS_fstat:
 305           gdb_error ("Target attempts SYS_fstat call at %s\n", buf);
 306           break;
 307         default:
 308           gdb_error ("Target attempts unknown SYS call at %s\n", buf);
 309           break;
 310         }
 311     }
 312
 313   putpacket (remcomOutBuffer);
 314
 315   stepping = 0;
 316
 317   while (1 == 1)
 318     {
 319       remcomOutBuffer[0] = 0;
 320       ptr = getpacket ();
 321       binary = 0;
 322       switch (*ptr++)
 323         {
 324         default:                /* Unknown code.  Return an empty reply message. */
 325           break;
 326         case 'R':
 327           if (hexToInt (&ptr, &addr))
 328             registers[PC] = addr;
 329           strcpy (remcomOutBuffer, "OK");
 330           break;
 331         case '!':
 332           strcpy (remcomOutBuffer, "OK");
 333           break;
 334         case 'X':               /* XAA..AA,LLLL:<binary data>#cs */
 335           binary = 1;
 336         case 'M':               /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
 337           /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
 338           {
 339             if (hexToInt (&ptr, &addr))
 340               if (*(ptr++) == ',')
 341                 if (hexToInt (&ptr, &length))
 342                   if (*(ptr++) == ':')
 343                     {
 344                       mem_err = 0;
 345                       if (binary)
 346                         bin2mem (ptr, (unsigned char *) addr, length, 1);
 347                       else
 348                         hex2mem (ptr, (unsigned char *) addr, length, 1);
 349                       if (mem_err)
 350                         {
 351                           strcpy (remcomOutBuffer, "E03");
 352                           gdb_error ("memory fault", "");
 353                         }
 354                       else
 355                         {
 356                           strcpy (remcomOutBuffer, "OK");
 357                         }
 358                       ptr = 0;
 359                     }
 360             if (ptr)
 361               {
 362                 strcpy (remcomOutBuffer, "E02");
 363               }
 364           }
 365           break;
 366         case 'm':               /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
 367           /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
 368           if (hexToInt (&ptr, &addr))
 369             if (*(ptr++) == ',')
 370               if (hexToInt (&ptr, &length))
 371                 {
 372                   ptr = 0;
 373                   mem_err = 0;
 374                   mem2hex ((unsigned char *) addr, remcomOutBuffer, length,
 375                            1);
 376                   if (mem_err)
 377                     {
 378                       strcpy (remcomOutBuffer, "E03");
 379                       gdb_error ("memory fault", "");
 380                     }
 381                 }
 382           if (ptr)
 383             {
 384               strcpy (remcomOutBuffer, "E01");
 385             }
 386           break;
 387         case '?':
 388           remcomOutBuffer[0] = 'S';
 389           remcomOutBuffer[1] = hexchars[sigval >> 4];
 390           remcomOutBuffer[2] = hexchars[sigval % 16];
 391           remcomOutBuffer[3] = 0;
 392           break;
 393         case 'd':
 394           remote_debug = !(remote_debug);       /* toggle debug flag */
 395           break;
 396         case 'g':               /* return the value of the CPU registers */
 397           mem2hex ((unsigned char *) registers, remcomOutBuffer, NUMREGBYTES,
 398                    0);
 399           break;
 400         case 'P':               /* set the value of a single CPU register - return OK */
 401           {
 402             int regno;
 403
 404             if (hexToInt (&ptr, &regno) && *ptr++ == '=')
 405               if (regno >= 0 && regno < NUMREGS)
 406                 {
 407                   int stackmode;
 408
 409                   hex2mem (ptr, (unsigned char *) &registers[regno], 4, 0);
 410                   /*
 411                    * Since we just changed a single CPU register, let's
 412                    * make sure to keep the several stack pointers consistant.
 413                    */
 414                   stackmode = registers[PSW] & 0x80;
 415                   if (regno == R15)     /* stack pointer changed */
 416                     {           /* need to change SPI or SPU */
 417                       if (stackmode == 0)
 418                         registers[SPI] = registers[R15];
 419                       else
 420                         registers[SPU] = registers[R15];
 421                     }
 422                   else if (regno == SPU)        /* "user" stack pointer changed */
 423                     {
 424                       if (stackmode != 0)       /* stack in user mode: copy SP */
 425                         registers[R15] = registers[SPU];
 426                     }
 427                   else if (regno == SPI)        /* "interrupt" stack pointer changed */
 428                     {
 429                       if (stackmode == 0)       /* stack in interrupt mode: copy SP */
 430                         registers[R15] = registers[SPI];
 431                     }
 432                   else if (regno == PSW)        /* stack mode may have changed! */
 433                     {           /* force SP to either SPU or SPI */
 434                       if (stackmode == 0)       /* stack in user mode */
 435                         registers[R15] = registers[SPI];
 436                       else      /* stack in interrupt mode */
 437                         registers[R15] = registers[SPU];
 438                     }
 439                   strcpy (remcomOutBuffer, "OK");
 440                   break;
 441                 }
 442             strcpy (remcomOutBuffer, "E01");
 443             break;
 444           }
 445         case 'G':               /* set the value of the CPU registers - return OK */
 446           hex2mem (ptr, (unsigned char *) registers, NUMREGBYTES, 0);
 447           strcpy (remcomOutBuffer, "OK");
 448           break;
 449         case 's':               /* sAA..AA      Step one instruction from AA..AA(optional) */
 450           stepping = 1;
 451         case 'c':               /* cAA..AA      Continue from address AA..AA(optional) */
 452           /* try to read optional parameter, pc unchanged if no parm */
 453           if (hexToInt (&ptr, &addr))
 454             registers[PC] = addr;
 455
 456           if (stepping)         /* single-stepping */
 457             {
 458               if (!prepare_to_step (0)) /* set up for single-step */
 459                 {
 460                   /* prepare_to_step has already emulated the target insn:
 461                      Send SIGTRAP to gdb, don't resume the target at all.  */
 462                   ptr = remcomOutBuffer;
 463                   *ptr++ = 'T'; /* Simulate stopping with SIGTRAP */
 464                   *ptr++ = '0';
 465                   *ptr++ = '5';
 466
 467                   *ptr++ = hexchars[PC >> 4];   /* send PC */
 468                   *ptr++ = hexchars[PC & 0xf];
 469                   *ptr++ = ':';
 470                   ptr = mem2hex ((unsigned char *) &registers[PC], ptr, 4, 0);
 471                   *ptr++ = ';';
 472
 473                   *ptr++ = hexchars[R13 >> 4];  /* send FP */
 474                   *ptr++ = hexchars[R13 & 0xf];
 475                   *ptr++ = ':';
 476                   ptr =
 477                     mem2hex ((unsigned char *) &registers[R13], ptr, 4, 0);
 478                   *ptr++ = ';';
 479
 480                   *ptr++ = hexchars[R15 >> 4];  /* send SP */
 481                   *ptr++ = hexchars[R15 & 0xf];
 482                   *ptr++ = ':';
 483                   ptr =
 484                     mem2hex ((unsigned char *) &registers[R15], ptr, 4, 0);
 485                   *ptr++ = ';';
 486                   *ptr++ = 0;
 487
 488                   break;
 489                 }
 490             }
 491           else                  /* continuing, not single-stepping */
 492             {
 493               /* OK, about to do a "continue".  First check to see if the
 494                  target pc is on an odd boundary (second instruction in the
 495                  word).  If so, we must do a single-step first, because
 496                  ya can't jump or return back to an odd boundary!  */
 497               if ((registers[PC] & 2) != 0)
 498                 prepare_to_step (1);
 499             }
 500
 501           return;
 502
 503         case 'D':               /* Detach */
 504 #if 0
 505           /* I am interpreting this to mean, release the board from control
 506              by the remote stub.  To do this, I am restoring the original
 507              (or at least previous) exception vectors.
 508            */
 509           for (i = 0; i < 18; i++)
 510             exceptionHandler (i, save_vectors[i]);
 511           putpacket ("OK");
 512           return;               /* continue the inferior */
 513 #else
 514           strcpy (remcomOutBuffer, "OK");
 515           break;
 516 #endif
 517         case 'q':
 518           if (*ptr++ == 'C' &&
 519               *ptr++ == 'R' && *ptr++ == 'C' && *ptr++ == ':')
 520             {
 521               unsigned long start, len, our_crc;
 522
 523               if (hexToInt (&ptr, (int *) &start) &&
 524                   *ptr++ == ',' && hexToInt (&ptr, (int *) &len))
 525                 {
 526                   remcomOutBuffer[0] = 'C';
 527                   our_crc = crc32 ((unsigned char *) start, len, 0xffffffff);
 528                   mem2hex ((char *) &our_crc,
 529                            &remcomOutBuffer[1], sizeof (long), 0);
 530                 }               /* else do nothing */
 531             }                   /* else do nothing */
 532           break;
 533
 534         case 'k':               /* kill the program */
 535           continue;
 536         }                       /* switch */
 537
 538       /* reply to the request */
 539       putpacket (remcomOutBuffer);
 540     }
 541 }
 542
 543 /* qCRC support */
 544
 545 /* Table used by the crc32 function to calculate the checksum.  */
 546 static unsigned long crc32_table[256] = { 0, 0 };
 547
 548 static unsigned long
 549 crc32 (unsigned char *buf, int len, unsigned long crc)
 550 {
 551   if (!crc32_table[1])
 552     {
 553       /* Initialize the CRC table and the decoding table. */
 554       int i, j;
 555       unsigned long c;
 556
 557       for (i = 0; i < 256; i++)
 558         {
 559           for (c = i << 24, j = 8; j > 0; --j)
 560             c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
 561           crc32_table[i] = c;
 562         }
 563     }
 564
 565   while (len--)
 566     {
 567       crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
 568       buf++;
 569     }
 570   return crc;
 571 }
 572
 573 static int
 574 hex (unsigned char ch)
 575 {
 576   if ((ch >= 'a') && (ch <= 'f'))
 577     return (ch - 'a' + 10);
 578   if ((ch >= '0') && (ch <= '9'))
 579     return (ch - '0');
 580   if ((ch >= 'A') && (ch <= 'F'))
 581     return (ch - 'A' + 10);
 582   return (-1);
 583 }
 584
 585 /* scan for the sequence $<data>#<checksum>     */
 586
 587 unsigned char *
 588 getpacket (void)
 589 {
 590   unsigned char *buffer = &remcomInBuffer[0];
 591   unsigned char checksum;
 592   unsigned char xmitcsum;
 593   int count;
 594   char ch;
 595
 596   while (1)
 597     {
 598       /* wait around for the start character, ignore all other characters */
 599       while ((ch = getDebugChar ()) != '$')
 600         ;
 601
 602     retry:
 603       checksum = 0;
 604       xmitcsum = -1;
 605       count = 0;
 606
 607       /* now, read until a # or end of buffer is found */
 608       while (count < BUFMAX - 1)
 609         {
 610           ch = getDebugChar ();
 611           if (ch == '$')
 612             goto retry;
 613           if (ch == '#')
 614             break;
 615           checksum = checksum + ch;
 616           buffer[count] = ch;
 617           count = count + 1;
 618         }
 619       buffer[count] = 0;
 620
 621       if (ch == '#')
 622         {
 623           ch = getDebugChar ();
 624           xmitcsum = hex (ch) << 4;
 625           ch = getDebugChar ();
 626           xmitcsum += hex (ch);
 627
 628           if (checksum != xmitcsum)
 629             {
 630               if (remote_debug)
 631                 {
 632                   unsigned char buf[16];
 633
 634                   mem2hex ((unsigned char *) &checksum, buf, 4, 0);
 635                   gdb_error ("Bad checksum: my count = %s, ", buf);
 636                   mem2hex ((unsigned char *) &xmitcsum, buf, 4, 0);
 637                   gdb_error ("sent count = %s\n", buf);
 638                   gdb_error (" -- Bad buffer: \"%s\"\n", buffer);
 639                 }
 640               putDebugChar ('-');       /* failed checksum */
 641             }
 642           else
 643             {
 644               putDebugChar ('+');       /* successful transfer */
 645
 646               /* if a sequence char is present, reply the sequence ID */
 647               if (buffer[2] == ':')
 648                 {
 649                   putDebugChar (buffer[0]);
 650                   putDebugChar (buffer[1]);
 651
 652                   return &buffer[3];
 653                 }
 654
 655               return &buffer[0];
 656             }
 657         }
 658     }
 659 }
 660
 661 /* send the packet in buffer.  */
 662
 663 static void
 664 putpacket (unsigned char *buffer)
 665 {
 666   unsigned char checksum;
 667   int count;
 668   char ch;
 669
 670   /*  $<packet info>#<checksum>. */
 671   do
 672     {
 673       putDebugChar ('$');
 674       checksum = 0;
 675       count = 0;
 676
 677       while (ch = buffer[count])
 678         {
 679           putDebugChar (ch);
 680           checksum += ch;
 681           count += 1;
 682         }
 683       putDebugChar ('#');
 684       putDebugChar (hexchars[checksum >> 4]);
 685       putDebugChar (hexchars[checksum % 16]);
 686     }
 687   while (getDebugChar () != '+');
 688 }
 689
 690 /* Address of a routine to RTE to if we get a memory fault.  */
 691
 692 static void (*volatile mem_fault_routine) () = 0;
 693
 694 static void
 695 set_mem_err (void)
 696 {
 697   mem_err = 1;
 698 }
 699
 700 /* Check the address for safe access ranges.  As currently defined,
 701    this routine will reject the "expansion bus" address range(s).
 702    To make those ranges useable, someone must implement code to detect
 703    whether there's anything connected to the expansion bus. */
 704
 705 static int
 706 mem_safe (unsigned char *addr)
 707 {
 708 #define BAD_RANGE_ONE_START     ((unsigned char *) 0x600000)
 709 #define BAD_RANGE_ONE_END       ((unsigned char *) 0xa00000)
 710 #define BAD_RANGE_TWO_START     ((unsigned char *) 0xff680000)
 711 #define BAD_RANGE_TWO_END       ((unsigned char *) 0xff800000)
 712
 713   if (addr < BAD_RANGE_ONE_START)
 714     return 1;                   /* safe */
 715   if (addr < BAD_RANGE_ONE_END)
 716     return 0;                   /* unsafe */
 717   if (addr < BAD_RANGE_TWO_START)
 718     return 1;                   /* safe */
 719   if (addr < BAD_RANGE_TWO_END)
 720     return 0;                   /* unsafe */
 721 }
 722
 723 /* These are separate functions so that they are so short and sweet
 724    that the compiler won't save any registers (if there is a fault
 725    to mem_fault, they won't get restored, so there better not be any
 726    saved).  */
 727 static int
 728 get_char (unsigned char *addr)
 729 {
 730 #if 1
 731   if (mem_fault_routine && !mem_safe (addr))
 732     {
 733       mem_fault_routine ();
 734       return 0;
 735     }
 736 #endif
 737   return *addr;
 738 }
 739
 740 static void
 741 set_char (unsigned char *addr, unsigned char val)
 742 {
 743 #if 1
 744   if (mem_fault_routine && !mem_safe (addr))
 745     {
 746       mem_fault_routine ();
 747       return;
 748     }
 749 #endif
 750   *addr = val;
 751 }
 752
 753 /* Convert the memory pointed to by mem into hex, placing result in buf.
 754    Return a pointer to the last char put in buf (null).
 755    If MAY_FAULT is non-zero, then we should set mem_err in response to
 756    a fault; if zero treat a fault like any other fault in the stub.  */
 757
 758 static unsigned char *
 759 mem2hex (unsigned char *mem, unsigned char *buf, int count, int may_fault)
 760 {
 761   int i;
 762   unsigned char ch;
 763
 764   if (may_fault)
 765     mem_fault_routine = set_mem_err;
 766   for (i = 0; i < count; i++)
 767     {
 768       ch = get_char (mem++);
 769       if (may_fault && mem_err)
 770         return (buf);
 771       *buf++ = hexchars[ch >> 4];
 772       *buf++ = hexchars[ch % 16];
 773     }
 774   *buf = 0;
 775   if (may_fault)
 776     mem_fault_routine = 0;
 777   return (buf);
 778 }
 779
 780 /* Convert the hex array pointed to by buf into binary to be placed in mem.
 781    Return a pointer to the character AFTER the last byte written. */
 782
 783 static unsigned char *
 784 hex2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault)
 785 {
 786   int i;
 787   unsigned char ch;
 788
 789   if (may_fault)
 790     mem_fault_routine = set_mem_err;
 791   for (i = 0; i < count; i++)
 792     {
 793       ch = hex (*buf++) << 4;
 794       ch = ch + hex (*buf++);
 795       set_char (mem++, ch);
 796       if (may_fault && mem_err)
 797         return (mem);
 798     }
 799   if (may_fault)
 800     mem_fault_routine = 0;
 801   return (mem);
 802 }
 803
 804 /* Convert the binary stream in BUF to memory.
 805
 806    Gdb will escape $, #, and the escape char (0x7d).
 807    COUNT is the total number of bytes to write into
 808    memory. */
 809 static unsigned char *
 810 bin2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault)
 811 {
 812   int i;
 813   unsigned char ch;
 814
 815   if (may_fault)
 816     mem_fault_routine = set_mem_err;
 817   for (i = 0; i < count; i++)
 818     {
 819       /* Check for any escaped characters. Be paranoid and
 820          only unescape chars that should be escaped. */
 821       if (*buf == 0x7d)
 822         {
 823           switch (*(buf + 1))
 824             {
 825             case 0x3:           /* # */
 826             case 0x4:           /* $ */
 827             case 0x5d:          /* escape char */
 828               buf++;
 829               *buf |= 0x20;
 830               break;
 831             default:
 832               /* nothing */
 833               break;
 834             }
 835         }
 836
 837       set_char (mem++, *buf++);
 838
 839       if (may_fault && mem_err)
 840         return mem;
 841     }
 842
 843   if (may_fault)
 844     mem_fault_routine = 0;
 845   return mem;
 846 }
 847
 848 /* this function takes the m32r exception vector and attempts to
 849    translate this number into a unix compatible signal value */
 850
 851 static int
 852 computeSignal (int exceptionVector)
 853 {
 854   int sigval;
 855   switch (exceptionVector)
 856     {
 857     case 0:
 858       sigval = 23;
 859       break;                    /* I/O trap                    */
 860     case 1:
 861       sigval = 5;
 862       break;                    /* breakpoint                  */
 863     case 2:
 864       sigval = 5;
 865       break;                    /* breakpoint                  */
 866     case 3:
 867       sigval = 5;
 868       break;                    /* breakpoint                  */
 869     case 4:
 870       sigval = 5;
 871       break;                    /* breakpoint                  */
 872     case 5:
 873       sigval = 5;
 874       break;                    /* breakpoint                  */
 875     case 6:
 876       sigval = 5;
 877       break;                    /* breakpoint                  */
 878     case 7:
 879       sigval = 5;
 880       break;                    /* breakpoint                  */
 881     case 8:
 882       sigval = 5;
 883       break;                    /* breakpoint                  */
 884     case 9:
 885       sigval = 5;
 886       break;                    /* breakpoint                  */
 887     case 10:
 888       sigval = 5;
 889       break;                    /* breakpoint                  */
 890     case 11:
 891       sigval = 5;
 892       break;                    /* breakpoint                  */
 893     case 12:
 894       sigval = 5;
 895       break;                    /* breakpoint                  */
 896     case 13:
 897       sigval = 5;
 898       break;                    /* breakpoint                  */
 899     case 14:
 900       sigval = 5;
 901       break;                    /* breakpoint                  */
 902     case 15:
 903       sigval = 5;
 904       break;                    /* breakpoint                  */
 905     case 16:
 906       sigval = 10;
 907       break;                    /* BUS ERROR (alignment)       */
 908     case 17:
 909       sigval = 2;
 910       break;                    /* INTerrupt                   */
 911     default:
 912       sigval = 7;
 913       break;                    /* "software generated"        */
 914     }
 915   return (sigval);
 916 }
 917
 918 /**********************************************/
 919 /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
 920 /* RETURN NUMBER OF CHARS PROCESSED           */
 921 /**********************************************/
 922 static int
 923 hexToInt (unsigned char **ptr, int *intValue)
 924 {
 925   int numChars = 0;
 926   int hexValue;
 927
 928   *intValue = 0;
 929   while (**ptr)
 930     {
 931       hexValue = hex (**ptr);
 932       if (hexValue >= 0)
 933         {
 934           *intValue = (*intValue << 4) | hexValue;
 935           numChars++;
 936         }
 937       else
 938         break;
 939       (*ptr)++;
 940     }
 941   return (numChars);
 942 }
 943
 944 /*
 945   Table of branch instructions:
 946
 947   10B6          RTE     return from trap or exception
 948   1FCr          JMP     jump
 949   1ECr          JL      jump and link
 950   7Fxx          BRA     branch
 951   FFxxxxxx      BRA     branch (long)
 952   B09rxxxx      BNEZ    branch not-equal-zero
 953   Br1rxxxx      BNE     branch not-equal
 954   7Dxx          BNC     branch not-condition
 955   FDxxxxxx      BNC     branch not-condition (long)
 956   B0Arxxxx      BLTZ    branch less-than-zero
 957   B0Crxxxx      BLEZ    branch less-equal-zero
 958   7Exx          BL      branch and link
 959   FExxxxxx      BL      branch and link (long)
 960   B0Drxxxx      BGTZ    branch greater-than-zero
 961   B0Brxxxx      BGEZ    branch greater-equal-zero
 962   B08rxxxx      BEQZ    branch equal-zero
 963   Br0rxxxx      BEQ     branch equal
 964   7Cxx          BC      branch condition
 965   FCxxxxxx      BC      branch condition (long)
 966   */
 967
 968 static int
 969 isShortBranch (unsigned char *instr)
 970 {
 971   unsigned char instr0 = instr[0] & 0x7F;       /* mask off high bit */
 972
 973   if (instr0 == 0x10 && instr[1] == 0xB6)       /* RTE */
 974     return 1;                   /* return from trap or exception */
 975
 976   if (instr0 == 0x1E || instr0 == 0x1F) /* JL or JMP */
 977     if ((instr[1] & 0xF0) == 0xC0)
 978       return 2;                 /* jump thru a register */
 979
 980   if (instr0 == 0x7C || instr0 == 0x7D ||       /* BC, BNC, BL, BRA */
 981       instr0 == 0x7E || instr0 == 0x7F)
 982     return 3;                   /* eight bit PC offset */
 983
 984   return 0;
 985 }
 986
 987 static int
 988 isLongBranch (unsigned char *instr)
 989 {
 990   if (instr[0] == 0xFC || instr[0] == 0xFD ||   /* BRA, BNC, BL, BC */
 991       instr[0] == 0xFE || instr[0] == 0xFF)     /* 24 bit relative */
 992     return 4;
 993   if ((instr[0] & 0xF0) == 0xB0)        /* 16 bit relative */
 994     {
 995       if ((instr[1] & 0xF0) == 0x00 ||  /* BNE, BEQ */
 996           (instr[1] & 0xF0) == 0x10)
 997         return 5;
 998       if (instr[0] == 0xB0)     /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ, BEQZ */
 999         if ((instr[1] & 0xF0) == 0x80 || (instr[1] & 0xF0) == 0x90 ||
1000             (instr[1] & 0xF0) == 0xA0 || (instr[1] & 0xF0) == 0xB0 ||
1001             (instr[1] & 0xF0) == 0xC0 || (instr[1] & 0xF0) == 0xD0)
1002           return 6;
1003     }
1004   return 0;
1005 }
1006
1007 /* if address is NOT on a 4-byte boundary, or high-bit of instr is zero,
1008    then it's a 2-byte instruction, else it's a 4-byte instruction.  */
1009
1010 #define INSTRUCTION_SIZE(addr) \
1011     ((((int) addr & 2) || (((unsigned char *) addr)[0] & 0x80) == 0) ? 2 : 4)
1012
1013 static int
1014 isBranch (unsigned char *instr)
1015 {
1016   if (INSTRUCTION_SIZE (instr) == 2)
1017     return isShortBranch (instr);
1018   else
1019     return isLongBranch (instr);
1020 }
1021
1022 static int
1023 willBranch (unsigned char *instr, int branchCode)
1024 {
1025   switch (branchCode)
1026     {
1027     case 0:
1028       return 0;                 /* not a branch */
1029     case 1:
1030       return 1;                 /* RTE */
1031     case 2:
1032       return 1;                 /* JL or JMP    */
1033     case 3:                     /* BC, BNC, BL, BRA (short) */
1034     case 4:                     /* BC, BNC, BL, BRA (long) */
1035       switch (instr[0] & 0x0F)
1036         {
1037         case 0xC:               /* Branch if Condition Register */
1038           return (registers[CBR] != 0);
1039         case 0xD:               /* Branch if NOT Condition Register */
1040           return (registers[CBR] == 0);
1041         case 0xE:               /* Branch and Link */
1042         case 0xF:               /* Branch (unconditional) */
1043           return 1;
1044         default:                /* oops? */
1045           return 0;
1046         }
1047     case 5:                     /* BNE, BEQ */
1048       switch (instr[1] & 0xF0)
1049         {
1050         case 0x00:              /* Branch if r1 equal to r2 */
1051           return (registers[instr[0] & 0x0F] == registers[instr[1] & 0x0F]);
1052         case 0x10:              /* Branch if r1 NOT equal to r2 */
1053           return (registers[instr[0] & 0x0F] != registers[instr[1] & 0x0F]);
1054         default:                /* oops? */
1055           return 0;
1056         }
1057     case 6:                     /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ */
1058       switch (instr[1] & 0xF0)
1059         {
1060         case 0x80:              /* Branch if reg equal to zero */
1061           return (registers[instr[1] & 0x0F] == 0);
1062         case 0x90:              /* Branch if reg NOT equal to zero */
1063           return (registers[instr[1] & 0x0F] != 0);
1064         case 0xA0:              /* Branch if reg less than zero */
1065           return (registers[instr[1] & 0x0F] < 0);
1066         case 0xB0:              /* Branch if reg greater or equal to zero */
1067           return (registers[instr[1] & 0x0F] >= 0);
1068         case 0xC0:              /* Branch if reg less than or equal to zero */
1069           return (registers[instr[1] & 0x0F] <= 0);
1070         case 0xD0:              /* Branch if reg greater than zero */
1071           return (registers[instr[1] & 0x0F] > 0);
1072         default:                /* oops? */
1073           return 0;
1074         }
1075     default:                    /* oops? */
1076       return 0;
1077     }
1078 }
1079
1080 static int
1081 branchDestination (unsigned char *instr, int branchCode)
1082 {
1083   switch (branchCode)
1084     {
1085     default:
1086     case 0:                     /* not a branch */
1087       return 0;
1088     case 1:                     /* RTE */
1089       return registers[BPC] & ~3;       /* pop BPC into PC */
1090     case 2:                     /* JL or JMP */
1091       return registers[instr[1] & 0x0F] & ~3;   /* jump thru a register */
1092     case 3:                     /* BC, BNC, BL, BRA (short, 8-bit relative offset) */
1093       return (((int) instr) & ~3) + ((char) instr[1] << 2);
1094     case 4:                     /* BC, BNC, BL, BRA (long, 24-bit relative offset) */
1095       return ((int) instr +
1096               ((((char) instr[1] << 16) | (instr[2] << 8) | (instr[3])) <<
1097                2));
1098     case 5:                     /* BNE, BEQ (16-bit relative offset) */
1099     case 6:                     /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ (ditto) */
1100       return ((int) instr + ((((char) instr[2] << 8) | (instr[3])) << 2));
1101     }
1102
1103   /* An explanatory note: in the last three return expressions, I have
1104      cast the most-significant byte of the return offset to char.
1105      What this accomplishes is sign extension.  If the other
1106      less-significant bytes were signed as well, they would get sign
1107      extended too and, if negative, their leading bits would clobber
1108      the bits of the more-significant bytes ahead of them.  There are
1109      other ways I could have done this, but sign extension from
1110      odd-sized integers is always a pain. */
1111 }
1112
1113 static void
1114 branchSideEffects (unsigned char *instr, int branchCode)
1115 {
1116   switch (branchCode)
1117     {
1118     case 1:                     /* RTE */
1119       return;                   /* I <THINK> this is already handled... */
1120     case 2:                     /* JL (or JMP) */
1121     case 3:                     /* BL (or BC, BNC, BRA) */
1122     case 4:
1123       if ((instr[0] & 0x0F) == 0x0E)    /* branch/jump and link */
1124         registers[R14] = (registers[PC] & ~3) + 4;
1125       return;
1126     default:                    /* any other branch has no side effects */
1127       return;
1128     }
1129 }
1130
1131 static struct STEPPING_CONTEXT
1132 {
1133   int stepping;                 /* true when we've started a single-step */
1134   unsigned long target_addr;    /* the instr we're trying to execute */
1135   unsigned long target_size;    /* the size of the target instr */
1136   unsigned long noop_addr;      /* where we've inserted a no-op, if any */
1137   unsigned long trap1_addr;     /* the trap following the target instr */
1138   unsigned long trap2_addr;     /* the trap at a branch destination, if any */
1139   unsigned short noop_save;     /* instruction overwritten by our no-op */
1140   unsigned short trap1_save;    /* instruction overwritten by trap1 */
1141   unsigned short trap2_save;    /* instruction overwritten by trap2 */
1142   unsigned short continue_p;    /* true if NOT returning to gdb after step */
1143 } stepping;
1144
1145 /* Function: prepare_to_step
1146    Called from handle_exception to prepare the user program to single-step.
1147    Places a trap instruction after the target instruction, with special
1148    extra handling for branch instructions and for instructions in the
1149    second half-word of a word.
1150
1151    Returns: True  if we should actually execute the instruction;
1152             False if we are going to emulate executing the instruction,
1153             in which case we simply report to GDB that the instruction
1154             has already been executed.  */
1155
1156 #define TRAP1  0x10f1;          /* trap #1 instruction */
1157 #define NOOP   0x7000;          /* noop    instruction */
1158
1159 static unsigned short trap1 = TRAP1;
1160 static unsigned short noop = NOOP;
1161
1162 static int
1163 prepare_to_step (continue_p)
1164      int continue_p;            /* if this isn't REALLY a single-step (see below) */
1165 {
1166   unsigned long pc = registers[PC];
1167   int branchCode = isBranch ((unsigned char *) pc);
1168   unsigned char *p;
1169
1170   /* zero out the stepping context
1171      (paranoia -- it should already be zeroed) */
1172   for (p = (unsigned char *) &stepping;
1173        p < ((unsigned char *) &stepping) + sizeof (stepping); p++)
1174     *p = 0;
1175
1176   if (branchCode != 0)          /* next instruction is a branch */
1177     {
1178       branchSideEffects ((unsigned char *) pc, branchCode);
1179       if (willBranch ((unsigned char *) pc, branchCode))
1180         registers[PC] = branchDestination ((unsigned char *) pc, branchCode);
1181       else
1182         registers[PC] = pc + INSTRUCTION_SIZE (pc);
1183       return 0;                 /* branch "executed" -- just notify GDB */
1184     }
1185   else if (((int) pc & 2) != 0) /* "second-slot" instruction */
1186     {
1187       /* insert no-op before pc */
1188       stepping.noop_addr = pc - 2;
1189       stepping.noop_save = *(unsigned short *) stepping.noop_addr;
1190       *(unsigned short *) stepping.noop_addr = noop;
1191       /* insert trap  after  pc */
1192       stepping.trap1_addr = pc + 2;
1193       stepping.trap1_save = *(unsigned short *) stepping.trap1_addr;
1194       *(unsigned short *) stepping.trap1_addr = trap1;
1195     }
1196   else                          /* "first-slot" instruction */
1197     {
1198       /* insert trap  after  pc */
1199       stepping.trap1_addr = pc + INSTRUCTION_SIZE (pc);
1200       stepping.trap1_save = *(unsigned short *) stepping.trap1_addr;
1201       *(unsigned short *) stepping.trap1_addr = trap1;
1202     }
1203   /* "continue_p" means that we are actually doing a continue, and not
1204      being requested to single-step by GDB.  Sometimes we have to do
1205      one single-step before continuing, because the PC is on a half-word
1206      boundary.  There's no way to simply resume at such an address.  */
1207   stepping.continue_p = continue_p;
1208   stepping.stepping = 1;        /* starting a single-step */
1209   return 1;
1210 }
1211
1212 /* Function: finish_from_step
1213    Called from handle_exception to finish up when the user program
1214    returns from a single-step.  Replaces the instructions that had
1215    been overwritten by traps or no-ops,
1216
1217    Returns: True  if we should notify GDB that the target stopped.
1218             False if we only single-stepped because we had to before we
1219             could continue (ie. we were trying to continue at a
1220             half-word boundary).  In that case don't notify GDB:
1221             just "continue continuing".  */
1222
1223 static int
1224 finish_from_step (void)
1225 {
1226   if (stepping.stepping)        /* anything to do? */
1227     {
1228       int continue_p = stepping.continue_p;
1229       unsigned char *p;
1230
1231       if (stepping.noop_addr)   /* replace instr "under" our no-op */
1232         *(unsigned short *) stepping.noop_addr = stepping.noop_save;
1233       if (stepping.trap1_addr)  /* replace instr "under" our trap  */
1234         *(unsigned short *) stepping.trap1_addr = stepping.trap1_save;
1235       if (stepping.trap2_addr)  /* ditto our other trap, if any    */
1236         *(unsigned short *) stepping.trap2_addr = stepping.trap2_save;
1237
1238       for (p = (unsigned char *) &stepping;     /* zero out the stepping context */
1239            p < ((unsigned char *) &stepping) + sizeof (stepping); p++)
1240         *p = 0;
1241
1242       return !(continue_p);
1243     }
1244   else                          /* we didn't single-step, therefore this must be a legitimate stop */
1245     return 1;
1246 }
1247
1248 struct PSWreg
1249 {                               /* separate out the bit flags in the PSW register */
1250   int pad1:16;
1251   int bsm:1;
1252   int bie:1;
1253   int pad2:5;
1254   int bc:1;
1255   int sm:1;
1256   int ie:1;
1257   int pad3:5;
1258   int c:1;
1259 } *psw;
1260
1261 /* Upon entry the value for LR to save has been pushed.
1262    We unpush that so that the value for the stack pointer saved is correct.
1263    Upon entry, all other registers are assumed to have not been modified
1264    since the interrupt/trap occured.  */
1265
1266 asm ("\n\
1267 stash_registers:\n\
1268         push r0\n\
1269         push r1\n\
1270         seth r1, #shigh(registers)\n\
1271         add3 r1, r1, #low(registers)\n\
1272         pop r0          ; r1\n\
1273         st r0, @(4,r1)\n\
1274         pop r0          ; r0\n\
1275         st r0, @r1\n\
1276         addi r1, #4     ; only add 4 as subsequent saves are `pre inc'\n\
1277         st r2, @+r1\n\
1278         st r3, @+r1\n\
1279         st r4, @+r1\n\
1280         st r5, @+r1\n\
1281         st r6, @+r1\n\
1282         st r7, @+r1\n\
1283         st r8, @+r1\n\
1284         st r9, @+r1\n\
1285         st r10, @+r1\n\
1286         st r11, @+r1\n\
1287         st r12, @+r1\n\
1288         st r13, @+r1    ; fp\n\
1289         pop r0          ; lr (r14)\n\
1290         st r0, @+r1\n\
1291         st sp, @+r1     ; sp contains right value at this point\n\
1292         mvfc r0, cr0\n\
1293         st r0, @+r1     ; cr0 == PSW\n\
1294         mvfc r0, cr1\n\
1295         st r0, @+r1     ; cr1 == CBR\n\
1296         mvfc r0, cr2\n\
1297         st r0, @+r1     ; cr2 == SPI\n\
1298         mvfc r0, cr3\n\
1299         st r0, @+r1     ; cr3 == SPU\n\
1300         mvfc r0, cr6\n\
1301         st r0, @+r1     ; cr6 == BPC\n\
1302         st r0, @+r1     ; PC  == BPC\n\
1303         mvfaclo r0\n\
1304         st r0, @+r1     ; ACCL\n\
1305         mvfachi r0\n\
1306         st r0, @+r1     ; ACCH\n\
1307         jmp lr");
1308
1309 /* C routine to clean up what stash_registers did.
1310    It is called after calling stash_registers.
1311    This is separate from stash_registers as we want to do this in C
1312    but doing stash_registers in C isn't straightforward.  */
1313
1314 static void
1315 cleanup_stash (void)
1316 {
1317   psw = (struct PSWreg *) &registers[PSW];      /* fields of PSW register */
1318   psw->sm = psw->bsm;           /* fix up pre-trap values of psw fields */
1319   psw->ie = psw->bie;
1320   psw->c = psw->bc;
1321   registers[CBR] = psw->bc;     /* fix up pre-trap "C" register */
1322
1323 #if 0                           /* FIXME: Was in previous version.  Necessary?
1324                                    (Remember that we use the "rte" insn to return from the
1325                                    trap/interrupt so the values of bsm, bie, bc are important.  */
1326   psw->bsm = psw->bie = psw->bc = 0;    /* zero post-trap values */
1327 #endif
1328
1329   /* FIXME: Copied from previous version.  This can probably be deleted
1330      since methinks stash_registers has already done this.  */
1331   registers[PC] = registers[BPC];       /* pre-trap PC */
1332
1333   /* FIXME: Copied from previous version.  Necessary?  */
1334   if (psw->sm)                  /* copy R15 into (psw->sm ? SPU : SPI) */
1335     registers[SPU] = registers[R15];
1336   else
1337     registers[SPI] = registers[R15];
1338 }
1339
1340 asm ("\n\
1341 restore_and_return:\n\
1342         seth r0, #shigh(registers+8)\n\
1343         add3 r0, r0, #low(registers+8)\n\
1344         ld r2, @r0+     ; restore r2\n\
1345         ld r3, @r0+     ; restore r3\n\
1346         ld r4, @r0+     ; restore r4\n\
1347         ld r5, @r0+     ; restore r5\n\
1348         ld r6, @r0+     ; restore r6\n\
1349         ld r7, @r0+     ; restore r7\n\
1350         ld r8, @r0+     ; restore r8\n\
1351         ld r9, @r0+     ; restore r9\n\
1352         ld r10, @r0+    ; restore r10\n\
1353         ld r11, @r0+    ; restore r11\n\
1354         ld r12, @r0+    ; restore r12\n\
1355         ld r13, @r0+    ; restore r13\n\
1356         ld r14, @r0+    ; restore r14\n\
1357         ld r15, @r0+    ; restore r15\n\
1358         ld r1, @r0+     ; restore cr0 == PSW\n\
1359         mvtc r1, cr0\n\
1360         ld r1, @r0+     ; restore cr1 == CBR (no-op, because it's read only)\n\
1361         mvtc r1, cr1\n\
1362         ld r1, @r0+     ; restore cr2 == SPI\n\
1363         mvtc r1, cr2\n\
1364         ld r1, @r0+     ; restore cr3 == SPU\n\
1365         mvtc r1, cr3\n\
1366         addi r0, #4     ; skip BPC\n\
1367         ld r1, @r0+     ; restore cr6 (BPC) == PC\n\
1368         mvtc r1, cr6\n\
1369         ld r1, @r0+     ; restore ACCL\n\
1370         mvtaclo r1\n\
1371         ld r1, @r0+     ; restore ACCH\n\
1372         mvtachi r1\n\
1373         seth r0, #shigh(registers)\n\
1374         add3 r0, r0, #low(registers)\n\
1375         ld r1, @(4,r0)  ; restore r1\n\
1376         ld r0, @r0      ; restore r0\n\
1377         rte");
1378
1379 /* General trap handler, called after the registers have been stashed.
1380    NUM is the trap/exception number.  */
1381
1382 static void
1383 process_exception (int num)
1384 {
1385   cleanup_stash ();
1386   asm volatile ("\n\
1387         seth r1, #shigh(stackPtr)\n\
1388         add3 r1, r1, #low(stackPtr)\n\
1389         ld r15, @r1             ; setup local stack (protect user stack)\n\
1390         mv r0, %0\n\
1391         bl handle_exception\n\
1392         bl restore_and_return"::"r" (num):"r0", "r1");
1393 }
1394
1395 void _catchException0 ();
1396
1397 asm ("\n\
1398 _catchException0:\n\
1399         push lr\n\
1400         bl stash_registers\n\
1401         ; Note that at this point the pushed value of `lr' has been popped\n\
1402         ldi r0, #0\n\
1403         bl process_exception");
1404
1405 void _catchException1 ();
1406
1407 asm ("\n\
1408 _catchException1:\n\
1409         push lr\n\
1410         bl stash_registers\n\
1411         ; Note that at this point the pushed value of `lr' has been popped\n\
1412         bl cleanup_stash\n\
1413         seth r1, #shigh(stackPtr)\n\
1414         add3 r1, r1, #low(stackPtr)\n\
1415         ld r15, @r1             ; setup local stack (protect user stack)\n\
1416         seth r1, #shigh(registers + 21*4) ; PC\n\
1417         add3 r1, r1, #low(registers + 21*4)\n\
1418         ld r0, @r1\n\
1419         addi r0, #-4            ; back up PC for breakpoint trap.\n\
1420         st r0, @r1              ; FIXME: what about bp in right slot?\n\
1421         ldi r0, #1\n\
1422         bl handle_exception\n\
1423         bl restore_and_return");
1424
1425 void _catchException2 ();
1426
1427 asm ("\n\
1428 _catchException2:\n\
1429         push lr\n\
1430         bl stash_registers\n\
1431         ; Note that at this point the pushed value of `lr' has been popped\n\
1432         ldi r0, #2\n\
1433         bl process_exception");
1434
1435 void _catchException3 ();
1436
1437 asm ("\n\
1438 _catchException3:\n\
1439         push lr\n\
1440         bl stash_registers\n\
1441         ; Note that at this point the pushed value of `lr' has been popped\n\
1442         ldi r0, #3\n\
1443         bl process_exception");
1444
1445 void _catchException4 ();
1446
1447 asm ("\n\
1448 _catchException4:\n\
1449         push lr\n\
1450         bl stash_registers\n\
1451         ; Note that at this point the pushed value of `lr' has been popped\n\
1452         ldi r0, #4\n\
1453         bl process_exception");
1454
1455 void _catchException5 ();
1456
1457 asm ("\n\
1458 _catchException5:\n\
1459         push lr\n\
1460         bl stash_registers\n\
1461         ; Note that at this point the pushed value of `lr' has been popped\n\
1462         ldi r0, #5\n\
1463         bl process_exception");
1464
1465 void _catchException6 ();
1466
1467 asm ("\n\
1468 _catchException6:\n\
1469         push lr\n\
1470         bl stash_registers\n\
1471         ; Note that at this point the pushed value of `lr' has been popped\n\
1472         ldi r0, #6\n\
1473         bl process_exception");
1474
1475 void _catchException7 ();
1476
1477 asm ("\n\
1478 _catchException7:\n\
1479         push lr\n\
1480         bl stash_registers\n\
1481         ; Note that at this point the pushed value of `lr' has been popped\n\
1482         ldi r0, #7\n\
1483         bl process_exception");
1484
1485 void _catchException8 ();
1486
1487 asm ("\n\
1488 _catchException8:\n\
1489         push lr\n\
1490         bl stash_registers\n\
1491         ; Note that at this point the pushed value of `lr' has been popped\n\
1492         ldi r0, #8\n\
1493         bl process_exception");
1494
1495 void _catchException9 ();
1496
1497 asm ("\n\
1498 _catchException9:\n\
1499         push lr\n\
1500         bl stash_registers\n\
1501         ; Note that at this point the pushed value of `lr' has been popped\n\
1502         ldi r0, #9\n\
1503         bl process_exception");
1504
1505 void _catchException10 ();
1506
1507 asm ("\n\
1508 _catchException10:\n\
1509         push lr\n\
1510         bl stash_registers\n\
1511         ; Note that at this point the pushed value of `lr' has been popped\n\
1512         ldi r0, #10\n\
1513         bl process_exception");
1514
1515 void _catchException11 ();
1516
1517 asm ("\n\
1518 _catchException11:\n\
1519         push lr\n\
1520         bl stash_registers\n\
1521         ; Note that at this point the pushed value of `lr' has been popped\n\
1522         ldi r0, #11\n\
1523         bl process_exception");
1524
1525 void _catchException12 ();
1526
1527 asm ("\n\
1528 _catchException12:\n\
1529         push lr\n\
1530         bl stash_registers\n\
1531         ; Note that at this point the pushed value of `lr' has been popped\n\
1532         ldi r0, #12\n\
1533         bl process_exception");
1534
1535 void _catchException13 ();
1536
1537 asm ("\n\
1538 _catchException13:\n\
1539         push lr\n\
1540         bl stash_registers\n\
1541         ; Note that at this point the pushed value of `lr' has been popped\n\
1542         ldi r0, #13\n\
1543         bl process_exception");
1544
1545 void _catchException14 ();
1546
1547 asm ("\n\
1548 _catchException14:\n\
1549         push lr\n\
1550         bl stash_registers\n\
1551         ; Note that at this point the pushed value of `lr' has been popped\n\
1552         ldi r0, #14\n\
1553         bl process_exception");
1554
1555 void _catchException15 ();
1556
1557 asm ("\n\
1558 _catchException15:\n\
1559         push lr\n\
1560         bl stash_registers\n\
1561         ; Note that at this point the pushed value of `lr' has been popped\n\
1562         ldi r0, #15\n\
1563         bl process_exception");
1564
1565 void _catchException16 ();
1566
1567 asm ("\n\
1568 _catchException16:\n\
1569         push lr\n\
1570         bl stash_registers\n\
1571         ; Note that at this point the pushed value of `lr' has been popped\n\
1572         ldi r0, #16\n\
1573         bl process_exception");
1574
1575 void _catchException17 ();
1576
1577 asm ("\n\
1578 _catchException17:\n\
1579         push lr\n\
1580         bl stash_registers\n\
1581         ; Note that at this point the pushed value of `lr' has been popped\n\
1582         ldi r0, #17\n\
1583         bl process_exception");
1584
1585
1586 /* this function is used to set up exception handlers for tracing and
1587    breakpoints */
1588 void
1589 set_debug_traps (void)
1590 {
1591   /*  extern void remcomHandler(); */
1592   int i;
1593
1594   for (i = 0; i < 18; i++)      /* keep a copy of old vectors */
1595     if (save_vectors[i] == 0)   /* only copy them the first time */
1596       save_vectors[i] = getExceptionHandler (i);
1597
1598   stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
1599
1600   exceptionHandler (0, _catchException0);
1601   exceptionHandler (1, _catchException1);
1602   exceptionHandler (2, _catchException2);
1603   exceptionHandler (3, _catchException3);
1604   exceptionHandler (4, _catchException4);
1605   exceptionHandler (5, _catchException5);
1606   exceptionHandler (6, _catchException6);
1607   exceptionHandler (7, _catchException7);
1608   exceptionHandler (8, _catchException8);
1609   exceptionHandler (9, _catchException9);
1610   exceptionHandler (10, _catchException10);
1611   exceptionHandler (11, _catchException11);
1612   exceptionHandler (12, _catchException12);
1613   exceptionHandler (13, _catchException13);
1614   exceptionHandler (14, _catchException14);
1615   exceptionHandler (15, _catchException15);
1616   exceptionHandler (16, _catchException16);
1617   /*  exceptionHandler (17, _catchException17); */
1618
1619   initialized = 1;
1620 }
1621
1622 /* This function will generate a breakpoint exception.  It is used at the
1623    beginning of a program to sync up with a debugger and can be used
1624    otherwise as a quick means to stop program execution and "break" into
1625    the debugger. */
1626
1627 #define BREAKPOINT() asm volatile ("    trap #2");
1628
1629 void
1630 breakpoint (void)
1631 {
1632   if (initialized)
1633     BREAKPOINT ();
1634 }
1635
1636 /* STDOUT section:
1637    Stuff pertaining to simulating stdout by sending chars to gdb to be echoed.
1638    Functions: gdb_putchar(char ch)
1639               gdb_puts(char *str)
1640               gdb_write(char *str, int len)
1641               gdb_error(char *format, char *parm)
1642               */
1643
1644 /* Function: gdb_putchar(int)
1645    Make gdb write a char to stdout.
1646    Returns: the char */
1647
1648 static int
1649 gdb_putchar (int ch)
1650 {
1651   char buf[4];
1652
1653   buf[0] = 'O';
1654   buf[1] = hexchars[ch >> 4];
1655   buf[2] = hexchars[ch & 0x0F];
1656   buf[3] = 0;
1657   putpacket (buf);
1658   return ch;
1659 }
1660
1661 /* Function: gdb_write(char *, int)
1662    Make gdb write n bytes to stdout (not assumed to be null-terminated).
1663    Returns: number of bytes written */
1664
1665 static int
1666 gdb_write (char *data, int len)
1667 {
1668   char *buf, *cpy;
1669   int i;
1670
1671   buf = remcomOutBuffer;
1672   buf[0] = 'O';
1673   i = 0;
1674   while (i < len)
1675     {
1676       for (cpy = buf + 1;
1677            i < len && cpy < buf + sizeof (remcomOutBuffer) - 3; i++)
1678         {
1679           *cpy++ = hexchars[data[i] >> 4];
1680           *cpy++ = hexchars[data[i] & 0x0F];
1681         }
1682       *cpy = 0;
1683       putpacket (buf);
1684     }
1685   return len;
1686 }
1687
1688 /* Function: gdb_puts(char *)
1689    Make gdb write a null-terminated string to stdout.
1690    Returns: the length of the string */
1691
1692 static int
1693 gdb_puts (char *str)
1694 {
1695   return gdb_write (str, strlen (str));
1696 }
1697
1698 /* Function: gdb_error(char *, char *)
1699    Send an error message to gdb's stdout.
1700    First string may have 1 (one) optional "%s" in it, which
1701    will cause the optional second string to be inserted.  */
1702
1703 static void
1704 gdb_error (char *format, char *parm)
1705 {
1706   char buf[400], *cpy;
1707   int len;
1708
1709   if (remote_debug)
1710     {
1711       if (format && *format)
1712         len = strlen (format);
1713       else
1714         return;                 /* empty input */
1715
1716       if (parm && *parm)
1717         len += strlen (parm);
1718
1719       for (cpy = buf; *format;)
1720         {
1721           if (format[0] == '%' && format[1] == 's')     /* include second string */
1722             {
1723               format += 2;      /* advance two chars instead of just one */
1724               while (parm && *parm)
1725                 *cpy++ = *parm++;
1726             }
1727           else
1728             *cpy++ = *format++;
1729         }
1730       *cpy = '\0';
1731       gdb_puts (buf);
1732     }
1733 }
1734
1735 static unsigned char *
1736 strcpy (unsigned char *dest, const unsigned char *src)
1737 {
1738   unsigned char *ret = dest;
1739
1740   if (dest && src)
1741     {
1742       while (*src)
1743         *dest++ = *src++;
1744       *dest = 0;
1745     }
1746   return ret;
1747 }
1748
1749 static int
1750 strlen (const unsigned char *src)
1751 {
1752   int ret;
1753
1754   for (ret = 0; *src; src++)
1755     ret++;
1756
1757   return ret;
1758 }
1759
1760 #if 0
1761 void
1762 exit (code)
1763      int code;
1764 {
1765   _exit (code);
1766 }
1767
1768 int
1769 atexit (void *p)
1770 {
1771   return 0;
1772 }
1773
1774 void
1775 abort (void)
1776 {
1777   _exit (1);
1778 }
1779 #endif