X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fm68k-stub.c;h=4ef4069bc3dfab4ad7b740826c0be597fd064da3;hb=b2182ed226dfa161296df892b2f12650d67c0ba0;hp=ae7553ac25a31871604a19ca4278f37965455c89;hpb=bd313dad25f56b7bacbedad0ea1fc5977350a764;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m68k-stub.c b/gdb/m68k-stub.c index ae7553ac25..4ef4069bc3 100644 --- a/gdb/m68k-stub.c +++ b/gdb/m68k-stub.c @@ -13,28 +13,32 @@ ****************************************************************************/ /**************************************************************************** - * $Header$ + * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $ * - * $Module name: remcom.c $ - * $Revision$ - * $Date$ - * $Contributor: Lake Stevens Instrument Division$ + * Module name: remcom.c $ + * Revision: 1.34 $ + * Date: 91/03/09 12:29:49 $ + * Contributor: Lake Stevens Instrument Division$ * - * $Description: low level support for gdb debugger. $ + * Description: low level support for gdb debugger. $ * - * $Considerations: only works on target hardware $ + * Considerations: only works on target hardware $ * - * $Written by: Glenn Engel $ - * $ModuleState: Experimental $ + * Written by: Glenn Engel $ + * ModuleState: Experimental $ * - * $NOTES: See Below $ + * NOTES: See Below $ * * To enable debugger support, two things need to happen. One, a * call to set_debug_traps() is necessary in order to allow any breakpoints * or error conditions to be properly intercepted and reported to gdb. * Two, a breakpoint needs to be generated to begin communication. This * is most easily accomplished by a call to breakpoint(). Breakpoint() - * simulates a breakpoint by executing a trap #1. + * simulates a breakpoint by executing a trap #1. The breakpoint instruction + * is hardwired to trap #1 because not to do so is a compatibility problem-- + * there either should be a standard breakpoint instruction, or the protocol + * should be extended to provide some means to communicate which breakpoint + * instruction is in use (or have the stub insert the breakpoint). * * Some explanation is probably necessary to explain how exceptions are * handled. When an exception is encountered the 68000 pushes the current @@ -51,7 +55,7 @@ * The sole purpose of the routine _catchException is to compute the * exception number and push it on the stack in place of the return address. * The external function exceptionHandler() is - * used to attach a specific handler to a specific 68k exception. + * used to attach a specific handler to a specific m68k exception. * For 68020 machines, the ability to have a return address around just * so the vector can be determined is not necessary because the '020 pushes an * extra word onto the stack containing the vector offset @@ -112,8 +116,8 @@ typedef void (*ExceptionHook)(int); /* pointer to function with int parm */ typedef void (*Function)(); /* pointer to a function */ -extern putDebugChar(); /* write a single character */ -extern getDebugChar(); /* read and return a single char */ +extern void putDebugChar(); /* write a single character */ +extern int getDebugChar(); /* read and return a single char */ extern Function exceptionHandler(); /* assign an exception handler */ extern ExceptionHook exceptionHook; /* hook variable for errors/exceptions */ @@ -121,7 +125,8 @@ extern ExceptionHook exceptionHook; /* hook variable for errors/exceptions */ /************************/ /* FORWARD DECLARATIONS */ /************************/ -void initializeRemcomErrorFrame(void); +static void +initializeRemcomErrorFrame (); /************************************************************************/ /* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/ @@ -145,6 +150,15 @@ enum regnames {D0,D1,D2,D3,D4,D5,D6,D7, FPCONTROL,FPSTATUS,FPIADDR }; + +/* We keep a whole frame cache here. "Why?", I hear you cry, "doesn't + GDB handle that sort of thing?" Well, yes, I believe the only + reason for this cache is to save and restore floating point state + (fsave/frestore). A cleaner way to do this would be to make the + fsave data part of the registers which GDB deals with like any + other registers. This should not be a performance problem if the + ability to read individual registers is added to the protocol. */ + typedef struct FrameStruct { struct FrameStruct *previous; @@ -180,11 +194,17 @@ static int* stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1]; static ExceptionHook oldExceptionHook; +#ifdef mc68020 /* the size of the exception stack on the 68020 varies with the type of * exception. The following table is the number of WORDS used * for each exception format. */ const short exceptionSize[] = { 4,4,6,4,4,4,4,4,29,10,16,46,12,4,4,4 }; +#endif + +#ifdef mc68332 +static const short exceptionSize[] = { 4,4,6,4,4,4,4,4,4,4,4,4,16,4,4,4 }; +#endif /************* jump buffer used for setjmp/longjmp **************************/ jmp_buf remcomEnv; @@ -212,8 +232,8 @@ skip_frestore: \n\ #define RESTORE_FP_REGS() #endif /* __HAVE_68881__ */ -void return_to_super(void); -void return_to_user(void); +void return_to_super(); +void return_to_user(); asm(" .text @@ -260,7 +280,7 @@ asm(" .globl __debug_level7 __debug_level7: movew d0,sp@-"); -#ifdef mc68020 +#if defined (mc68020) || defined (mc68332) asm(" movew sp@(2),d0"); #else asm(" movew sp@(6),d0"); @@ -272,14 +292,14 @@ asm(" andiw #0x700,d0 bra __catchException _already7: movew sp@+,d0"); -#ifndef mc68020 +#if !defined (mc68020) && !defined (mc68332) asm(" lea sp@(4),sp"); /* pull off 68000 return address */ #endif asm(" rte"); -extern void _catchException(); +extern void _catchException (); -#ifdef mc68020 +#if defined (mc68020) || defined (mc68332) /* This function is called when a 68020 exception occurs. It saves * all the cpu and fpcp regs in the _registers array, creates a frame on a * linked list of frames which has the cpu and fpcp stack frames needed @@ -457,222 +477,306 @@ asm(" movel d0,sp@-"); /* push exception onto stack */ asm(" jbsr _handle_exception"); /* this never returns */ asm(" rts"); /* return */ -void _returnFromException( Frame *frame ) +void +_returnFromException (Frame * frame) { - /* if no passed in frame, use the last one */ - if (! frame) + /* if no passed in frame, use the last one */ + if (!frame) { - frame = lastFrame; - frame->frameSize = 4; - frame->format = 0; - frame->fsaveHeader = -1; /* restore regs, but we dont have fsave info*/ + frame = lastFrame; + frame->frameSize = 4; + frame->format = 0; + frame->fsaveHeader = -1; /* restore regs, but we dont have fsave info */ } -#ifndef mc68020 - /* a 68000 cannot use the internal info pushed onto a bus error - * or address error frame when doing an RTE so don't put this info - * onto the stack or the stack will creep every time this happens. - */ - frame->frameSize=3; +#if !defined (mc68020) && !defined (mc68332) + /* a 68000 cannot use the internal info pushed onto a bus error + * or address error frame when doing an RTE so don't put this info + * onto the stack or the stack will creep every time this happens. + */ + frame->frameSize = 3; #endif - /* throw away any frames in the list after this frame */ - lastFrame = frame; + /* throw away any frames in the list after this frame */ + lastFrame = frame; - frame->sr = registers[(int) PS]; - frame->pc = registers[(int) PC]; + frame->sr = registers[(int) PS]; + frame->pc = registers[(int) PC]; - if (registers[(int) PS] & 0x2000) - { - /* return to supervisor mode... */ - return_to_super(); + if (registers[(int) PS] & 0x2000) + { + /* return to supervisor mode... */ + return_to_super (); } - else - { /* return to user mode */ - return_to_user(); + else + { /* return to user mode */ + return_to_user (); } } -int hex(ch) -char ch; +int +hex (ch) + char ch; { - if ((ch >= 'a') && (ch <= 'f')) return (ch-'a'+10); - if ((ch >= '0') && (ch <= '9')) return (ch-'0'); - if ((ch >= 'A') && (ch <= 'F')) return (ch-'A'+10); + if ((ch >= 'a') && (ch <= 'f')) + return (ch - 'a' + 10); + if ((ch >= '0') && (ch <= '9')) + return (ch - '0'); + if ((ch >= 'A') && (ch <= 'F')) + return (ch - 'A' + 10); return (-1); } +static char remcomInBuffer[BUFMAX]; +static char remcomOutBuffer[BUFMAX]; /* scan for the sequence $# */ -void getpacket(buffer) -char * buffer; + +unsigned char * +getpacket (void) { + unsigned char *buffer = &remcomInBuffer[0]; unsigned char checksum; unsigned char xmitcsum; - int i; - int count; + int count; char ch; - - do { - /* wait around for the start character, ignore all other characters */ - while ((ch = getDebugChar()) != '$'); - checksum = 0; - xmitcsum = -1; - - count = 0; - - /* now, read until a # or end of buffer is found */ - while (count < BUFMAX) { - ch = getDebugChar(); - if (ch == '#') break; - checksum = checksum + ch; - buffer[count] = ch; - count = count + 1; - } - buffer[count] = 0; - - if (ch == '#') { - xmitcsum = hex(getDebugChar()) << 4; - xmitcsum += hex(getDebugChar()); - if ((remote_debug ) && (checksum != xmitcsum)) { - fprintf(stderr,"bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n", - checksum,xmitcsum,buffer); - } - - if (checksum != xmitcsum) putDebugChar('-'); /* failed checksum */ - else { - putDebugChar('+'); /* successful transfer */ - /* if a sequence char is present, reply the sequence ID */ - if (buffer[2] == ':') { - putDebugChar( buffer[0] ); - putDebugChar( buffer[1] ); - /* remove sequence chars from buffer */ - count = strlen(buffer); - for (i=3; i <= count; i++) buffer[i-3] = buffer[i]; - } - } - } - } while (checksum != xmitcsum); - -} -/* send the packet in buffer. The host get's one chance to read it. - This routine does not wait for a positive acknowledge. */ + while (1) + { + /* wait around for the start character, ignore all other characters */ + while ((ch = getDebugChar ()) != '$') + ; + + retry: + checksum = 0; + xmitcsum = -1; + count = 0; + + /* now, read until a # or end of buffer is found */ + while (count < BUFMAX - 1) + { + ch = getDebugChar (); + if (ch == '$') + goto retry; + if (ch == '#') + break; + checksum = checksum + ch; + buffer[count] = ch; + count = count + 1; + } + buffer[count] = 0; + + if (ch == '#') + { + ch = getDebugChar (); + xmitcsum = hex (ch) << 4; + ch = getDebugChar (); + xmitcsum += hex (ch); + + if (checksum != xmitcsum) + { + if (remote_debug) + { + fprintf (stderr, + "bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n", + checksum, xmitcsum, buffer); + } + putDebugChar ('-'); /* failed checksum */ + } + else + { + putDebugChar ('+'); /* successful transfer */ + + /* if a sequence char is present, reply the sequence ID */ + if (buffer[2] == ':') + { + putDebugChar (buffer[0]); + putDebugChar (buffer[1]); + + return &buffer[3]; + } + + return &buffer[0]; + } + } + } +} +/* send the packet in buffer. */ -void putpacket(buffer) -char * buffer; +void +putpacket (buffer) + char *buffer; { unsigned char checksum; - int count; + int count; char ch; - + /* $#. */ - do { - putDebugChar('$'); - checksum = 0; - count = 0; - - while (ch=buffer[count]) { - if (! putDebugChar(ch)) return; - checksum += ch; - count += 1; - } - - putDebugChar('#'); - putDebugChar(hexchars[checksum >> 4]); - putDebugChar(hexchars[checksum % 16]); - - } while (1 == 0); /* (getDebugChar() != '+'); */ - -} + do + { + putDebugChar ('$'); + checksum = 0; + count = 0; -char remcomInBuffer[BUFMAX]; -char remcomOutBuffer[BUFMAX]; -static short error; + while (ch = buffer[count]) + { + putDebugChar (ch); + checksum += ch; + count += 1; + } + putDebugChar ('#'); + putDebugChar (hexchars[checksum >> 4]); + putDebugChar (hexchars[checksum % 16]); -void debug_error(format, parm) -char * format; -char * parm; + } + while (getDebugChar () != '+'); + +} + +void +debug_error (format, parm) + char *format; + char *parm; { - if (remote_debug) fprintf(stderr,format,parm); + if (remote_debug) + fprintf (stderr, format, parm); } /* convert the memory pointed to by mem into hex, placing result in buf */ /* return a pointer to the last char put in buf (null) */ -char* mem2hex(mem, buf, count) -char* mem; -char* buf; -int count; +char * +mem2hex (mem, buf, count) + char *mem; + char *buf; + int count; { - int i; - unsigned char ch; - for (i=0;i> 4]; - *buf++ = hexchars[ch % 16]; - } - *buf = 0; - return(buf); + int i; + unsigned char ch; + for (i = 0; i < count; i++) + { + ch = *mem++; + *buf++ = hexchars[ch >> 4]; + *buf++ = hexchars[ch % 16]; + } + *buf = 0; + return (buf); } /* convert the hex array pointed to by buf into binary to be placed in mem */ /* return a pointer to the character AFTER the last byte written */ -char* hex2mem(buf, mem, count) -char* buf; -char* mem; -int count; +char * +hex2mem (buf, mem, count) + char *buf; + char *mem; + int count; { - int i; - unsigned char ch; - for (i=0;i=0) - { - *intValue = (*intValue <<4) | hexValue; - numChars ++; - } - else - break; - - (*ptr)++; + hexValue = hex (**ptr); + if (hexValue >= 0) + { + *intValue = (*intValue << 4) | hexValue; + numChars++; + } + else + break; + + (*ptr)++; } - return (numChars); + return (numChars); } /* * This function does all command procesing for interfacing to gdb. */ -void handle_exception(int exceptionVector) +void +handle_exception (int exceptionVector) { - int sigval; - int addr, length; - char * ptr; - int newPC; - Frame *frame; - - if (remote_debug) printf("vector=%d, sr=0x%x, pc=0x%x\n", - exceptionVector, - registers[ PS ], - registers[ PC ]); + int sigval, stepping; + int addr, length; + char *ptr; + int newPC; + Frame *frame; + + if (remote_debug) + printf ("vector=%d, sr=0x%x, pc=0x%x\n", + exceptionVector, registers[PS], registers[PC]); /* reply to host that an exception has occurred */ - sigval = computeSignal( exceptionVector ); + sigval = computeSignal (exceptionVector); remcomOutBuffer[0] = 'S'; - remcomOutBuffer[1] = hexchars[sigval >> 4]; - remcomOutBuffer[2] = hexchars[sigval % 16]; + remcomOutBuffer[1] = hexchars[sigval >> 4]; + remcomOutBuffer[2] = hexchars[sigval % 16]; remcomOutBuffer[3] = 0; - putpacket(remcomOutBuffer); - - while (1==1) { - error = 0; - remcomOutBuffer[0] = 0; - getpacket(remcomInBuffer); - switch (remcomInBuffer[0]) { - case '?' : remcomOutBuffer[0] = 'S'; - remcomOutBuffer[1] = hexchars[sigval >> 4]; - remcomOutBuffer[2] = hexchars[sigval % 16]; - remcomOutBuffer[3] = 0; - break; - case 'd' : remote_debug = !(remote_debug); /* toggle debug flag */ - break; - case 'g' : /* return the value of the CPU registers */ - mem2hex((char*) registers, remcomOutBuffer, NUMREGBYTES); - break; - case 'G' : /* set the value of the CPU registers - return OK */ - hex2mem(&remcomInBuffer[1], (char*) registers, NUMREGBYTES); - strcpy(remcomOutBuffer,"OK"); - break; - - /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ - case 'm' : - if (setjmp(remcomEnv) == 0) - { - exceptionHandler(2,handle_buserror); - - /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */ - ptr = &remcomInBuffer[1]; - if (hexToInt(&ptr,&addr)) - if (*(ptr++) == ',') - if (hexToInt(&ptr,&length)) - { - ptr = 0; - mem2hex((char*) addr, remcomOutBuffer, length); - } - - if (ptr) - { - strcpy(remcomOutBuffer,"E01"); - debug_error("malformed read memory command: %s",remcomInBuffer); - } - } - else { - exceptionHandler(2,_catchException); - strcpy(remcomOutBuffer,"E03"); - debug_error("bus error"); - } - - /* restore handler for bus error */ - exceptionHandler(2,_catchException); + putpacket (remcomOutBuffer); + + stepping = 0; + + while (1 == 1) + { + remcomOutBuffer[0] = 0; + ptr = getpacket (); + switch (*ptr++) + { + case '?': + remcomOutBuffer[0] = 'S'; + remcomOutBuffer[1] = hexchars[sigval >> 4]; + remcomOutBuffer[2] = hexchars[sigval % 16]; + remcomOutBuffer[3] = 0; + break; + case 'd': + remote_debug = !(remote_debug); /* toggle debug flag */ + break; + case 'g': /* return the value of the CPU registers */ + mem2hex ((char *) registers, remcomOutBuffer, NUMREGBYTES); + break; + case 'G': /* set the value of the CPU registers - return OK */ + hex2mem (ptr, (char *) registers, NUMREGBYTES); + strcpy (remcomOutBuffer, "OK"); + break; + + /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ + case 'm': + if (setjmp (remcomEnv) == 0) + { + exceptionHandler (2, handle_buserror); + + /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */ + if (hexToInt (&ptr, &addr)) + if (*(ptr++) == ',') + if (hexToInt (&ptr, &length)) + { + ptr = 0; + mem2hex ((char *) addr, remcomOutBuffer, length); + } + + if (ptr) + { + strcpy (remcomOutBuffer, "E01"); + } + } + else + { + exceptionHandler (2, _catchException); + strcpy (remcomOutBuffer, "E03"); + debug_error ("bus error"); + } + + /* restore handler for bus error */ + exceptionHandler (2, _catchException); + break; + + /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ + case 'M': + if (setjmp (remcomEnv) == 0) + { + exceptionHandler (2, handle_buserror); + + /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */ + if (hexToInt (&ptr, &addr)) + if (*(ptr++) == ',') + if (hexToInt (&ptr, &length)) + if (*(ptr++) == ':') + { + hex2mem (ptr, (char *) addr, length); + ptr = 0; + strcpy (remcomOutBuffer, "OK"); + } + if (ptr) + { + strcpy (remcomOutBuffer, "E02"); + } + } + else + { + exceptionHandler (2, _catchException); + strcpy (remcomOutBuffer, "E03"); + debug_error ("bus error"); + } + + /* restore handler for bus error */ + exceptionHandler (2, _catchException); + break; + + /* cAA..AA Continue at address AA..AA(optional) */ + /* sAA..AA Step one instruction from AA..AA(optional) */ + case 's': + stepping = 1; + case 'c': + /* try to read optional parameter, pc unchanged if no parm */ + if (hexToInt (&ptr, &addr)) + registers[PC] = addr; + + newPC = registers[PC]; + + /* clear the trace bit */ + registers[PS] &= 0x7fff; + + /* set the trace bit if we're stepping */ + if (stepping) + registers[PS] |= 0x8000; + + /* + * look for newPC in the linked list of exception frames. + * if it is found, use the old frame it. otherwise, + * fake up a dummy frame in returnFromException(). + */ + if (remote_debug) + printf ("new pc = 0x%x\n", newPC); + frame = lastFrame; + while (frame) + { + if (remote_debug) + printf ("frame at 0x%x has pc=0x%x, except#=%d\n", + frame, frame->exceptionPC, frame->exceptionVector); + if (frame->exceptionPC == newPC) + break; /* bingo! a match */ + /* + * for a breakpoint instruction, the saved pc may + * be off by two due to re-executing the instruction + * replaced by the trap instruction. Check for this. + */ + if ((frame->exceptionVector == 33) && + (frame->exceptionPC == (newPC + 2))) break; - - /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ - case 'M' : - if (setjmp(remcomEnv) == 0) { - exceptionHandler(2,handle_buserror); - - /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */ - ptr = &remcomInBuffer[1]; - if (hexToInt(&ptr,&addr)) - if (*(ptr++) == ',') - if (hexToInt(&ptr,&length)) - if (*(ptr++) == ':') - { - hex2mem(ptr, (char*) addr, length); - ptr = 0; - strcpy(remcomOutBuffer,"OK"); - } - if (ptr) - { - strcpy(remcomOutBuffer,"E02"); - debug_error("malformed write memory command: %s",remcomInBuffer); - } - } - else { - exceptionHandler(2,_catchException); - strcpy(remcomOutBuffer,"E03"); - debug_error("bus error"); - } - - /* restore handler for bus error */ - exceptionHandler(2,_catchException); - break; - - /* cAA..AA Continue at address AA..AA(optional) */ - /* sAA..AA Step one instruction from AA..AA(optional) */ - case 'c' : - case 's' : - /* try to read optional parameter, pc unchanged if no parm */ - ptr = &remcomInBuffer[1]; - if (hexToInt(&ptr,&addr)) - registers[ PC ] = addr; - - newPC = registers[ PC]; - - /* clear the trace bit */ - registers[ PS ] &= 0x7fff; - - /* set the trace bit if we're stepping */ - if (remcomInBuffer[0] == 's') registers[ PS ] |= 0x8000; - - /* - * look for newPC in the linked list of exception frames. - * if it is found, use the old frame it. otherwise, - * fake up a dummy frame in returnFromException(). - */ - if (remote_debug) printf("new pc = 0x%x\n",newPC); - frame = lastFrame; - while (frame) - { - if (remote_debug) - printf("frame at 0x%x has pc=0x%x, except#=%d\n", - frame,frame->exceptionPC, - frame->exceptionVector); - if (frame->exceptionPC == newPC) break; /* bingo! a match */ - /* - * for a breakpoint instruction, the saved pc may - * be off by two due to re-executing the instruction - * replaced by the trap instruction. Check for this. - */ - if ((frame->exceptionVector == 33) && - (frame->exceptionPC == (newPC+2))) break; - if (frame == frame->previous) - { - frame = 0; /* no match found */ - break; - } + if (frame == frame->previous) + { + frame = 0; /* no match found */ + break; + } frame = frame->previous; - } - - /* - * If we found a match for the PC AND we are not returning - * as a result of a breakpoint (33), - * trace exception (9), nmi (31), jmp to - * the old exception handler as if this code never ran. - */ - if (frame) - { - if ((frame->exceptionVector != 9) && - (frame->exceptionVector != 31) && - (frame->exceptionVector != 33)) - { - /* - * invoke the previous handler. - */ - if (oldExceptionHook) - (*oldExceptionHook) (frame->exceptionVector); - newPC = registers[ PC ]; /* pc may have changed */ - if (newPC != frame->exceptionPC) - { - if (remote_debug) - printf("frame at 0x%x has pc=0x%x, except#=%d\n", - frame,frame->exceptionPC, - frame->exceptionVector); - /* re-use the last frame, we're skipping it (longjump?)*/ + } + + /* + * If we found a match for the PC AND we are not returning + * as a result of a breakpoint (33), + * trace exception (9), nmi (31), jmp to + * the old exception handler as if this code never ran. + */ + if (frame) + { + if ((frame->exceptionVector != 9) && + (frame->exceptionVector != 31) && + (frame->exceptionVector != 33)) + { + /* + * invoke the previous handler. + */ + if (oldExceptionHook) + (*oldExceptionHook) (frame->exceptionVector); + newPC = registers[PC]; /* pc may have changed */ + if (newPC != frame->exceptionPC) + { + if (remote_debug) + printf ("frame at 0x%x has pc=0x%x, except#=%d\n", + frame, frame->exceptionPC, + frame->exceptionVector); + /* re-use the last frame, we're skipping it (longjump?) */ frame = (Frame *) 0; - _returnFromException( frame ); /* this is a jump */ - } - } - } - - /* if we couldn't find a frame, create one */ - if (frame == 0) - { - frame = lastFrame -1 ; - + _returnFromException (frame); /* this is a jump */ + } + } + } + + /* if we couldn't find a frame, create one */ + if (frame == 0) + { + frame = lastFrame - 1; + /* by using a bunch of print commands with breakpoints, - it's possible for the frame stack to creep down. If it creeps - too far, give up and reset it to the top. Normal use should - not see this happen. - */ - if ((unsigned int) (frame-2) < (unsigned int) &gdbFrameStack) - { - initializeRemcomErrorFrame(); - frame = lastFrame; - } - frame->previous = lastFrame; - lastFrame = frame; - frame = 0; /* null so _return... will properly initialize it */ - } - - _returnFromException( frame ); /* this is a jump */ - - break; - - /* kill the program */ - case 'k' : /* do nothing */ - break; - } /* switch */ - - /* reply to the request */ - putpacket(remcomOutBuffer); + it's possible for the frame stack to creep down. If it creeps + too far, give up and reset it to the top. Normal use should + not see this happen. + */ + if ((unsigned int) (frame - 2) < (unsigned int) &gdbFrameStack) + { + initializeRemcomErrorFrame (); + frame = lastFrame; + } + frame->previous = lastFrame; + lastFrame = frame; + frame = 0; /* null so _return... will properly initialize it */ + } + + _returnFromException (frame); /* this is a jump */ + + break; + + /* kill the program */ + case 'k': /* do nothing */ + break; + } /* switch */ + + /* reply to the request */ + putpacket (remcomOutBuffer); } } -void initializeRemcomErrorFrame(void) +void +initializeRemcomErrorFrame (void) { - lastFrame = ((Frame *) &gdbFrameStack[FRAMESIZE-1]) - 1; - lastFrame->previous = lastFrame; + lastFrame = ((Frame *) & gdbFrameStack[FRAMESIZE - 1]) - 1; + lastFrame->previous = lastFrame; } /* this function is used to set up exception handlers for tracing and breakpoints */ -void set_debug_traps() +void +set_debug_traps () { -extern void _debug_level7(); -extern void remcomHandler(); -int exception; + extern void _debug_level7 (); + extern void remcomHandler (); + int exception; - initializeRemcomErrorFrame(); - stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1]; + initializeRemcomErrorFrame (); + stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1]; for (exception = 2; exception <= 23; exception++) - exceptionHandler(exception,_catchException); + exceptionHandler (exception, _catchException); /* level 7 interrupt */ - exceptionHandler(31,_debug_level7); - + exceptionHandler (31, _debug_level7); + /* breakpoint exception (trap #1) */ - exceptionHandler(33,_catchException); - - /* floating point error (trap #8) */ - exceptionHandler(40,_catchException); - + exceptionHandler (33, _catchException); + + /* This is a trap #8 instruction. Apparently it is someone's software + convention for some sort of SIGFPE condition. Whose? How many + people are being screwed by having this code the way it is? + Is there a clean solution? */ + exceptionHandler (40, _catchException); + /* 48 to 54 are floating point coprocessor errors */ for (exception = 48; exception <= 54; exception++) - exceptionHandler(exception,_catchException); + exceptionHandler (exception, _catchException); if (oldExceptionHook != remcomHandler) - { + { oldExceptionHook = exceptionHook; - exceptionHook = remcomHandler; - } - + exceptionHook = remcomHandler; + } + initialized = 1; } @@ -972,9 +1089,10 @@ int exception; beginning of a program to sync up with a debugger and can be used otherwise as a quick means to stop program execution and "break" into the debugger. */ - -void breakpoint() + +void +breakpoint () { - if (initialized) BREAKPOINT(); + if (initialized) + BREAKPOINT (); } -