gdb/stubs/m32r-stub.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /****************************************************************************

  3.                 THIS SOFTWARE IS NOT COPYRIGHTED

  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.

  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.

  13. ****************************************************************************/

  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. ****************************************************************************/


  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   */

  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

  109. ‌static char initialized;        /* boolean flag. != 0 means we've been initialized */

  111. ‌int remote_debug;
  112. /*  debug >  0 prints ill-formed commands in valid packets & checksum errors */

  114. ‌static const unsigned char hexchars[] = "0123456789abcdef";

  116. ‌#define NUMREGS 24

  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. };

  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. };

  153. ‌static int registers[NUMREGS];

  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];

  161. ‌static unsigned int save_vectors[18];        /* previous exception vectors */

  163. /* Indicate to caller of mem2hex or hex2mem that there has been an error. */
  164. ‌static volatile int mem_err = 0;

  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;

  170. #if 0
  171. #include "syscall.h"                /* for SYS_exit, SYS_write etc. */
  172. #endif

  174. /* Global entry points:
  175. */

  177. extern void handle_exception (int);
  178. extern void set_debug_traps (void);
  179. extern void breakpoint (void);

  181. /* Local functions:
  182. */

  184. static int computeSignal (int);
  185. static void putpacket (unsigned char *);
  186. static unsigned char *getpacket (void);

  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);

  198. static void gdb_error (char *, char *);
  199. static int gdb_putchar (int), gdb_puts (char *), gdb_write (char *, int);

  201. static unsigned char *strcpy (unsigned char *, const unsigned char *);
  202. static int strlen (const unsigned char *);

  204. /*
  205. * This function does all command procesing for interfacing to gdb.
  206. */

  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;

  217.   if (!finish_from_step ())
  218.     return;                        /* "false step": let the target continue */

  220.   gdb_m32r_vector = exceptionVector;

  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.     }

  230.   /* reply to host that an exception has occurred */
  231.   sigval = computeSignal (exceptionVector);

  233.   ptr = remcomOutBuffer;

  235.   *ptr++ = 'T';                        /* notify gdb with signo, PC, FP and SP */
  236.   *ptr++ = hexchars[sigval >> 4];
  237.   *ptr++ = hexchars[sigval & 0xf];

  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++ = ';';

  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++ = ';';

  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;

  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.     }

  313.   putpacket (remcomOutBuffer);

  315.   stepping = 0;

  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;

  404.             if (hexToInt (&ptr, &regno) && *ptr++ == '=')
  405.               if (regno >= 0 && regno < NUMREGS)
  406.                 {
  407.                   int stackmode;

  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;

  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';

  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++ = ';';

  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++ = ';';

  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;

  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.             }

  501.           return;

  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;

  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;

  534.         case 'k':                /* kill the program */
  535.           continue;
  536.         }                        /* switch */

  538.       /* reply to the request */
  539.       putpacket (remcomOutBuffer);
  540.     }
  541. }

  543. /* qCRC support */

  545. /* Table used by the crc32 function to calcuate the checksum. */
  546. ‌static unsigned long crc32_table[256] = { 0, 0 };

  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;

  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.     }

  565.   while (len--)
  566.     {
  567.       crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
  568.       buf++;
  569.     }
  570.   return crc;
  571. }

  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. }

  585. /* scan for the sequence $<data>#<checksum>     */

  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;

  596.   while (1)
  597.     {
  598.       /* wait around for the start character, ignore all other characters */
  599.       while ((ch = getDebugChar ()) != '$')
  600.         ;

  602.     retry:
  603.       checksum = 0;
  604.       xmitcsum = -1;
  605.       count = 0;

  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;

  621.       if (ch == '#')
  622.         {
  623.           ch = getDebugChar ();
  624.           xmitcsum = hex (ch) << 4;
  625.           ch = getDebugChar ();
  626.           xmitcsum += hex (ch);

  628.           if (checksum != xmitcsum)
  629.             {
  630.               if (remote_debug)
  631.                 {
  632.                   unsigned char buf[16];

  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 */

  646.               /* if a sequence char is present, reply the sequence ID */
  647.               if (buffer[2] == ':')
  648.                 {
  649.                   putDebugChar (buffer[0]);
  650.                   putDebugChar (buffer[1]);

  652.                   return &buffer[3];
  653.                 }

  655.               return &buffer[0];
  656.             }
  657.         }
  658.     }
  659. }

  661. /* send the packet in buffer.  */

  663. static void
  664. ‌putpacket (unsigned char *buffer)
  665. {
  666.   unsigned char checksum;
  667.   int count;
  668.   char ch;

  670.   /*  $<packet info>#<checksum>. */
  671.   do
  672.     {
  673.       putDebugChar ('$');
  674.       checksum = 0;
  675.       count = 0;

  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. }

  690. /* Address of a routine to RTE to if we get a memory fault.  */

  692. ‌static void (*volatile mem_fault_routine) () = 0;

  694. static void
  695. ‌set_mem_err (void)
  696. {
  697.   mem_err = 1;
  698. }

  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. */

  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)

  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. }

  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. }

  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. }

  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.  */

  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;

  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. }

  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. */

  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;

  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. }

  804. /* Convert the binary stream in BUF to memory.

  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;

  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.         }

  837.       set_char (mem++, *buf++);

  839.       if (may_fault && mem_err)
  840.         return mem;
  841.     }

  843.   if (may_fault)
  844.     mem_fault_routine = 0;
  845.   return mem;
  846. }

  848. /* this function takes the m32r exception vector and attempts to
  849.    translate this number into a unix compatible signal value */

  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. }

  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;

  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. }

  944. /*
  945.   Table of branch instructions:

  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.   */

  968. static int
  969. ‌isShortBranch (unsigned char *instr)
  970. {
  971.   unsigned char instr0 = instr[0] & 0x7F;        /* mask off high bit */

  973.   if (instr0 == 0x10 && instr[1] == 0xB6)        /* RTE */
  974.     return 1;                        /* return from trap or exception */

  976.   if (instr0 == 0x1E || instr0 == 0x1F)        /* JL or JMP */
  977.     if ((instr[1] & 0xF0) == 0xC0)
  978.       return 2;                        /* jump thru a register */

  980.   if (instr0 == 0x7C || instr0 == 0x7D ||        /* BC, BNC, BL, BRA */
  981.       instr0 == 0x7E || instr0 == 0x7F)
  982.     return 3;                        /* eight bit PC offset */

  984.   return 0;
  985. }

  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. }

  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.  */

  1010. ‌#define INSTRUCTION_SIZE(addr) \
  1011.     ((((int) addr & 2) || (((unsigned char *) addr)[0] & 0x80) == 0) ? 2 : 4)

  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. }

  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. }

  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.     }

  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. }

  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. }

  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;

  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.

  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.  */

  1156. ‌#define TRAP1  0x10f1;                /* trap #1 instruction */
  1157. ‌#define NOOP   0x7000;                /* noop    instruction */

  1159. ‌static unsigned short trap1 = TRAP1;
  1160. ‌static unsigned short noop = NOOP;

  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;

  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;

  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. }

  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,

  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".  */

  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;

  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;

  1238.       for (p = (unsigned char *) &stepping;        /* zero out the stepping context */
  1239.            p < ((unsigned char *) &stepping) + sizeof (stepping); p++)
  1240.         *p = 0;

  1242.       return !(continue_p);
  1243.     }
  1244.   else                                /* we didn't single-step, therefore this must be a legitimate stop */
  1245.     return 1;
  1246. }

  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;

  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.  */

  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");

  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.  */

  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 */

  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

  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 */

  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. }

  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");

  1379. /* General trap handler, called after the registers have been stashed.
  1380.    NUM is the trap/exception number.  */

  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. }

  1395. void _catchException0 ();

  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");

  1405. void _catchException1 ();

  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");

  1425. void _catchException2 ();

  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");

  1435. void _catchException3 ();

  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");

  1445. void _catchException4 ();

  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");

  1455. void _catchException5 ();

  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");

  1465. void _catchException6 ();

  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");

  1475. void _catchException7 ();

  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");

  1485. void _catchException8 ();

  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");

  1495. void _catchException9 ();

  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");

  1505. void _catchException10 ();

  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");

  1515. void _catchException11 ();

  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");

  1525. void _catchException12 ();

  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");

  1535. void _catchException13 ();

  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");

  1545. void _catchException14 ();

  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");

  1555. void _catchException15 ();

  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");

  1565. void _catchException16 ();

  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");

  1575. void _catchException17 ();

  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");


  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;

  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);

  1598.   stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];

  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); */

  1619.   initialized = 1;
  1620. }

  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. */

  1627. ‌#define BREAKPOINT() asm volatile ("        trap #2");

  1629. void
  1630. ‌breakpoint (void)
  1631. {
  1632.   if (initialized)
  1633.     BREAKPOINT ();
  1634. }

  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.               */

  1644. /* Function: gdb_putchar(int)
  1645.    Make gdb write a char to stdout.
  1646.    Returns: the char */

  1648. static int
  1649. ‌gdb_putchar (int ch)
  1650. {
  1651.   char buf[4];

  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. }

  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 */

  1665. static int
  1666. ‌gdb_write (char *data, int len)
  1667. {
  1668.   char *buf, *cpy;
  1669.   int i;

  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. }

  1688. /* Function: gdb_puts(char *)
  1689.    Make gdb write a null-terminated string to stdout.
  1690.    Returns: the length of the string */

  1692. static int
  1693. ‌gdb_puts (char *str)
  1694. {
  1695.   return gdb_write (str, strlen (str));
  1696. }

  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.  */

  1703. static void
  1704. ‌gdb_error (char *format, char *parm)
  1705. {
  1706.   char buf[400], *cpy;
  1707.   int len;

  1709.   if (remote_debug)
  1710.     {
  1711.       if (format && *format)
  1712.         len = strlen (format);
  1713.       else
  1714.         return;                        /* empty input */

  1716.       if (parm && *parm)
  1717.         len += strlen (parm);

  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. }

  1735. static unsigned char *
  1736. ‌strcpy (unsigned char *dest, const unsigned char *src)
  1737. {
  1738.   unsigned char *ret = dest;

  1740.   if (dest && src)
  1741.     {
  1742.       while (*src)
  1743.         *dest++ = *src++;
  1744.       *dest = 0;
  1745.     }
  1746.   return ret;
  1747. }

  1749. static int
  1750. ‌strlen (const unsigned char *src)
  1751. {
  1752.   int ret;

  1754.   for (ret = 0; *src; src++)
  1755.     ret++;

  1757.   return ret;
  1758. }

  1760. #if 0
  1761. void
  1762. exit (code)
  1763.      int code;
  1764. {
  1765.   _exit (code);
  1766. }

  1768. int
  1769. atexit (void *p)
  1770. {
  1771.   return 0;
  1772. }

  1774. void
  1775. abort (void)
  1776. {
  1777.   _exit (1);
  1778. }
  1779. #endif