Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / stubs / m68k-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  *  To enable debugger support, two things need to happen.  One, a
33  *  call to set_debug_traps() is necessary in order to allow any breakpoints
34  *  or error conditions to be properly intercepted and reported to gdb.
35  *  Two, a breakpoint needs to be generated to begin communication.  This
36  *  is most easily accomplished by a call to breakpoint().  Breakpoint()
37  *  simulates a breakpoint by executing a trap #1.  The breakpoint instruction
38  *  is hardwired to trap #1 because not to do so is a compatibility problem--
39  *  there either should be a standard breakpoint instruction, or the protocol
40  *  should be extended to provide some means to communicate which breakpoint
41  *  instruction is in use (or have the stub insert the breakpoint).
42  *  
43  *  Some explanation is probably necessary to explain how exceptions are
44  *  handled.  When an exception is encountered the 68000 pushes the current
45  *  program counter and status register onto the supervisor stack and then
46  *  transfers execution to a location specified in it's vector table.
47  *  The handlers for the exception vectors are hardwired to jmp to an address
48  *  given by the relation:  (exception - 256) * 6.  These are decending 
49  *  addresses starting from -6, -12, -18, ...  By allowing 6 bytes for
50  *  each entry, a jsr, jmp, bsr, ... can be used to enter the exception 
51  *  handler.  Using a jsr to handle an exception has an added benefit of
52  *  allowing a single handler to service several exceptions and use the
53  *  return address as the key differentiation.  The vector number can be
54  *  computed from the return address by [ exception = (addr + 1530) / 6 ].
55  *  The sole purpose of the routine _catchException is to compute the
56  *  exception number and push it on the stack in place of the return address.
57  *  The external function exceptionHandler() is
58  *  used to attach a specific handler to a specific m68k exception.
59  *  For 68020 machines, the ability to have a return address around just
60  *  so the vector can be determined is not necessary because the '020 pushes an
61  *  extra word onto the stack containing the vector offset
62  * 
63  *  Because gdb will sometimes write to the stack area to execute function
64  *  calls, this program cannot rely on using the supervisor stack so it
65  *  uses it's own stack area reserved in the int array remcomStack.  
66  * 
67  *************
68  *
69  *    The following gdb commands are supported:
70  * 
71  * command          function                               Return value
72  * 
73  *    g             return the value of the CPU registers  hex data or ENN
74  *    G             set the value of the CPU registers     OK or ENN
75  * 
76  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
77  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
78  * 
79  *    c             Resume at current address              SNN   ( signal NN)
80  *    cAA..AA       Continue at address AA..AA             SNN
81  * 
82  *    s             Step one instruction                   SNN
83  *    sAA..AA       Step one instruction from AA..AA       SNN
84  * 
85  *    k             kill
86  *
87  *    ?             What was the last sigval ?             SNN   (signal NN)
88  * 
89  * All commands and responses are sent with a packet which includes a 
90  * checksum.  A packet consists of 
91  * 
92  * $<packet info>#<checksum>.
93  * 
94  * where
95  * <packet info> :: <characters representing the command or response>
96  * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
97  * 
98  * When a packet is received, it is first acknowledged with either '+' or '-'.
99  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
100  * 
101  * Example:
102  * 
103  * Host:                  Reply:
104  * $m0,10#2a               +$00010203040506070809101112131415#42
105  * 
106  ****************************************************************************/
107
108 #include <stdio.h>
109 #include <string.h>
110 #include <setjmp.h>
111
112 /************************************************************************
113  *
114  * external low-level support routines 
115  */
116 typedef void (*ExceptionHook)(int);   /* pointer to function with int parm */
117 typedef void (*Function)();           /* pointer to a function */
118
119 extern void putDebugChar();     /* write a single character      */
120 extern int getDebugChar();      /* read and return a single char */
121
122 extern Function exceptionHandler();  /* assign an exception handler */
123 extern ExceptionHook exceptionHook;  /* hook variable for errors/exceptions */
124
125 /************************/
126 /* FORWARD DECLARATIONS */
127 /************************/
128 static void
129 initializeRemcomErrorFrame ();
130
131 /************************************************************************/
132 /* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/
133 /* at least NUMREGBYTES*2 are needed for register packets */
134 #define BUFMAX 400
135
136 static char initialized;  /* boolean flag. != 0 means we've been initialized */
137
138 int     remote_debug;
139 /*  debug >  0 prints ill-formed commands in valid packets & checksum errors */ 
140
141 static const char hexchars[]="0123456789abcdef";
142
143 /* there are 180 bytes of registers on a 68020 w/68881      */
144 /* many of the fpa registers are 12 byte (96 bit) registers */
145 #define NUMREGBYTES 180
146 enum regnames {D0,D1,D2,D3,D4,D5,D6,D7, 
147                A0,A1,A2,A3,A4,A5,A6,A7, 
148                PS,PC,
149                FP0,FP1,FP2,FP3,FP4,FP5,FP6,FP7,
150                FPCONTROL,FPSTATUS,FPIADDR
151               };
152
153 \f
154 /* We keep a whole frame cache here.  "Why?", I hear you cry, "doesn't
155    GDB handle that sort of thing?"  Well, yes, I believe the only
156    reason for this cache is to save and restore floating point state
157    (fsave/frestore).  A cleaner way to do this would be to make the
158  fsave data part of the registers which GDB deals with like any
159    other registers.  This should not be a performance problem if the
160    ability to read individual registers is added to the protocol.  */
161
162 typedef struct FrameStruct
163 {
164     struct FrameStruct  *previous;
165     int       exceptionPC;      /* pc value when this frame created */
166     int       exceptionVector;  /* cpu vector causing exception     */
167     short     frameSize;        /* size of cpu frame in words       */
168     short     sr;               /* for 68000, this not always sr    */
169     int       pc;
170     short     format;
171     int       fsaveHeader;
172     int       morejunk[0];        /* exception frame, fp save... */
173 } Frame;
174
175 #define FRAMESIZE 500
176 int   gdbFrameStack[FRAMESIZE];
177 static Frame *lastFrame;
178
179 /*
180  * these should not be static cuz they can be used outside this module
181  */
182 int registers[NUMREGBYTES/4];
183 int superStack;
184
185 #define STACKSIZE 10000
186 int remcomStack[STACKSIZE/sizeof(int)];
187 static int* stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];
188
189 /*
190  * In many cases, the system will want to continue exception processing
191  * when a continue command is given.  
192  * oldExceptionHook is a function to invoke in this case.
193  */
194
195 static ExceptionHook oldExceptionHook;
196
197 #ifdef mc68020
198 /* the size of the exception stack on the 68020 varies with the type of
199  * exception.  The following table is the number of WORDS used
200  * for each exception format.
201  */
202 const short exceptionSize[] = { 4,4,6,4,4,4,4,4,29,10,16,46,12,4,4,4 };
203 #endif
204
205 #ifdef mc68332
206 static const short exceptionSize[] = { 4,4,6,4,4,4,4,4,4,4,4,4,16,4,4,4 };
207 #endif
208
209 /************* jump buffer used for setjmp/longjmp **************************/
210 jmp_buf remcomEnv;
211
212 /***************************  ASSEMBLY CODE MACROS *************************/
213 /*                                                                         */
214
215 #ifdef __HAVE_68881__
216 /* do an fsave, then remember the address to begin a restore from */
217 #define SAVE_FP_REGS()    asm(" fsave   a0@-");         \
218                           asm(" fmovemx fp0-fp7,_registers+72");        \
219                           asm(" fmoveml fpcr/fpsr/fpi,_registers+168"); 
220 #define RESTORE_FP_REGS()                              \
221 asm("                                                \n\
222     fmoveml  _registers+168,fpcr/fpsr/fpi            \n\
223     fmovemx  _registers+72,fp0-fp7                   \n\
224     cmpl     #-1,a0@     |  skip frestore flag set ? \n\
225     beq      skip_frestore                           \n\
226     frestore a0@+                                    \n\
227 skip_frestore:                                       \n\
228 ");
229
230 #else
231 #define SAVE_FP_REGS()
232 #define RESTORE_FP_REGS()
233 #endif /* __HAVE_68881__ */
234
235 void return_to_super();
236 void return_to_user();
237
238 asm("
239 .text
240 .globl _return_to_super
241 _return_to_super:
242         movel   _registers+60,sp /* get new stack pointer */        
243         movel   _lastFrame,a0   /* get last frame info  */              
244         bra     return_to_any
245
246 .globl _return_to_user
247 _return_to_user:
248         movel   _registers+60,a0 /* get usp */                          
249         movel   a0,usp           /* set usp */                          
250         movel   _superStack,sp  /* get original stack pointer */        
251
252 return_to_any:
253         movel   _lastFrame,a0   /* get last frame info  */              
254         movel   a0@+,_lastFrame /* link in previous frame     */        
255         addql   #8,a0           /* skip over pc, vector#*/              
256         movew   a0@+,d0         /* get # of words in cpu frame */       
257         addw    d0,a0           /* point to end of data        */       
258         addw    d0,a0           /* point to end of data        */       
259         movel   a0,a1                                                   
260 #                                                                       
261 # copy the stack frame                                                  
262         subql   #1,d0                                                   
263 copyUserLoop:                                                               
264         movew   a1@-,sp@-                                               
265         dbf     d0,copyUserLoop                                             
266 ");                                                                     
267         RESTORE_FP_REGS()                                              
268    asm("   moveml  _registers,d0-d7/a0-a6");                            
269    asm("   rte");  /* pop and go! */                                    
270
271 #define DISABLE_INTERRUPTS()   asm("         oriw   #0x0700,sr");
272 #define BREAKPOINT() asm("   trap #1");
273
274 /* this function is called immediately when a level 7 interrupt occurs */
275 /* if the previous interrupt level was 7 then we're already servicing  */
276 /* this interrupt and an rte is in order to return to the debugger.    */
277 /* For the 68000, the offset for sr is 6 due to the jsr return address */
278 asm("
279 .text
280 .globl __debug_level7
281 __debug_level7:
282         movew   d0,sp@-");
283 #if defined (mc68020) || defined (mc68332)
284 asm("   movew   sp@(2),d0");
285 #else
286 asm("   movew   sp@(6),d0");
287 #endif
288 asm("   andiw   #0x700,d0
289         cmpiw   #0x700,d0
290         beq     _already7
291         movew   sp@+,d0 
292         bra     __catchException
293 _already7:
294         movew   sp@+,d0");
295 #if !defined (mc68020) && !defined (mc68332)
296 asm("   lea     sp@(4),sp");     /* pull off 68000 return address */
297 #endif
298 asm("   rte");
299
300 extern void _catchException ();
301
302 #if defined (mc68020) || defined (mc68332)
303 /* This function is called when a 68020 exception occurs.  It saves
304  * all the cpu and fpcp regs in the _registers array, creates a frame on a
305  * linked list of frames which has the cpu and fpcp stack frames needed
306  * to properly restore the context of these processors, and invokes
307  * an exception handler (remcom_handler).
308  *
309  * stack on entry:                       stack on exit:
310  *   N bytes of junk                     exception # MSWord
311  *   Exception Format Word               exception # MSWord
312  *   Program counter LSWord              
313  *   Program counter MSWord             
314  *   Status Register                    
315  *                                       
316  *                                       
317  */
318 asm(" 
319 .text
320 .globl __catchException
321 __catchException:");
322 DISABLE_INTERRUPTS();
323 asm("
324         moveml  d0-d7/a0-a6,_registers /* save registers        */
325         movel   _lastFrame,a0   /* last frame pointer */
326 ");
327 SAVE_FP_REGS();        
328 asm("
329         lea     _registers,a5   /* get address of registers     */
330         movew   sp@,d1          /* get status register          */
331         movew   d1,a5@(66)      /* save sr                      */      
332         movel   sp@(2),a4       /* save pc in a4 for later use  */
333         movel   a4,a5@(68)      /* save pc in _regisers[]       */
334
335 #
336 # figure out how many bytes in the stack frame
337         movew   sp@(6),d0       /* get '020 exception format    */
338         movew   d0,d2           /* make a copy of format word   */
339         andiw   #0xf000,d0      /* mask off format type         */
340         rolw    #5,d0           /* rotate into the low byte *2  */
341         lea     _exceptionSize,a1   
342         addw    d0,a1           /* index into the table         */
343         movew   a1@,d0          /* get number of words in frame */
344         movew   d0,d3           /* save it                      */
345         subw    d0,a0           /* adjust save pointer          */
346         subw    d0,a0           /* adjust save pointer(bytes)   */
347         movel   a0,a1           /* copy save pointer            */
348         subql   #1,d0           /* predecrement loop counter    */
349 #
350 # copy the frame
351 saveFrameLoop:
352         movew   sp@+,a1@+
353         dbf     d0,saveFrameLoop
354 #
355 # now that the stack has been clenaed,
356 # save the a7 in use at time of exception
357         movel   sp,_superStack  /* save supervisor sp           */
358         andiw   #0x2000,d1      /* were we in supervisor mode ? */
359         beq     userMode       
360         movel   a7,a5@(60)      /* save a7                  */
361         bra     a7saveDone
362 userMode:  
363         movel   usp,a1          
364         movel   a1,a5@(60)      /* save user stack pointer      */
365 a7saveDone:
366
367 #
368 # save size of frame
369         movew   d3,a0@-
370
371 #
372 # compute exception number
373         andl    #0xfff,d2       /* mask off vector offset       */
374         lsrw    #2,d2           /* divide by 4 to get vect num  */
375         movel   d2,a0@-         /* save it                      */
376 #
377 # save pc causing exception
378         movel   a4,a0@-
379 #
380 # save old frame link and set the new value
381         movel   _lastFrame,a1   /* last frame pointer */
382         movel   a1,a0@-         /* save pointer to prev frame   */
383         movel   a0,_lastFrame
384
385         movel   d2,sp@-         /* push exception num           */
386         movel   _exceptionHook,a0  /* get address of handler */
387         jbsr    a0@             /* and call it */
388         clrl    sp@             /* replace exception num parm with frame ptr */
389         jbsr     __returnFromException   /* jbsr, but never returns */
390 ");
391 #else /* mc68000 */
392 /* This function is called when an exception occurs.  It translates the
393  * return address found on the stack into an exception vector # which
394  * is then handled by either handle_exception or a system handler.
395  * _catchException provides a front end for both.  
396  *
397  * stack on entry:                       stack on exit:
398  *   Program counter MSWord              exception # MSWord 
399  *   Program counter LSWord              exception # MSWord
400  *   Status Register                     
401  *   Return Address  MSWord              
402  *   Return Address  LSWord             
403  */
404 asm("
405 .text
406 .globl __catchException
407 __catchException:");
408 DISABLE_INTERRUPTS();
409 asm("
410         moveml d0-d7/a0-a6,_registers  /* save registers               */
411         movel   _lastFrame,a0   /* last frame pointer */
412 ");
413 SAVE_FP_REGS();        
414 asm("
415         lea     _registers,a5   /* get address of registers     */
416         movel   sp@+,d2         /* pop return address           */
417         addl    #1530,d2        /* convert return addr to       */
418         divs    #6,d2           /*  exception number            */
419         extl    d2   
420
421         moveql  #3,d3           /* assume a three word frame     */
422
423         cmpiw   #3,d2           /* bus error or address error ? */
424         bgt     normal          /* if >3 then normal error      */
425         movel   sp@+,a0@-       /* copy error info to frame buff*/
426         movel   sp@+,a0@-       /* these are never used         */
427         moveql  #7,d3           /* this is a 7 word frame       */
428      
429 normal:   
430         movew   sp@+,d1         /* pop status register          */
431         movel   sp@+,a4         /* pop program counter          */
432         movew   d1,a5@(66)      /* save sr                      */      
433         movel   a4,a5@(68)      /* save pc in _regisers[]       */
434         movel   a4,a0@-         /* copy pc to frame buffer      */
435         movew   d1,a0@-         /* copy sr to frame buffer      */
436
437         movel   sp,_superStack  /* save supervisor sp          */
438
439         andiw   #0x2000,d1      /* were we in supervisor mode ? */
440         beq     userMode       
441         movel   a7,a5@(60)      /* save a7                  */
442         bra     saveDone             
443 userMode:
444         movel   usp,a1          /* save user stack pointer      */
445         movel   a1,a5@(60)      /* save user stack pointer      */
446 saveDone:
447
448         movew   d3,a0@-         /* push frame size in words     */
449         movel   d2,a0@-         /* push vector number           */
450         movel   a4,a0@-         /* push exception pc            */
451
452 #
453 # save old frame link and set the new value
454         movel   _lastFrame,a1   /* last frame pointer */
455         movel   a1,a0@-         /* save pointer to prev frame   */
456         movel   a0,_lastFrame
457
458         movel   d2,sp@-         /* push exception num           */
459         movel   _exceptionHook,a0  /* get address of handler */
460         jbsr    a0@             /* and call it */
461         clrl    sp@             /* replace exception num parm with frame ptr */
462         jbsr     __returnFromException   /* jbsr, but never returns */
463 ");
464 #endif
465
466
467 /*
468  * remcomHandler is a front end for handle_exception.  It moves the
469  * stack pointer into an area reserved for debugger use in case the
470  * breakpoint happened in supervisor mode.
471  */
472 asm("_remcomHandler:");
473 asm("           addl    #4,sp");        /* pop off return address     */
474 asm("           movel   sp@+,d0");      /* get the exception number   */
475 asm("           movel   _stackPtr,sp"); /* move to remcom stack area  */
476 asm("           movel   d0,sp@-");      /* push exception onto stack  */
477 asm("           jbsr    _handle_exception");    /* this never returns */
478 asm("           rts");                  /* return */
479
480 void
481 _returnFromException (Frame * frame)
482 {
483   /* if no passed in frame, use the last one */
484   if (!frame)
485     {
486       frame = lastFrame;
487       frame->frameSize = 4;
488       frame->format = 0;
489       frame->fsaveHeader = -1;  /* restore regs, but we dont have fsave info */
490     }
491
492 #if !defined (mc68020) && !defined (mc68332)
493   /* a 68000 cannot use the internal info pushed onto a bus error
494    * or address error frame when doing an RTE so don't put this info
495    * onto the stack or the stack will creep every time this happens.
496    */
497   frame->frameSize = 3;
498 #endif
499
500   /* throw away any frames in the list after this frame */
501   lastFrame = frame;
502
503   frame->sr = registers[(int) PS];
504   frame->pc = registers[(int) PC];
505
506   if (registers[(int) PS] & 0x2000)
507     {
508       /* return to supervisor mode... */
509       return_to_super ();
510     }
511   else
512     {                           /* return to user mode */
513       return_to_user ();
514     }
515 }
516
517 int
518 hex (ch)
519      char ch;
520 {
521   if ((ch >= 'a') && (ch <= 'f'))
522     return (ch - 'a' + 10);
523   if ((ch >= '0') && (ch <= '9'))
524     return (ch - '0');
525   if ((ch >= 'A') && (ch <= 'F'))
526     return (ch - 'A' + 10);
527   return (-1);
528 }
529
530 static char remcomInBuffer[BUFMAX];
531 static char remcomOutBuffer[BUFMAX];
532
533 /* scan for the sequence $<data>#<checksum>     */
534
535 unsigned char *
536 getpacket (void)
537 {
538   unsigned char *buffer = &remcomInBuffer[0];
539   unsigned char checksum;
540   unsigned char xmitcsum;
541   int count;
542   char ch;
543
544   while (1)
545     {
546       /* wait around for the start character, ignore all other characters */
547       while ((ch = getDebugChar ()) != '$')
548         ;
549
550     retry:
551       checksum = 0;
552       xmitcsum = -1;
553       count = 0;
554
555       /* now, read until a # or end of buffer is found */
556       while (count < BUFMAX - 1)
557         {
558           ch = getDebugChar ();
559           if (ch == '$')
560             goto retry;
561           if (ch == '#')
562             break;
563           checksum = checksum + ch;
564           buffer[count] = ch;
565           count = count + 1;
566         }
567       buffer[count] = 0;
568
569       if (ch == '#')
570         {
571           ch = getDebugChar ();
572           xmitcsum = hex (ch) << 4;
573           ch = getDebugChar ();
574           xmitcsum += hex (ch);
575
576           if (checksum != xmitcsum)
577             {
578               if (remote_debug)
579                 {
580                   fprintf (stderr,
581                            "bad checksum.  My count = 0x%x, sent=0x%x. buf=%s\n",
582                            checksum, xmitcsum, buffer);
583                 }
584               putDebugChar ('-');       /* failed checksum */
585             }
586           else
587             {
588               putDebugChar ('+');       /* successful transfer */
589
590               /* if a sequence char is present, reply the sequence ID */
591               if (buffer[2] == ':')
592                 {
593                   putDebugChar (buffer[0]);
594                   putDebugChar (buffer[1]);
595
596                   return &buffer[3];
597                 }
598
599               return &buffer[0];
600             }
601         }
602     }
603 }
604
605 /* send the packet in buffer. */
606
607 void
608 putpacket (buffer)
609      char *buffer;
610 {
611   unsigned char checksum;
612   int count;
613   char ch;
614
615   /*  $<packet info>#<checksum>. */
616   do
617     {
618       putDebugChar ('$');
619       checksum = 0;
620       count = 0;
621
622       while (ch = buffer[count])
623         {
624           putDebugChar (ch);
625           checksum += ch;
626           count += 1;
627         }
628
629       putDebugChar ('#');
630       putDebugChar (hexchars[checksum >> 4]);
631       putDebugChar (hexchars[checksum % 16]);
632
633     }
634   while (getDebugChar () != '+');
635
636 }
637
638 void
639 debug_error (format, parm)
640      char *format;
641      char *parm;
642 {
643   if (remote_debug)
644     fprintf (stderr, format, parm);
645 }
646
647 /* convert the memory pointed to by mem into hex, placing result in buf */
648 /* return a pointer to the last char put in buf (null) */
649 char *
650 mem2hex (mem, buf, count)
651      char *mem;
652      char *buf;
653      int count;
654 {
655   int i;
656   unsigned char ch;
657   for (i = 0; i < count; i++)
658     {
659       ch = *mem++;
660       *buf++ = hexchars[ch >> 4];
661       *buf++ = hexchars[ch % 16];
662     }
663   *buf = 0;
664   return (buf);
665 }
666
667 /* convert the hex array pointed to by buf into binary to be placed in mem */
668 /* return a pointer to the character AFTER the last byte written */
669 char *
670 hex2mem (buf, mem, count)
671      char *buf;
672      char *mem;
673      int count;
674 {
675   int i;
676   unsigned char ch;
677   for (i = 0; i < count; i++)
678     {
679       ch = hex (*buf++) << 4;
680       ch = ch + hex (*buf++);
681       *mem++ = ch;
682     }
683   return (mem);
684 }
685
686 /* a bus error has occurred, perform a longjmp
687    to return execution and allow handling of the error */
688
689 void
690 handle_buserror ()
691 {
692   longjmp (remcomEnv, 1);
693 }
694
695 /* this function takes the 68000 exception number and attempts to 
696    translate this number into a unix compatible signal value */
697 int
698 computeSignal (exceptionVector)
699      int exceptionVector;
700 {
701   int sigval;
702   switch (exceptionVector)
703     {
704     case 2:
705       sigval = 10;
706       break;                    /* bus error           */
707     case 3:
708       sigval = 10;
709       break;                    /* address error       */
710     case 4:
711       sigval = 4;
712       break;                    /* illegal instruction */
713     case 5:
714       sigval = 8;
715       break;                    /* zero divide         */
716     case 6:
717       sigval = 8;
718       break;                    /* chk instruction     */
719     case 7:
720       sigval = 8;
721       break;                    /* trapv instruction   */
722     case 8:
723       sigval = 11;
724       break;                    /* privilege violation */
725     case 9:
726       sigval = 5;
727       break;                    /* trace trap          */
728     case 10:
729       sigval = 4;
730       break;                    /* line 1010 emulator  */
731     case 11:
732       sigval = 4;
733       break;                    /* line 1111 emulator  */
734
735       /* Coprocessor protocol violation.  Using a standard MMU or FPU
736          this cannot be triggered by software.  Call it a SIGBUS.  */
737     case 13:
738       sigval = 10;
739       break;
740
741     case 31:
742       sigval = 2;
743       break;                    /* interrupt           */
744     case 33:
745       sigval = 5;
746       break;                    /* breakpoint          */
747
748       /* This is a trap #8 instruction.  Apparently it is someone's software
749          convention for some sort of SIGFPE condition.  Whose?  How many
750          people are being screwed by having this code the way it is?
751          Is there a clean solution?  */
752     case 40:
753       sigval = 8;
754       break;                    /* floating point err  */
755
756     case 48:
757       sigval = 8;
758       break;                    /* floating point err  */
759     case 49:
760       sigval = 8;
761       break;                    /* floating point err  */
762     case 50:
763       sigval = 8;
764       break;                    /* zero divide         */
765     case 51:
766       sigval = 8;
767       break;                    /* underflow           */
768     case 52:
769       sigval = 8;
770       break;                    /* operand error       */
771     case 53:
772       sigval = 8;
773       break;                    /* overflow            */
774     case 54:
775       sigval = 8;
776       break;                    /* NAN                 */
777     default:
778       sigval = 7;               /* "software generated" */
779     }
780   return (sigval);
781 }
782
783 /**********************************************/
784 /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
785 /* RETURN NUMBER OF CHARS PROCESSED           */
786 /**********************************************/
787 int
788 hexToInt (char **ptr, int *intValue)
789 {
790   int numChars = 0;
791   int hexValue;
792
793   *intValue = 0;
794
795   while (**ptr)
796     {
797       hexValue = hex (**ptr);
798       if (hexValue >= 0)
799         {
800           *intValue = (*intValue << 4) | hexValue;
801           numChars++;
802         }
803       else
804         break;
805
806       (*ptr)++;
807     }
808
809   return (numChars);
810 }
811
812 /*
813  * This function does all command procesing for interfacing to gdb.
814  */
815 void
816 handle_exception (int exceptionVector)
817 {
818   int sigval, stepping;
819   int addr, length;
820   char *ptr;
821   int newPC;
822   Frame *frame;
823
824   if (remote_debug)
825     printf ("vector=%d, sr=0x%x, pc=0x%x\n",
826             exceptionVector, registers[PS], registers[PC]);
827
828   /* reply to host that an exception has occurred */
829   sigval = computeSignal (exceptionVector);
830   remcomOutBuffer[0] = 'S';
831   remcomOutBuffer[1] = hexchars[sigval >> 4];
832   remcomOutBuffer[2] = hexchars[sigval % 16];
833   remcomOutBuffer[3] = 0;
834
835   putpacket (remcomOutBuffer);
836
837   stepping = 0;
838
839   while (1 == 1)
840     {
841       remcomOutBuffer[0] = 0;
842       ptr = getpacket ();
843       switch (*ptr++)
844         {
845         case '?':
846           remcomOutBuffer[0] = 'S';
847           remcomOutBuffer[1] = hexchars[sigval >> 4];
848           remcomOutBuffer[2] = hexchars[sigval % 16];
849           remcomOutBuffer[3] = 0;
850           break;
851         case 'd':
852           remote_debug = !(remote_debug);       /* toggle debug flag */
853           break;
854         case 'g':               /* return the value of the CPU registers */
855           mem2hex ((char *) registers, remcomOutBuffer, NUMREGBYTES);
856           break;
857         case 'G':               /* set the value of the CPU registers - return OK */
858           hex2mem (ptr, (char *) registers, NUMREGBYTES);
859           strcpy (remcomOutBuffer, "OK");
860           break;
861
862           /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
863         case 'm':
864           if (setjmp (remcomEnv) == 0)
865             {
866               exceptionHandler (2, handle_buserror);
867
868               /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
869               if (hexToInt (&ptr, &addr))
870                 if (*(ptr++) == ',')
871                   if (hexToInt (&ptr, &length))
872                     {
873                       ptr = 0;
874                       mem2hex ((char *) addr, remcomOutBuffer, length);
875                     }
876
877               if (ptr)
878                 {
879                   strcpy (remcomOutBuffer, "E01");
880                 }
881             }
882           else
883             {
884               exceptionHandler (2, _catchException);
885               strcpy (remcomOutBuffer, "E03");
886               debug_error ("bus error");
887             }
888
889           /* restore handler for bus error */
890           exceptionHandler (2, _catchException);
891           break;
892
893           /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
894         case 'M':
895           if (setjmp (remcomEnv) == 0)
896             {
897               exceptionHandler (2, handle_buserror);
898
899               /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
900               if (hexToInt (&ptr, &addr))
901                 if (*(ptr++) == ',')
902                   if (hexToInt (&ptr, &length))
903                     if (*(ptr++) == ':')
904                       {
905                         hex2mem (ptr, (char *) addr, length);
906                         ptr = 0;
907                         strcpy (remcomOutBuffer, "OK");
908                       }
909               if (ptr)
910                 {
911                   strcpy (remcomOutBuffer, "E02");
912                 }
913             }
914           else
915             {
916               exceptionHandler (2, _catchException);
917               strcpy (remcomOutBuffer, "E03");
918               debug_error ("bus error");
919             }
920
921           /* restore handler for bus error */
922           exceptionHandler (2, _catchException);
923           break;
924
925           /* cAA..AA    Continue at address AA..AA(optional) */
926           /* sAA..AA   Step one instruction from AA..AA(optional) */
927         case 's':
928           stepping = 1;
929         case 'c':
930           /* try to read optional parameter, pc unchanged if no parm */
931           if (hexToInt (&ptr, &addr))
932             registers[PC] = addr;
933
934           newPC = registers[PC];
935
936           /* clear the trace bit */
937           registers[PS] &= 0x7fff;
938
939           /* set the trace bit if we're stepping */
940           if (stepping)
941             registers[PS] |= 0x8000;
942
943           /*
944            * look for newPC in the linked list of exception frames.
945            * if it is found, use the old frame it.  otherwise,
946            * fake up a dummy frame in returnFromException().
947            */
948           if (remote_debug)
949             printf ("new pc = 0x%x\n", newPC);
950           frame = lastFrame;
951           while (frame)
952             {
953               if (remote_debug)
954                 printf ("frame at 0x%x has pc=0x%x, except#=%d\n",
955                         frame, frame->exceptionPC, frame->exceptionVector);
956               if (frame->exceptionPC == newPC)
957                 break;          /* bingo! a match */
958               /*
959                * for a breakpoint instruction, the saved pc may
960                * be off by two due to re-executing the instruction
961                * replaced by the trap instruction.  Check for this.
962                */
963               if ((frame->exceptionVector == 33) &&
964                   (frame->exceptionPC == (newPC + 2)))
965                 break;
966               if (frame == frame->previous)
967                 {
968                   frame = 0;    /* no match found */
969                   break;
970                 }
971               frame = frame->previous;
972             }
973
974           /*
975            * If we found a match for the PC AND we are not returning
976            * as a result of a breakpoint (33),
977            * trace exception (9), nmi (31), jmp to
978            * the old exception handler as if this code never ran.
979            */
980           if (frame)
981             {
982               if ((frame->exceptionVector != 9) &&
983                   (frame->exceptionVector != 31) &&
984                   (frame->exceptionVector != 33))
985                 {
986                   /*
987                    * invoke the previous handler.
988                    */
989                   if (oldExceptionHook)
990                     (*oldExceptionHook) (frame->exceptionVector);
991                   newPC = registers[PC];        /* pc may have changed  */
992                   if (newPC != frame->exceptionPC)
993                     {
994                       if (remote_debug)
995                         printf ("frame at 0x%x has pc=0x%x, except#=%d\n",
996                                 frame, frame->exceptionPC,
997                                 frame->exceptionVector);
998                       /* re-use the last frame, we're skipping it (longjump?) */
999                       frame = (Frame *) 0;
1000                       _returnFromException (frame);     /* this is a jump */
1001                     }
1002                 }
1003             }
1004
1005           /* if we couldn't find a frame, create one */
1006           if (frame == 0)
1007             {
1008               frame = lastFrame - 1;
1009
1010               /* by using a bunch of print commands with breakpoints,
1011                  it's possible for the frame stack to creep down.  If it creeps
1012                  too far, give up and reset it to the top.  Normal use should
1013                  not see this happen.
1014                */
1015               if ((unsigned int) (frame - 2) < (unsigned int) &gdbFrameStack)
1016                 {
1017                   initializeRemcomErrorFrame ();
1018                   frame = lastFrame;
1019                 }
1020               frame->previous = lastFrame;
1021               lastFrame = frame;
1022               frame = 0;        /* null so _return... will properly initialize it */
1023             }
1024
1025           _returnFromException (frame); /* this is a jump */
1026
1027           break;
1028
1029           /* kill the program */
1030         case 'k':               /* do nothing */
1031           break;
1032         }                       /* switch */
1033
1034       /* reply to the request */
1035       putpacket (remcomOutBuffer);
1036     }
1037 }
1038
1039
1040 void
1041 initializeRemcomErrorFrame (void)
1042 {
1043   lastFrame = ((Frame *) & gdbFrameStack[FRAMESIZE - 1]) - 1;
1044   lastFrame->previous = lastFrame;
1045 }
1046
1047 /* this function is used to set up exception handlers for tracing and 
1048    breakpoints */
1049 void
1050 set_debug_traps ()
1051 {
1052   extern void _debug_level7 ();
1053   extern void remcomHandler ();
1054   int exception;
1055
1056   initializeRemcomErrorFrame ();
1057   stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
1058
1059   for (exception = 2; exception <= 23; exception++)
1060     exceptionHandler (exception, _catchException);
1061
1062   /* level 7 interrupt              */
1063   exceptionHandler (31, _debug_level7);
1064
1065   /* breakpoint exception (trap #1) */
1066   exceptionHandler (33, _catchException);
1067
1068   /* This is a trap #8 instruction.  Apparently it is someone's software
1069      convention for some sort of SIGFPE condition.  Whose?  How many
1070      people are being screwed by having this code the way it is?
1071      Is there a clean solution?  */
1072   exceptionHandler (40, _catchException);
1073
1074   /* 48 to 54 are floating point coprocessor errors */
1075   for (exception = 48; exception <= 54; exception++)
1076     exceptionHandler (exception, _catchException);
1077
1078   if (oldExceptionHook != remcomHandler)
1079     {
1080       oldExceptionHook = exceptionHook;
1081       exceptionHook = remcomHandler;
1082     }
1083
1084   initialized = 1;
1085
1086 }
1087
1088 /* This function will generate a breakpoint exception.  It is used at the
1089    beginning of a program to sync up with a debugger and can be used
1090    otherwise as a quick means to stop program execution and "break" into
1091    the debugger. */
1092
1093 void
1094 breakpoint ()
1095 {
1096   if (initialized)
1097     BREAKPOINT ();
1098 }