asm(" pushl %eax"); /* push exception onto stack */
asm(" call _handle_exception"); /* this never returns */
-void _returnFromException()
+void
+_returnFromException ()
{
return_to_prog ();
}
-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);
}
while ((ch = getDebugChar ()) != '$')
;
-retry:
+ retry:
checksum = 0;
xmitcsum = -1;
count = 0;
while (count < BUFMAX)
{
ch = getDebugChar ();
- if (ch == '$')
+ if (ch == '$')
goto retry;
if (ch == '#')
break;
if (remote_debug)
{
fprintf (stderr,
- "bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
+ "bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
checksum, xmitcsum, buffer);
}
putDebugChar ('-'); /* failed checksum */
/* send the packet in buffer. */
-void putpacket(buffer)
- unsigned char *buffer;
+void
+putpacket (unsigned char *buffer)
{
unsigned char checksum;
- int count;
+ int count;
char ch;
/* $<packet info>#<checksum>. */
- do {
- putDebugChar('$');
- checksum = 0;
- count = 0;
-
- while (ch=buffer[count]) {
- putDebugChar(ch);
- checksum += ch;
- count += 1;
- }
+ do
+ {
+ putDebugChar ('$');
+ checksum = 0;
+ count = 0;
- putDebugChar('#');
- putDebugChar(hexchars[checksum >> 4]);
- putDebugChar(hexchars[checksum % 16]);
+ while (ch = buffer[count])
+ {
+ putDebugChar (ch);
+ checksum += ch;
+ count += 1;
+ }
- } while (getDebugChar() != '+');
+ putDebugChar ('#');
+ putDebugChar (hexchars[checksum >> 4]);
+ putDebugChar (hexchars[checksum % 16]);
+ }
+ while (getDebugChar () != '+');
}
-void debug_error(format, parm)
-char * format;
-char * parm;
+void
+debug_error (format, parm)
+ char *format;
+ char *parm;
{
- if (remote_debug) fprintf (stderr,format,parm);
+ if (remote_debug)
+ fprintf (stderr, format, parm);
}
/* Address of a routine to RTE to if we get a memory fault. */
-static void (*volatile mem_fault_routine)() = NULL;
+static void (*volatile mem_fault_routine) () = NULL;
/* Indicate to caller of mem2hex or hex2mem that there has been an
error. */
/* return a pointer to the last char put in buf (null) */
/* If MAY_FAULT is non-zero, then we should set mem_err in response to
a fault; if zero treat a fault like any other fault in the stub. */
-char* mem2hex(mem, buf, count, may_fault)
-char* mem;
-char* buf;
-int count;
-int may_fault;
+char *
+mem2hex (mem, buf, count, may_fault)
+ char *mem;
+ char *buf;
+ int count;
+ int may_fault;
{
- int i;
- unsigned char ch;
-
- if (may_fault)
- mem_fault_routine = set_mem_err;
- for (i=0;i<count;i++) {
- ch = get_char (mem++);
- if (may_fault && mem_err)
- return (buf);
- *buf++ = hexchars[ch >> 4];
- *buf++ = hexchars[ch % 16];
- }
- *buf = 0;
- if (may_fault)
- mem_fault_routine = NULL;
- return(buf);
+ int i;
+ unsigned char ch;
+
+ if (may_fault)
+ mem_fault_routine = set_mem_err;
+ for (i = 0; i < count; i++)
+ {
+ ch = get_char (mem++);
+ if (may_fault && mem_err)
+ return (buf);
+ *buf++ = hexchars[ch >> 4];
+ *buf++ = hexchars[ch % 16];
+ }
+ *buf = 0;
+ if (may_fault)
+ mem_fault_routine = NULL;
+ 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, may_fault)
-char* buf;
-char* mem;
-int count;
-int may_fault;
+char *
+hex2mem (buf, mem, count, may_fault)
+ char *buf;
+ char *mem;
+ int count;
+ int may_fault;
{
- int i;
- unsigned char ch;
-
- if (may_fault)
- mem_fault_routine = set_mem_err;
- for (i=0;i<count;i++) {
- ch = hex(*buf++) << 4;
- ch = ch + hex(*buf++);
- set_char (mem++, ch);
- if (may_fault && mem_err)
- return (mem);
- }
- if (may_fault)
- mem_fault_routine = NULL;
- return(mem);
+ int i;
+ unsigned char ch;
+
+ if (may_fault)
+ mem_fault_routine = set_mem_err;
+ for (i = 0; i < count; i++)
+ {
+ ch = hex (*buf++) << 4;
+ ch = ch + hex (*buf++);
+ set_char (mem++, ch);
+ if (may_fault && mem_err)
+ return (mem);
+ }
+ if (may_fault)
+ mem_fault_routine = NULL;
+ return (mem);
}
/* this function takes the 386 exception vector and attempts to
translate this number into a unix compatible signal value */
-int computeSignal( exceptionVector )
-int exceptionVector;
+int
+computeSignal (int exceptionVector)
{
int sigval;
- switch (exceptionVector) {
- case 0 : sigval = 8; break; /* divide by zero */
- case 1 : sigval = 5; break; /* debug exception */
- case 3 : sigval = 5; break; /* breakpoint */
- case 4 : sigval = 16; break; /* into instruction (overflow) */
- case 5 : sigval = 16; break; /* bound instruction */
- case 6 : sigval = 4; break; /* Invalid opcode */
- case 7 : sigval = 8; break; /* coprocessor not available */
- case 8 : sigval = 7; break; /* double fault */
- case 9 : sigval = 11; break; /* coprocessor segment overrun */
- case 10 : sigval = 11; break; /* Invalid TSS */
- case 11 : sigval = 11; break; /* Segment not present */
- case 12 : sigval = 11; break; /* stack exception */
- case 13 : sigval = 11; break; /* general protection */
- case 14 : sigval = 11; break; /* page fault */
- case 16 : sigval = 7; break; /* coprocessor error */
+ switch (exceptionVector)
+ {
+ case 0:
+ sigval = 8;
+ break; /* divide by zero */
+ case 1:
+ sigval = 5;
+ break; /* debug exception */
+ case 3:
+ sigval = 5;
+ break; /* breakpoint */
+ case 4:
+ sigval = 16;
+ break; /* into instruction (overflow) */
+ case 5:
+ sigval = 16;
+ break; /* bound instruction */
+ case 6:
+ sigval = 4;
+ break; /* Invalid opcode */
+ case 7:
+ sigval = 8;
+ break; /* coprocessor not available */
+ case 8:
+ sigval = 7;
+ break; /* double fault */
+ case 9:
+ sigval = 11;
+ break; /* coprocessor segment overrun */
+ case 10:
+ sigval = 11;
+ break; /* Invalid TSS */
+ case 11:
+ sigval = 11;
+ break; /* Segment not present */
+ case 12:
+ sigval = 11;
+ break; /* stack exception */
+ case 13:
+ sigval = 11;
+ break; /* general protection */
+ case 14:
+ sigval = 11;
+ break; /* page fault */
+ case 16:
+ sigval = 7;
+ break; /* coprocessor error */
default:
- sigval = 7; /* "software generated"*/
- }
+ sigval = 7; /* "software generated" */
+ }
return (sigval);
}
/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
/* RETURN NUMBER OF CHARS PROCESSED */
/**********************************************/
-int hexToInt(char **ptr, int *intValue)
+int
+hexToInt (char **ptr, int *intValue)
{
- int numChars = 0;
- int hexValue;
+ int numChars = 0;
+ int hexValue;
- *intValue = 0;
+ *intValue = 0;
- while (**ptr)
+ while (**ptr)
{
- hexValue = hex(**ptr);
- if (hexValue >=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, stepping;
- int addr, length;
- char * ptr;
- int newPC;
+ int sigval, stepping;
+ int addr, length;
+ char *ptr;
+ int newPC;
gdb_i386vector = exceptionVector;
- if (remote_debug) printf("vector=%d, sr=0x%x, pc=0x%x\n",
- exceptionVector,
- registers[ PS ],
- registers[ PC ]);
+ 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);
+ 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, 0);
- break;
- case 'G' : /* set the value of the CPU registers - return OK */
- hex2mem(ptr, (char*) registers, NUMREGBYTES, 0);
- strcpy(remcomOutBuffer,"OK");
- break;
- case 'P' : /* set the value of a single CPU register - return OK */
- {
- int regno;
-
- if (hexToInt (&ptr, ®no) && *ptr++ == '=')
- if (regno >= 0 && regno < NUMREGS)
- {
- hex2mem (ptr, (char *)®isters[regno], 4, 0);
- strcpy(remcomOutBuffer,"OK");
- break;
- }
-
- strcpy (remcomOutBuffer, "E01");
- break;
- }
-
- /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
- case 'm' :
- /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
- if (hexToInt(&ptr,&addr))
- if (*(ptr++) == ',')
- if (hexToInt(&ptr,&length))
- {
- ptr = 0;
- mem_err = 0;
- mem2hex((char*) addr, remcomOutBuffer, length, 1);
- if (mem_err) {
- strcpy (remcomOutBuffer, "E03");
- debug_error ("memory fault");
- }
- }
-
- if (ptr)
- {
- strcpy(remcomOutBuffer,"E01");
- }
- break;
-
- /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
- case 'M' :
- /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
- if (hexToInt(&ptr,&addr))
- if (*(ptr++) == ',')
- if (hexToInt(&ptr,&length))
- if (*(ptr++) == ':')
- {
- mem_err = 0;
- hex2mem(ptr, (char*) addr, length, 1);
-
- if (mem_err) {
- strcpy (remcomOutBuffer, "E03");
- debug_error ("memory fault");
- } else {
- strcpy(remcomOutBuffer,"OK");
- }
-
- ptr = 0;
- }
- if (ptr)
- {
- strcpy(remcomOutBuffer,"E02");
+ 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, 0);
+ break;
+ case 'G': /* set the value of the CPU registers - return OK */
+ hex2mem (ptr, (char *) registers, NUMREGBYTES, 0);
+ strcpy (remcomOutBuffer, "OK");
+ break;
+ case 'P': /* set the value of a single CPU register - return OK */
+ {
+ int regno;
+
+ if (hexToInt (&ptr, ®no) && *ptr++ == '=')
+ if (regno >= 0 && regno < NUMREGS)
+ {
+ hex2mem (ptr, (char *) ®isters[regno], 4, 0);
+ strcpy (remcomOutBuffer, "OK");
+ break;
+ }
+
+ strcpy (remcomOutBuffer, "E01");
+ break;
+ }
+
+ /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
+ case 'm':
+ /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
+ if (hexToInt (&ptr, &addr))
+ if (*(ptr++) == ',')
+ if (hexToInt (&ptr, &length))
+ {
+ ptr = 0;
+ mem_err = 0;
+ mem2hex ((char *) addr, remcomOutBuffer, length, 1);
+ if (mem_err)
+ {
+ strcpy (remcomOutBuffer, "E03");
+ debug_error ("memory fault");
}
- 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;
+ if (ptr)
+ {
+ strcpy (remcomOutBuffer, "E01");
+ }
+ break;
+
+ /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
+ case 'M':
+ /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
+ if (hexToInt (&ptr, &addr))
+ if (*(ptr++) == ',')
+ if (hexToInt (&ptr, &length))
+ if (*(ptr++) == ':')
+ {
+ mem_err = 0;
+ hex2mem (ptr, (char *) addr, length, 1);
+
+ if (mem_err)
+ {
+ strcpy (remcomOutBuffer, "E03");
+ debug_error ("memory fault");
+ }
+ else
+ {
+ strcpy (remcomOutBuffer, "OK");
+ }
+
+ ptr = 0;
+ }
+ if (ptr)
+ {
+ strcpy (remcomOutBuffer, "E02");
+ }
+ 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];
+ newPC = registers[PC];
- /* clear the trace bit */
- registers[ PS ] &= 0xfffffeff;
+ /* clear the trace bit */
+ registers[PS] &= 0xfffffeff;
- /* set the trace bit if we're stepping */
- if (stepping) registers[ PS ] |= 0x100;
+ /* set the trace bit if we're stepping */
+ if (stepping)
+ registers[PS] |= 0x100;
- _returnFromException(); /* this is a jump */
- break;
+ _returnFromException (); /* this is a jump */
+ break;
- /* kill the program */
- case 'k' : /* do nothing */
+ /* kill the program */
+ case 'k': /* do nothing */
#if 0
- /* Huh? This doesn't look like "nothing".
- m68k-stub.c and sparc-stub.c don't have it. */
- BREAKPOINT();
+ /* Huh? This doesn't look like "nothing".
+ m68k-stub.c and sparc-stub.c don't have it. */
+ BREAKPOINT ();
#endif
- break;
- } /* switch */
+ break;
+ } /* switch */
- /* reply to the request */
- putpacket(remcomOutBuffer);
+ /* reply to the request */
+ putpacket (remcomOutBuffer);
}
}
/* this function is used to set up exception handlers for tracing and
breakpoints */
-void set_debug_traps()
+void
+set_debug_traps (void)
{
-extern void remcomHandler();
-int exception;
-
- stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];
+ stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
exceptionHandler (0, _catchException0);
exceptionHandler (1, _catchException1);
otherwise as a quick means to stop program execution and "break" into
the debugger. */
-void breakpoint()
+void
+breakpoint (void)
{
if (initialized)
- BREAKPOINT();
+ BREAKPOINT ();
}
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 */
}
#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;
+ /* 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 remcomOutBuffer[BUFMAX];
/* scan for the sequence $<data>#<checksum> */
-
+
unsigned char *
getpacket (void)
{
while ((ch = getDebugChar ()) != '$')
;
-retry:
+ retry:
checksum = 0;
xmitcsum = -1;
count = 0;
{
ch = getDebugChar ();
if (ch == '$')
- goto retry;
+ goto retry;
if (ch == '#')
break;
checksum = checksum + ch;
if (remote_debug)
{
fprintf (stderr,
- "bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
+ "bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
checksum, xmitcsum, buffer);
}
putDebugChar ('-'); /* failed checksum */
/* send the packet in buffer. */
-
-void putpacket(buffer)
-char * buffer;
+void
+putpacket (buffer)
+ char *buffer;
{
unsigned char checksum;
- int count;
+ int count;
char ch;
-
+
/* $<packet info>#<checksum>. */
- do {
- putDebugChar('$');
- checksum = 0;
- count = 0;
-
- while (ch=buffer[count]) {
- putDebugChar(ch);
- checksum += ch;
- count += 1;
- }
-
- putDebugChar('#');
- putDebugChar(hexchars[checksum >> 4]);
- putDebugChar(hexchars[checksum % 16]);
-
- } while (getDebugChar() != '+');
-
+ do
+ {
+ putDebugChar ('$');
+ checksum = 0;
+ count = 0;
+
+ while (ch = buffer[count])
+ {
+ putDebugChar (ch);
+ checksum += ch;
+ count += 1;
+ }
+
+ putDebugChar ('#');
+ putDebugChar (hexchars[checksum >> 4]);
+ putDebugChar (hexchars[checksum % 16]);
+
+ }
+ while (getDebugChar () != '+');
+
}
-void debug_error(format, parm)
-char * format;
-char * parm;
+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<count;i++) {
- ch = *mem++;
- *buf++ = hexchars[ch >> 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<count;i++) {
- ch = hex(*buf++) << 4;
- ch = ch + hex(*buf++);
- *mem++ = ch;
- }
- return(mem);
+ int i;
+ unsigned char ch;
+ for (i = 0; i < count; i++)
+ {
+ ch = hex (*buf++) << 4;
+ ch = ch + hex (*buf++);
+ *mem++ = ch;
+ }
+ return (mem);
}
/* a bus error has occurred, perform a longjmp
to return execution and allow handling of the error */
-void handle_buserror()
+void
+handle_buserror ()
{
- longjmp(remcomEnv,1);
+ longjmp (remcomEnv, 1);
}
/* this function takes the 68000 exception number and attempts to
translate this number into a unix compatible signal value */
-int computeSignal( exceptionVector )
-int exceptionVector;
+int
+computeSignal (exceptionVector)
+ int exceptionVector;
{
int sigval;
- switch (exceptionVector) {
- case 2 : sigval = 10; break; /* bus error */
- case 3 : sigval = 10; break; /* address error */
- case 4 : sigval = 4; break; /* illegal instruction */
- case 5 : sigval = 8; break; /* zero divide */
- case 6 : sigval = 8; break; /* chk instruction */
- case 7 : sigval = 8; break; /* trapv instruction */
- case 8 : sigval = 11; break; /* privilege violation */
- case 9 : sigval = 5; break; /* trace trap */
- case 10: sigval = 4; break; /* line 1010 emulator */
- case 11: sigval = 4; break; /* line 1111 emulator */
+ switch (exceptionVector)
+ {
+ case 2:
+ sigval = 10;
+ break; /* bus error */
+ case 3:
+ sigval = 10;
+ break; /* address error */
+ case 4:
+ sigval = 4;
+ break; /* illegal instruction */
+ case 5:
+ sigval = 8;
+ break; /* zero divide */
+ case 6:
+ sigval = 8;
+ break; /* chk instruction */
+ case 7:
+ sigval = 8;
+ break; /* trapv instruction */
+ case 8:
+ sigval = 11;
+ break; /* privilege violation */
+ case 9:
+ sigval = 5;
+ break; /* trace trap */
+ case 10:
+ sigval = 4;
+ break; /* line 1010 emulator */
+ case 11:
+ sigval = 4;
+ break; /* line 1111 emulator */
/* Coprocessor protocol violation. Using a standard MMU or FPU
- this cannot be triggered by software. Call it a SIGBUS. */
- case 13: sigval = 10; break;
-
- case 31: sigval = 2; break; /* interrupt */
- case 33: sigval = 5; break; /* breakpoint */
+ this cannot be triggered by software. Call it a SIGBUS. */
+ case 13:
+ sigval = 10;
+ break;
+
+ case 31:
+ sigval = 2;
+ break; /* interrupt */
+ case 33:
+ sigval = 5;
+ break; /* breakpoint */
/* 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? */
- case 40: sigval = 8; break; /* floating point err */
-
- case 48: sigval = 8; break; /* floating point err */
- case 49: sigval = 8; break; /* floating point err */
- case 50: sigval = 8; break; /* zero divide */
- case 51: sigval = 8; break; /* underflow */
- case 52: sigval = 8; break; /* operand error */
- case 53: sigval = 8; break; /* overflow */
- case 54: sigval = 8; break; /* NAN */
- default:
- sigval = 7; /* "software generated"*/
- }
+ 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? */
+ case 40:
+ sigval = 8;
+ break; /* floating point err */
+
+ case 48:
+ sigval = 8;
+ break; /* floating point err */
+ case 49:
+ sigval = 8;
+ break; /* floating point err */
+ case 50:
+ sigval = 8;
+ break; /* zero divide */
+ case 51:
+ sigval = 8;
+ break; /* underflow */
+ case 52:
+ sigval = 8;
+ break; /* operand error */
+ case 53:
+ sigval = 8;
+ break; /* overflow */
+ case 54:
+ sigval = 8;
+ break; /* NAN */
+ default:
+ sigval = 7; /* "software generated" */
+ }
return (sigval);
}
/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
/* RETURN NUMBER OF CHARS PROCESSED */
/**********************************************/
-int hexToInt(char **ptr, int *intValue)
+int
+hexToInt (char **ptr, int *intValue)
{
- int numChars = 0;
- int hexValue;
-
- *intValue = 0;
+ int numChars = 0;
+ int hexValue;
+
+ *intValue = 0;
- while (**ptr)
+ while (**ptr)
{
- hexValue = hex(**ptr);
- if (hexValue >=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, 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 ]);
+ 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);
+ 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);
+ 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 */
- 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;
- 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)
{
- 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();
+ 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);
-
+ 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);
-
+ 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;
}
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 ();
}
-
OSDN Git Service
