diff --git a/libgloss/ChangeLog b/libgloss/ChangeLog index e2f3d2636..1d913aaa5 100644 --- a/libgloss/ChangeLog +++ b/libgloss/ChangeLog @@ -1,3 +1,7 @@ +2009-03-16 Jeff Johnston + + * m32r/m32r-stub.c: Replace with one from newer version of gdb. + 2009-01-07 Ben Elliston * Makefile.in (all): Add `+' to the command line so that the diff --git a/libgloss/m32r/m32r-stub.c b/libgloss/m32r/m32r-stub.c index 9fdf4969e..4d54f72d6 100644 --- a/libgloss/m32r/m32r-stub.c +++ b/libgloss/m32r/m32r-stub.c @@ -96,9 +96,9 @@ * * external low-level support routines */ -extern void putDebugChar(); /* write a single character */ -extern int getDebugChar(); /* read and return a single char */ -extern void exceptionHandler(); /* assign an exception handler */ +extern void putDebugChar (); /* write a single character */ +extern int getDebugChar (); /* read and return a single char */ +extern void exceptionHandler (); /* assign an exception handler */ /***************************************************************************** * BUFMAX defines the maximum number of characters in inbound/outbound buffers @@ -106,53 +106,57 @@ extern void exceptionHandler(); /* assign an exception handler */ */ #define BUFMAX 400 -static char initialized; /* boolean flag. != 0 means we've been initialized */ +static char initialized; /* boolean flag. != 0 means we've been initialized */ -int remote_debug; +int remote_debug; /* debug > 0 prints ill-formed commands in valid packets & checksum errors */ -static const unsigned char hexchars[]="0123456789abcdef"; +static const unsigned char hexchars[] = "0123456789abcdef"; #define NUMREGS 24 /* Number of bytes of registers. */ #define NUMREGBYTES (NUMREGS * 4) -enum regnames { R0, R1, R2, R3, R4, R5, R6, R7, - R8, R9, R10, R11, R12, R13, R14, R15, - PSW, CBR, SPI, SPU, BPC, PC, ACCL, ACCH }; +enum regnames +{ R0, R1, R2, R3, R4, R5, R6, R7, + R8, R9, R10, R11, R12, R13, R14, R15, + PSW, CBR, SPI, SPU, BPC, PC, ACCL, ACCH +}; -enum SYS_calls { - SYS_null, - SYS_exit, - SYS_open, - SYS_close, - SYS_read, - SYS_write, - SYS_lseek, - SYS_unlink, - SYS_getpid, - SYS_kill, - SYS_fstat, - SYS_sbrk, - SYS_fork, - SYS_execve, - SYS_wait4, - SYS_link, - SYS_chdir, - SYS_stat, - SYS_utime, - SYS_chown, - SYS_chmod, - SYS_time, - SYS_pipe }; +enum SYS_calls +{ + SYS_null, + SYS_exit, + SYS_open, + SYS_close, + SYS_read, + SYS_write, + SYS_lseek, + SYS_unlink, + SYS_getpid, + SYS_kill, + SYS_fstat, + SYS_sbrk, + SYS_fork, + SYS_execve, + SYS_wait4, + SYS_link, + SYS_chdir, + SYS_stat, + SYS_utime, + SYS_chown, + SYS_chmod, + SYS_time, + SYS_pipe +}; static int registers[NUMREGS]; #define STACKSIZE 8096 static unsigned char remcomInBuffer[BUFMAX]; static unsigned char remcomOutBuffer[BUFMAX]; -static int remcomStack[STACKSIZE/sizeof(int)]; -static int* stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1]; +static int remcomStack[STACKSIZE / sizeof (int)]; +static int *stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1]; static unsigned int save_vectors[18]; /* previous exception vectors */ @@ -164,383 +168,387 @@ static volatile int mem_err = 0; int gdb_m32r_vector = -1; #if 0 -#include "syscall.h" /* for SYS_exit, SYS_write etc. */ +#include "syscall.h" /* for SYS_exit, SYS_write etc. */ #endif /* Global entry points: */ -extern void handle_exception(int); -extern void set_debug_traps(void); -extern void breakpoint(void); +extern void handle_exception (int); +extern void set_debug_traps (void); +extern void breakpoint (void); /* Local functions: */ -static int computeSignal(int); -static void putpacket(unsigned char *); -static unsigned char *getpacket(void); +static int computeSignal (int); +static void putpacket (unsigned char *); +static unsigned char *getpacket (void); -static unsigned char *mem2hex(unsigned char *, unsigned char *, int, int); -static unsigned char *hex2mem(unsigned char *, unsigned char *, int, int); -static int hexToInt(unsigned char **, int *); -static unsigned char *bin2mem(unsigned char *, unsigned char *, int, int); -static void stash_registers(void); -static void restore_registers(void); -static int prepare_to_step(int); -static int finish_from_step(void); +static unsigned char *mem2hex (unsigned char *, unsigned char *, int, int); +static unsigned char *hex2mem (unsigned char *, unsigned char *, int, int); +static int hexToInt (unsigned char **, int *); +static unsigned char *bin2mem (unsigned char *, unsigned char *, int, int); +static void stash_registers (void); +static void restore_registers (void); +static int prepare_to_step (int); +static int finish_from_step (void); static unsigned long crc32 (unsigned char *, int, unsigned long); -static void gdb_error(char *, char *); -static int gdb_putchar(int), gdb_puts(char *), gdb_write(char *, int); +static void gdb_error (char *, char *); +static int gdb_putchar (int), gdb_puts (char *), gdb_write (char *, int); static unsigned char *strcpy (unsigned char *, const unsigned char *); -static int strlen (const unsigned char *); +static int strlen (const unsigned char *); /* * 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, i; - unsigned char * ptr; - unsigned char buf[16]; + int sigval, stepping; + int addr, length, i; + unsigned char *ptr; + unsigned char buf[16]; int binary; - if (!finish_from_step()) - return; /* "false step": let the target continue */ + if (!finish_from_step ()) + return; /* "false step": let the target continue */ gdb_m32r_vector = exceptionVector; if (remote_debug) { - mem2hex((unsigned char *) &exceptionVector, buf, 4, 0); - gdb_error("Handle exception %s, ", buf); - mem2hex((unsigned char *) ®isters[PC], buf, 4, 0); - gdb_error("PC == 0x%s\n", buf); + mem2hex ((unsigned char *) &exceptionVector, buf, 4, 0); + gdb_error ("Handle exception %s, ", buf); + mem2hex ((unsigned char *) ®isters[PC], buf, 4, 0); + gdb_error ("PC == 0x%s\n", buf); } /* reply to host that an exception has occurred */ - sigval = computeSignal( exceptionVector ); + sigval = computeSignal (exceptionVector); ptr = remcomOutBuffer; - - *ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */ + + *ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */ *ptr++ = hexchars[sigval >> 4]; *ptr++ = hexchars[sigval & 0xf]; - + *ptr++ = hexchars[PC >> 4]; *ptr++ = hexchars[PC & 0xf]; *ptr++ = ':'; - ptr = mem2hex((unsigned char *)®isters[PC], ptr, 4, 0); /* PC */ + ptr = mem2hex ((unsigned char *) ®isters[PC], ptr, 4, 0); /* PC */ *ptr++ = ';'; - + *ptr++ = hexchars[R13 >> 4]; *ptr++ = hexchars[R13 & 0xf]; *ptr++ = ':'; - ptr = mem2hex((unsigned char *)®isters[R13], ptr, 4, 0); /* FP */ + ptr = mem2hex ((unsigned char *) ®isters[R13], ptr, 4, 0); /* FP */ *ptr++ = ';'; - + *ptr++ = hexchars[R15 >> 4]; *ptr++ = hexchars[R15 & 0xf]; *ptr++ = ':'; - ptr = mem2hex((unsigned char *)®isters[R15], ptr, 4, 0); /* SP */ + ptr = mem2hex ((unsigned char *) ®isters[R15], ptr, 4, 0); /* SP */ *ptr++ = ';'; *ptr++ = 0; - - if (exceptionVector == 0) /* simulated SYS call stuff */ + + if (exceptionVector == 0) /* simulated SYS call stuff */ { - mem2hex((unsigned char *) ®isters[PC], buf, 4, 0); - switch (registers[R0]) { - case SYS_exit: - gdb_error("Target program has exited at %s\n", buf); - ptr = remcomOutBuffer; - *ptr++ = 'W'; - sigval = registers[R1] & 0xff; - *ptr++ = hexchars[sigval >> 4]; - *ptr++ = hexchars[sigval & 0xf]; - *ptr++ = 0; - break; - case SYS_open: - gdb_error("Target attempts SYS_open call at %s\n", buf); - break; - case SYS_close: - gdb_error("Target attempts SYS_close call at %s\n", buf); - break; - case SYS_read: - gdb_error("Target attempts SYS_read call at %s\n", buf); - break; - case SYS_write: - if (registers[R1] == 1 || /* write to stdout */ - registers[R1] == 2) /* write to stderr */ - { /* (we can do that) */ - registers[R0] = gdb_write((void *) registers[R2], registers[R3]); - return; - } - else - gdb_error("Target attempts SYS_write call at %s\n", buf); - break; - case SYS_lseek: - gdb_error("Target attempts SYS_lseek call at %s\n", buf); - break; - case SYS_unlink: - gdb_error("Target attempts SYS_unlink call at %s\n", buf); - break; - case SYS_getpid: - gdb_error("Target attempts SYS_getpid call at %s\n", buf); - break; - case SYS_kill: - gdb_error("Target attempts SYS_kill call at %s\n", buf); - break; - case SYS_fstat: - gdb_error("Target attempts SYS_fstat call at %s\n", buf); - break; - default: - gdb_error("Target attempts unknown SYS call at %s\n", buf); - break; - } + mem2hex ((unsigned char *) ®isters[PC], buf, 4, 0); + switch (registers[R0]) + { + case SYS_exit: + gdb_error ("Target program has exited at %s\n", buf); + ptr = remcomOutBuffer; + *ptr++ = 'W'; + sigval = registers[R1] & 0xff; + *ptr++ = hexchars[sigval >> 4]; + *ptr++ = hexchars[sigval & 0xf]; + *ptr++ = 0; + break; + case SYS_open: + gdb_error ("Target attempts SYS_open call at %s\n", buf); + break; + case SYS_close: + gdb_error ("Target attempts SYS_close call at %s\n", buf); + break; + case SYS_read: + gdb_error ("Target attempts SYS_read call at %s\n", buf); + break; + case SYS_write: + if (registers[R1] == 1 || /* write to stdout */ + registers[R1] == 2) /* write to stderr */ + { /* (we can do that) */ + registers[R0] = + gdb_write ((void *) registers[R2], registers[R3]); + return; + } + else + gdb_error ("Target attempts SYS_write call at %s\n", buf); + break; + case SYS_lseek: + gdb_error ("Target attempts SYS_lseek call at %s\n", buf); + break; + case SYS_unlink: + gdb_error ("Target attempts SYS_unlink call at %s\n", buf); + break; + case SYS_getpid: + gdb_error ("Target attempts SYS_getpid call at %s\n", buf); + break; + case SYS_kill: + gdb_error ("Target attempts SYS_kill call at %s\n", buf); + break; + case SYS_fstat: + gdb_error ("Target attempts SYS_fstat call at %s\n", buf); + break; + default: + gdb_error ("Target attempts unknown SYS call at %s\n", buf); + break; + } } - putpacket(remcomOutBuffer); + putpacket (remcomOutBuffer); stepping = 0; - while (1==1) { - remcomOutBuffer[0] = 0; - ptr = getpacket(); - binary = 0; - switch (*ptr++) { - default: /* Unknown code. Return an empty reply message. */ - break; - case 'R': - if (hexToInt (&ptr, &addr)) - registers[PC] = addr; - strcpy(remcomOutBuffer, "OK"); - break; - case '!': - strcpy(remcomOutBuffer, "OK"); - break; - case 'X': /* XAA..AA,LLLL:#cs */ - binary = 1; - case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ - /* 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; - if (binary) - bin2mem (ptr, (unsigned char *) addr, length, 1); - else - hex2mem(ptr, (unsigned char*) addr, length, 1); - if (mem_err) { - strcpy (remcomOutBuffer, "E03"); - gdb_error ("memory fault", ""); - } else { - strcpy(remcomOutBuffer,"OK"); - } - ptr = 0; - } - if (ptr) - { - strcpy(remcomOutBuffer,"E02"); - } - } - break; - case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ - /* 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((unsigned char*) addr, remcomOutBuffer, length, 1); - if (mem_err) { - strcpy (remcomOutBuffer, "E03"); - gdb_error ("memory fault", ""); - } - } - if (ptr) - { - strcpy(remcomOutBuffer,"E01"); - } - break; - 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((unsigned char*) registers, remcomOutBuffer, NUMREGBYTES, 0); - break; - case 'P': /* set the value of a single CPU register - return OK */ + while (1 == 1) + { + remcomOutBuffer[0] = 0; + ptr = getpacket (); + binary = 0; + switch (*ptr++) { - int regno; - - if (hexToInt (&ptr, ®no) && *ptr++ == '=') - if (regno >= 0 && regno < NUMREGS) - { - int stackmode; - - hex2mem (ptr, (unsigned char *) ®isters[regno], 4, 0); - /* - * Since we just changed a single CPU register, let's - * make sure to keep the several stack pointers consistant. - */ - stackmode = registers[PSW] & 0x80; - if (regno == R15) /* stack pointer changed */ - { /* need to change SPI or SPU */ - if (stackmode == 0) - registers[SPI] = registers[R15]; - else - registers[SPU] = registers[R15]; - } - else if (regno == SPU) /* "user" stack pointer changed */ - { - if (stackmode != 0) /* stack in user mode: copy SP */ - registers[R15] = registers[SPU]; - } - else if (regno == SPI) /* "interrupt" stack pointer changed */ - { - if (stackmode == 0) /* stack in interrupt mode: copy SP */ - registers[R15] = registers[SPI]; - } - else if (regno == PSW) /* stack mode may have changed! */ - { /* force SP to either SPU or SPI */ - if (stackmode == 0) /* stack in user mode */ - registers[R15] = registers[SPI]; - else /* stack in interrupt mode */ - registers[R15] = registers[SPU]; - } - strcpy (remcomOutBuffer, "OK"); - break; - } - strcpy (remcomOutBuffer, "E01"); + default: /* Unknown code. Return an empty reply message. */ break; - } - case 'G': /* set the value of the CPU registers - return OK */ - hex2mem(ptr, (unsigned char*) registers, NUMREGBYTES, 0); - strcpy(remcomOutBuffer,"OK"); - break; - case 's': /* sAA..AA Step one instruction from AA..AA(optional) */ - stepping = 1; - case 'c': /* cAA..AA Continue from address AA..AA(optional) */ - /* try to read optional parameter, pc unchanged if no parm */ - if (hexToInt(&ptr,&addr)) - registers[ PC ] = addr; - - if (stepping) /* single-stepping */ + case 'R': + if (hexToInt (&ptr, &addr)) + registers[PC] = addr; + strcpy (remcomOutBuffer, "OK"); + break; + case '!': + strcpy (remcomOutBuffer, "OK"); + break; + case 'X': /* XAA..AA,LLLL:#cs */ + binary = 1; + case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ + /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */ { - if (!prepare_to_step(0)) /* set up for single-step */ + if (hexToInt (&ptr, &addr)) + if (*(ptr++) == ',') + if (hexToInt (&ptr, &length)) + if (*(ptr++) == ':') + { + mem_err = 0; + if (binary) + bin2mem (ptr, (unsigned char *) addr, length, 1); + else + hex2mem (ptr, (unsigned char *) addr, length, 1); + if (mem_err) + { + strcpy (remcomOutBuffer, "E03"); + gdb_error ("memory fault", ""); + } + else + { + strcpy (remcomOutBuffer, "OK"); + } + ptr = 0; + } + if (ptr) { - /* prepare_to_step has already emulated the target insn: - Send SIGTRAP to gdb, don't resume the target at all. */ - ptr = remcomOutBuffer; - *ptr++ = 'T'; /* Simulate stopping with SIGTRAP */ - *ptr++ = '0'; - *ptr++ = '5'; - - *ptr++ = hexchars[PC >> 4]; /* send PC */ - *ptr++ = hexchars[PC & 0xf]; - *ptr++ = ':'; - ptr = mem2hex((unsigned char *)®isters[PC], ptr, 4, 0); - *ptr++ = ';'; - - *ptr++ = hexchars[R13 >> 4]; /* send FP */ - *ptr++ = hexchars[R13 & 0xf]; - *ptr++ = ':'; - ptr = mem2hex((unsigned char *)®isters[R13], ptr, 4, 0); - *ptr++ = ';'; - - *ptr++ = hexchars[R15 >> 4]; /* send SP */ - *ptr++ = hexchars[R15 & 0xf]; - *ptr++ = ':'; - ptr = mem2hex((unsigned char *)®isters[R15], ptr, 4, 0); - *ptr++ = ';'; - *ptr++ = 0; - - break; + strcpy (remcomOutBuffer, "E02"); } } - else /* continuing, not single-stepping */ - { - /* OK, about to do a "continue". First check to see if the - target pc is on an odd boundary (second instruction in the - word). If so, we must do a single-step first, because - ya can't jump or return back to an odd boundary! */ - if ((registers[PC] & 2) != 0) - prepare_to_step(1); - } - - return; - - case 'D': /* Detach */ -#if 0 - /* I am interpreting this to mean, release the board from control - by the remote stub. To do this, I am restoring the original - (or at least previous) exception vectors. - */ - for (i = 0; i < 18; i++) - exceptionHandler (i, save_vectors[i]); - putpacket ("OK"); - return; /* continue the inferior */ -#else - strcpy(remcomOutBuffer,"OK"); - break; -#endif - case 'q': - if (*ptr++ == 'C' && - *ptr++ == 'R' && - *ptr++ == 'C' && - *ptr++ == ':') - { - unsigned long start, len, our_crc; - - if (hexToInt (&ptr, (int *) &start) && - *ptr++ == ',' && - hexToInt (&ptr, (int *) &len)) + break; + case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ + /* 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 ((unsigned char *) addr, remcomOutBuffer, length, + 1); + if (mem_err) + { + strcpy (remcomOutBuffer, "E03"); + gdb_error ("memory fault", ""); + } + } + if (ptr) { - remcomOutBuffer[0] = 'C'; - our_crc = crc32 ((unsigned char *) start, len, 0xffffffff); - mem2hex ((char *) &our_crc, - &remcomOutBuffer[1], - sizeof (long), - 0); - } /* else do nothing */ - } /* else do nothing */ - break; + strcpy (remcomOutBuffer, "E01"); + } + break; + 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 ((unsigned char *) registers, remcomOutBuffer, NUMREGBYTES, + 0); + break; + case 'P': /* set the value of a single CPU register - return OK */ + { + int regno; - case 'k': /* kill the program */ - continue; - } /* switch */ + if (hexToInt (&ptr, ®no) && *ptr++ == '=') + if (regno >= 0 && regno < NUMREGS) + { + int stackmode; - /* reply to the request */ - putpacket(remcomOutBuffer); - } + hex2mem (ptr, (unsigned char *) ®isters[regno], 4, 0); + /* + * Since we just changed a single CPU register, let's + * make sure to keep the several stack pointers consistant. + */ + stackmode = registers[PSW] & 0x80; + if (regno == R15) /* stack pointer changed */ + { /* need to change SPI or SPU */ + if (stackmode == 0) + registers[SPI] = registers[R15]; + else + registers[SPU] = registers[R15]; + } + else if (regno == SPU) /* "user" stack pointer changed */ + { + if (stackmode != 0) /* stack in user mode: copy SP */ + registers[R15] = registers[SPU]; + } + else if (regno == SPI) /* "interrupt" stack pointer changed */ + { + if (stackmode == 0) /* stack in interrupt mode: copy SP */ + registers[R15] = registers[SPI]; + } + else if (regno == PSW) /* stack mode may have changed! */ + { /* force SP to either SPU or SPI */ + if (stackmode == 0) /* stack in user mode */ + registers[R15] = registers[SPI]; + else /* stack in interrupt mode */ + registers[R15] = registers[SPU]; + } + strcpy (remcomOutBuffer, "OK"); + break; + } + strcpy (remcomOutBuffer, "E01"); + break; + } + case 'G': /* set the value of the CPU registers - return OK */ + hex2mem (ptr, (unsigned char *) registers, NUMREGBYTES, 0); + strcpy (remcomOutBuffer, "OK"); + break; + case 's': /* sAA..AA Step one instruction from AA..AA(optional) */ + stepping = 1; + case 'c': /* cAA..AA Continue from address AA..AA(optional) */ + /* try to read optional parameter, pc unchanged if no parm */ + if (hexToInt (&ptr, &addr)) + registers[PC] = addr; + + if (stepping) /* single-stepping */ + { + if (!prepare_to_step (0)) /* set up for single-step */ + { + /* prepare_to_step has already emulated the target insn: + Send SIGTRAP to gdb, don't resume the target at all. */ + ptr = remcomOutBuffer; + *ptr++ = 'T'; /* Simulate stopping with SIGTRAP */ + *ptr++ = '0'; + *ptr++ = '5'; + + *ptr++ = hexchars[PC >> 4]; /* send PC */ + *ptr++ = hexchars[PC & 0xf]; + *ptr++ = ':'; + ptr = mem2hex ((unsigned char *) ®isters[PC], ptr, 4, 0); + *ptr++ = ';'; + + *ptr++ = hexchars[R13 >> 4]; /* send FP */ + *ptr++ = hexchars[R13 & 0xf]; + *ptr++ = ':'; + ptr = + mem2hex ((unsigned char *) ®isters[R13], ptr, 4, 0); + *ptr++ = ';'; + + *ptr++ = hexchars[R15 >> 4]; /* send SP */ + *ptr++ = hexchars[R15 & 0xf]; + *ptr++ = ':'; + ptr = + mem2hex ((unsigned char *) ®isters[R15], ptr, 4, 0); + *ptr++ = ';'; + *ptr++ = 0; + + break; + } + } + else /* continuing, not single-stepping */ + { + /* OK, about to do a "continue". First check to see if the + target pc is on an odd boundary (second instruction in the + word). If so, we must do a single-step first, because + ya can't jump or return back to an odd boundary! */ + if ((registers[PC] & 2) != 0) + prepare_to_step (1); + } + + return; + + case 'D': /* Detach */ +#if 0 + /* I am interpreting this to mean, release the board from control + by the remote stub. To do this, I am restoring the original + (or at least previous) exception vectors. + */ + for (i = 0; i < 18; i++) + exceptionHandler (i, save_vectors[i]); + putpacket ("OK"); + return; /* continue the inferior */ +#else + strcpy (remcomOutBuffer, "OK"); + break; +#endif + case 'q': + if (*ptr++ == 'C' && + *ptr++ == 'R' && *ptr++ == 'C' && *ptr++ == ':') + { + unsigned long start, len, our_crc; + + if (hexToInt (&ptr, (int *) &start) && + *ptr++ == ',' && hexToInt (&ptr, (int *) &len)) + { + remcomOutBuffer[0] = 'C'; + our_crc = crc32 ((unsigned char *) start, len, 0xffffffff); + mem2hex ((char *) &our_crc, + &remcomOutBuffer[1], sizeof (long), 0); + } /* else do nothing */ + } /* else do nothing */ + break; + + case 'k': /* kill the program */ + continue; + } /* switch */ + + /* reply to the request */ + putpacket (remcomOutBuffer); + } } /* qCRC support */ /* Table used by the crc32 function to calcuate the checksum. */ -static unsigned long crc32_table[256] = {0, 0}; +static unsigned long crc32_table[256] = { 0, 0 }; static unsigned long -crc32 (buf, len, crc) - unsigned char *buf; - int len; - unsigned long crc; +crc32 (unsigned char *buf, int len, unsigned long crc) { - if (! crc32_table[1]) + if (!crc32_table[1]) { /* Initialize the CRC table and the decoding table. */ int i, j; @@ -562,20 +570,22 @@ crc32 (buf, len, crc) return crc; } -static int -hex(ch) - unsigned char ch; +static int +hex (unsigned 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); } /* scan for the sequence $# */ unsigned char * -getpacket () +getpacket (void) { unsigned char *buffer = &remcomInBuffer[0]; unsigned char checksum; @@ -589,16 +599,16 @@ getpacket () while ((ch = getDebugChar ()) != '$') ; -retry: + retry: checksum = 0; xmitcsum = -1; count = 0; /* now, read until a # or end of buffer is found */ - while (count < BUFMAX) + while (count < BUFMAX - 1) { ch = getDebugChar (); - if (ch == '$') + if (ch == '$') goto retry; if (ch == '#') break; @@ -621,11 +631,11 @@ retry: { unsigned char buf[16]; - mem2hex((unsigned char *) &checksum, buf, 4, 0); - gdb_error("Bad checksum: my count = %s, ", buf); - mem2hex((unsigned char *) &xmitcsum, buf, 4, 0); - gdb_error("sent count = %s\n", buf); - gdb_error(" -- Bad buffer: \"%s\"\n", buffer); + mem2hex ((unsigned char *) &checksum, buf, 4, 0); + gdb_error ("Bad checksum: my count = %s, ", buf); + mem2hex ((unsigned char *) &xmitcsum, buf, 4, 0); + gdb_error ("sent count = %s\n", buf); + gdb_error (" -- Bad buffer: \"%s\"\n", buffer); } putDebugChar ('-'); /* failed checksum */ } @@ -650,37 +660,39 @@ retry: /* send the packet in buffer. */ -static void -putpacket(buffer) - unsigned char *buffer; +static void +putpacket (unsigned char *buffer) { unsigned char checksum; - int count; + int count; char ch; /* $#. */ - do { - putDebugChar('$'); - checksum = 0; - count = 0; + do + { + putDebugChar ('$'); + checksum = 0; + count = 0; - while (ch=buffer[count]) { - putDebugChar(ch); - checksum += ch; - count += 1; + while (ch = buffer[count]) + { + putDebugChar (ch); + checksum += ch; + count += 1; + } + putDebugChar ('#'); + putDebugChar (hexchars[checksum >> 4]); + putDebugChar (hexchars[checksum % 16]); } - putDebugChar('#'); - putDebugChar(hexchars[checksum >> 4]); - putDebugChar(hexchars[checksum % 16]); - } while (getDebugChar() != '+'); + while (getDebugChar () != '+'); } /* Address of a routine to RTE to if we get a memory fault. */ -static void (*volatile mem_fault_routine)() = 0; +static void (*volatile mem_fault_routine) () = 0; static void -set_mem_err () +set_mem_err (void) { mem_err = 1; } @@ -691,18 +703,21 @@ set_mem_err () whether there's anything connected to the expansion bus. */ static int -mem_safe (addr) - unsigned char *addr; +mem_safe (unsigned char *addr) { #define BAD_RANGE_ONE_START ((unsigned char *) 0x600000) #define BAD_RANGE_ONE_END ((unsigned char *) 0xa00000) #define BAD_RANGE_TWO_START ((unsigned char *) 0xff680000) #define BAD_RANGE_TWO_END ((unsigned char *) 0xff800000) - if (addr < BAD_RANGE_ONE_START) return 1; /* safe */ - if (addr < BAD_RANGE_ONE_END) return 0; /* unsafe */ - if (addr < BAD_RANGE_TWO_START) return 1; /* safe */ - if (addr < BAD_RANGE_TWO_END) return 0; /* unsafe */ + if (addr < BAD_RANGE_ONE_START) + return 1; /* safe */ + if (addr < BAD_RANGE_ONE_END) + return 0; /* unsafe */ + if (addr < BAD_RANGE_TWO_START) + return 1; /* safe */ + if (addr < BAD_RANGE_TWO_END) + return 0; /* unsafe */ } /* These are separate functions so that they are so short and sweet @@ -710,11 +725,10 @@ mem_safe (addr) to mem_fault, they won't get restored, so there better not be any saved). */ static int -get_char (addr) - unsigned char *addr; +get_char (unsigned char *addr) { #if 1 - if (mem_fault_routine && !mem_safe(addr)) + if (mem_fault_routine && !mem_safe (addr)) { mem_fault_routine (); return 0; @@ -724,9 +738,7 @@ get_char (addr) } static void -set_char (addr, val) - unsigned char *addr; - unsigned char val; +set_char (unsigned char *addr, unsigned char val) { #if 1 if (mem_fault_routine && !mem_safe (addr)) @@ -744,55 +756,49 @@ set_char (addr, val) a fault; if zero treat a fault like any other fault in the stub. */ static unsigned char * -mem2hex(mem, buf, count, may_fault) - unsigned char* mem; - unsigned char* buf; - int count; - int may_fault; +mem2hex (unsigned char *mem, unsigned 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> 4]; - *buf++ = hexchars[ch % 16]; - } + 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 = 0; - return(buf); + 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. */ -static unsigned char* -hex2mem(buf, mem, count, may_fault) - unsigned char* buf; - unsigned char* mem; - int count; - int may_fault; +static unsigned char * +hex2mem (unsigned char *buf, unsigned 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=0) - { - *intValue = (*intValue <<4) | hexValue; - numChars ++; - } + hexValue = hex (**ptr); + if (hexValue >= 0) + { + *intValue = (*intValue << 4) | hexValue; + numChars++; + } else break; (*ptr)++; @@ -927,40 +965,38 @@ hexToInt(ptr, intValue) FCxxxxxx BC branch condition (long) */ -static int -isShortBranch(instr) - unsigned char *instr; +static int +isShortBranch (unsigned char *instr) { - unsigned char instr0 = instr[0] & 0x7F; /* mask off high bit */ + unsigned char instr0 = instr[0] & 0x7F; /* mask off high bit */ if (instr0 == 0x10 && instr[1] == 0xB6) /* RTE */ - return 1; /* return from trap or exception */ + return 1; /* return from trap or exception */ - if (instr0 == 0x1E || instr0 == 0x1F) /* JL or JMP */ + if (instr0 == 0x1E || instr0 == 0x1F) /* JL or JMP */ if ((instr[1] & 0xF0) == 0xC0) - return 2; /* jump thru a register */ + return 2; /* jump thru a register */ - if (instr0 == 0x7C || instr0 == 0x7D || /* BC, BNC, BL, BRA */ + if (instr0 == 0x7C || instr0 == 0x7D || /* BC, BNC, BL, BRA */ instr0 == 0x7E || instr0 == 0x7F) - return 3; /* eight bit PC offset */ + return 3; /* eight bit PC offset */ return 0; } static int -isLongBranch(instr) - unsigned char *instr; +isLongBranch (unsigned char *instr) { if (instr[0] == 0xFC || instr[0] == 0xFD || /* BRA, BNC, BL, BC */ instr[0] == 0xFE || instr[0] == 0xFF) /* 24 bit relative */ return 4; - if ((instr[0] & 0xF0) == 0xB0) /* 16 bit relative */ + if ((instr[0] & 0xF0) == 0xB0) /* 16 bit relative */ { - if ((instr[1] & 0xF0) == 0x00 || /* BNE, BEQ */ + if ((instr[1] & 0xF0) == 0x00 || /* BNE, BEQ */ (instr[1] & 0xF0) == 0x10) return 5; if (instr[0] == 0xB0) /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ, BEQZ */ - if ((instr[1] & 0xF0) == 0x80 || (instr[1] & 0xF0) == 0x90 || + if ((instr[1] & 0xF0) == 0x80 || (instr[1] & 0xF0) == 0x90 || (instr[1] & 0xF0) == 0xA0 || (instr[1] & 0xF0) == 0xB0 || (instr[1] & 0xF0) == 0xC0 || (instr[1] & 0xF0) == 0xD0) return 6; @@ -975,27 +1011,28 @@ isLongBranch(instr) ((((int) addr & 2) || (((unsigned char *) addr)[0] & 0x80) == 0) ? 2 : 4) static int -isBranch(instr) - unsigned char *instr; +isBranch (unsigned char *instr) { - if (INSTRUCTION_SIZE(instr) == 2) - return isShortBranch(instr); + if (INSTRUCTION_SIZE (instr) == 2) + return isShortBranch (instr); else - return isLongBranch(instr); + return isLongBranch (instr); } static int -willBranch(instr, branchCode) - unsigned char *instr; +willBranch (unsigned char *instr, int branchCode) { - switch (branchCode) + switch (branchCode) { - case 0: return 0; /* not a branch */ - case 1: return 1; /* RTE */ - case 2: return 1; /* JL or JMP */ + case 0: + return 0; /* not a branch */ + case 1: + return 1; /* RTE */ + case 2: + return 1; /* JL or JMP */ case 3: /* BC, BNC, BL, BRA (short) */ case 4: /* BC, BNC, BL, BRA (long) */ - switch (instr[0] & 0x0F) + switch (instr[0] & 0x0F) { case 0xC: /* Branch if Condition Register */ return (registers[CBR] != 0); @@ -1007,8 +1044,8 @@ willBranch(instr, branchCode) default: /* oops? */ return 0; } - case 5: /* BNE, BEQ */ - switch (instr[1] & 0xF0) + case 5: /* BNE, BEQ */ + switch (instr[1] & 0xF0) { case 0x00: /* Branch if r1 equal to r2 */ return (registers[instr[0] & 0x0F] == registers[instr[1] & 0x0F]); @@ -1017,8 +1054,8 @@ willBranch(instr, branchCode) default: /* oops? */ return 0; } - case 6: /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ */ - switch (instr[1] & 0xF0) + case 6: /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ */ + switch (instr[1] & 0xF0) { case 0x80: /* Branch if reg equal to zero */ return (registers[instr[1] & 0x0F] == 0); @@ -1040,27 +1077,28 @@ willBranch(instr, branchCode) } } -static int -branchDestination(instr, branchCode) - unsigned char *instr; -{ - switch (branchCode) { - default: - case 0: /* not a branch */ - return 0; - case 1: /* RTE */ - return registers[BPC] & ~3; /* pop BPC into PC */ - case 2: /* JL or JMP */ - return registers[instr[1] & 0x0F] & ~3; /* jump thru a register */ - case 3: /* BC, BNC, BL, BRA (short, 8-bit relative offset) */ - return (((int) instr) & ~3) + ((char) instr[1] << 2); - case 4: /* BC, BNC, BL, BRA (long, 24-bit relative offset) */ - return ((int) instr + - ((((char) instr[1] << 16) | (instr[2] << 8) | (instr[3])) << 2)); - case 5: /* BNE, BEQ (16-bit relative offset) */ - case 6: /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ (ditto) */ - return ((int) instr + ((((char) instr[2] << 8) | (instr[3])) << 2)); - } +static int +branchDestination (unsigned char *instr, int branchCode) +{ + switch (branchCode) + { + default: + case 0: /* not a branch */ + return 0; + case 1: /* RTE */ + return registers[BPC] & ~3; /* pop BPC into PC */ + case 2: /* JL or JMP */ + return registers[instr[1] & 0x0F] & ~3; /* jump thru a register */ + case 3: /* BC, BNC, BL, BRA (short, 8-bit relative offset) */ + return (((int) instr) & ~3) + ((char) instr[1] << 2); + case 4: /* BC, BNC, BL, BRA (long, 24-bit relative offset) */ + return ((int) instr + + ((((char) instr[1] << 16) | (instr[2] << 8) | (instr[3])) << + 2)); + case 5: /* BNE, BEQ (16-bit relative offset) */ + case 6: /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ (ditto) */ + return ((int) instr + ((((char) instr[2] << 8) | (instr[3])) << 2)); + } /* An explanatory note: in the last three return expressions, I have cast the most-significant byte of the return offset to char. @@ -1073,9 +1111,7 @@ branchDestination(instr, branchCode) } static void -branchSideEffects(instr, branchCode) - unsigned char *instr; - int branchCode; +branchSideEffects (unsigned char *instr, int branchCode) { switch (branchCode) { @@ -1084,7 +1120,7 @@ branchSideEffects(instr, branchCode) case 2: /* JL (or JMP) */ case 3: /* BL (or BC, BNC, BRA) */ case 4: - if ((instr[0] & 0x0F) == 0x0E) /* branch/jump and link */ + if ((instr[0] & 0x0F) == 0x0E) /* branch/jump and link */ registers[R14] = (registers[PC] & ~3) + 4; return; default: /* any other branch has no side effects */ @@ -1092,13 +1128,14 @@ branchSideEffects(instr, branchCode) } } -static struct STEPPING_CONTEXT { +static struct STEPPING_CONTEXT +{ int stepping; /* true when we've started a single-step */ - unsigned long target_addr; /* the instr we're trying to execute */ - unsigned long target_size; /* the size of the target instr */ - unsigned long noop_addr; /* where we've inserted a no-op, if any */ - unsigned long trap1_addr; /* the trap following the target instr */ - unsigned long trap2_addr; /* the trap at a branch destination, if any */ + unsigned long target_addr; /* the instr we're trying to execute */ + unsigned long target_size; /* the size of the target instr */ + unsigned long noop_addr; /* where we've inserted a no-op, if any */ + unsigned long trap1_addr; /* the trap following the target instr */ + unsigned long trap2_addr; /* the trap at a branch destination, if any */ unsigned short noop_save; /* instruction overwritten by our no-op */ unsigned short trap1_save; /* instruction overwritten by trap1 */ unsigned short trap2_save; /* instruction overwritten by trap2 */ @@ -1116,51 +1153,50 @@ static struct STEPPING_CONTEXT { in which case we simply report to GDB that the instruction has already been executed. */ -#define TRAP1 0x10f1; /* trap #1 instruction */ -#define NOOP 0x7000; /* noop instruction */ +#define TRAP1 0x10f1; /* trap #1 instruction */ +#define NOOP 0x7000; /* noop instruction */ static unsigned short trap1 = TRAP1; -static unsigned short noop = NOOP; +static unsigned short noop = NOOP; static int -prepare_to_step(continue_p) - int continue_p; /* if this isn't REALLY a single-step (see below) */ +prepare_to_step (continue_p) + int continue_p; /* if this isn't REALLY a single-step (see below) */ { unsigned long pc = registers[PC]; - int branchCode = isBranch((unsigned char *) pc); + int branchCode = isBranch ((unsigned char *) pc); unsigned char *p; /* zero out the stepping context (paranoia -- it should already be zeroed) */ for (p = (unsigned char *) &stepping; - p < ((unsigned char *) &stepping) + sizeof(stepping); - p++) + p < ((unsigned char *) &stepping) + sizeof (stepping); p++) *p = 0; - if (branchCode != 0) /* next instruction is a branch */ + if (branchCode != 0) /* next instruction is a branch */ { - branchSideEffects((unsigned char *) pc, branchCode); - if (willBranch((unsigned char *)pc, branchCode)) - registers[PC] = branchDestination((unsigned char *) pc, branchCode); + branchSideEffects ((unsigned char *) pc, branchCode); + if (willBranch ((unsigned char *) pc, branchCode)) + registers[PC] = branchDestination ((unsigned char *) pc, branchCode); else - registers[PC] = pc + INSTRUCTION_SIZE(pc); + registers[PC] = pc + INSTRUCTION_SIZE (pc); return 0; /* branch "executed" -- just notify GDB */ } - else if (((int) pc & 2) != 0) /* "second-slot" instruction */ + else if (((int) pc & 2) != 0) /* "second-slot" instruction */ { /* insert no-op before pc */ - stepping.noop_addr = pc - 2; - stepping.noop_save = *(unsigned short *) stepping.noop_addr; - *(unsigned short *) stepping.noop_addr = noop; + stepping.noop_addr = pc - 2; + stepping.noop_save = *(unsigned short *) stepping.noop_addr; + *(unsigned short *) stepping.noop_addr = noop; /* insert trap after pc */ - stepping.trap1_addr = pc + 2; + stepping.trap1_addr = pc + 2; stepping.trap1_save = *(unsigned short *) stepping.trap1_addr; *(unsigned short *) stepping.trap1_addr = trap1; } - else /* "first-slot" instruction */ + else /* "first-slot" instruction */ { /* insert trap after pc */ - stepping.trap1_addr = pc + INSTRUCTION_SIZE(pc); + stepping.trap1_addr = pc + INSTRUCTION_SIZE (pc); stepping.trap1_save = *(unsigned short *) stepping.trap1_addr; *(unsigned short *) stepping.trap1_addr = trap1; } @@ -1169,7 +1205,7 @@ prepare_to_step(continue_p) one single-step before continuing, because the PC is on a half-word boundary. There's no way to simply resume at such an address. */ stepping.continue_p = continue_p; - stepping.stepping = 1; /* starting a single-step */ + stepping.stepping = 1; /* starting a single-step */ return 1; } @@ -1185,7 +1221,7 @@ prepare_to_step(continue_p) just "continue continuing". */ static int -finish_from_step() +finish_from_step (void) { if (stepping.stepping) /* anything to do? */ { @@ -1193,33 +1229,33 @@ finish_from_step() unsigned char *p; if (stepping.noop_addr) /* replace instr "under" our no-op */ - *(unsigned short *) stepping.noop_addr = stepping.noop_save; + *(unsigned short *) stepping.noop_addr = stepping.noop_save; if (stepping.trap1_addr) /* replace instr "under" our trap */ *(unsigned short *) stepping.trap1_addr = stepping.trap1_save; - if (stepping.trap2_addr) /* ditto our other trap, if any */ + if (stepping.trap2_addr) /* ditto our other trap, if any */ *(unsigned short *) stepping.trap2_addr = stepping.trap2_save; for (p = (unsigned char *) &stepping; /* zero out the stepping context */ - p < ((unsigned char *) &stepping) + sizeof(stepping); - p++) + p < ((unsigned char *) &stepping) + sizeof (stepping); p++) *p = 0; return !(continue_p); } - else /* we didn't single-step, therefore this must be a legitimate stop */ + else /* we didn't single-step, therefore this must be a legitimate stop */ return 1; } -struct PSWreg { /* separate out the bit flags in the PSW register */ - int pad1 : 16; - int bsm : 1; - int bie : 1; - int pad2 : 5; - int bc : 1; - int sm : 1; - int ie : 1; - int pad3 : 5; - int c : 1; +struct PSWreg +{ /* separate out the bit flags in the PSW register */ + int pad1:16; + int bsm:1; + int bie:1; + int pad2:5; + int bc:1; + int sm:1; + int ie:1; + int pad3:5; + int c:1; } *psw; /* Upon entry the value for LR to save has been pushed. @@ -1227,47 +1263,47 @@ struct PSWreg { /* separate out the bit flags in the PSW register */ Upon entry, all other registers are assumed to have not been modified since the interrupt/trap occured. */ -asm (" -stash_registers: - push r0 - push r1 - seth r1, #shigh(registers) - add3 r1, r1, #low(registers) - pop r0 ; r1 - st r0, @(4,r1) - pop r0 ; r0 - st r0, @r1 - addi r1, #4 ; only add 4 as subsequent saves are `pre inc' - st r2, @+r1 - st r3, @+r1 - st r4, @+r1 - st r5, @+r1 - st r6, @+r1 - st r7, @+r1 - st r8, @+r1 - st r9, @+r1 - st r10, @+r1 - st r11, @+r1 - st r12, @+r1 - st r13, @+r1 ; fp - pop r0 ; lr (r14) - st r0, @+r1 - st sp, @+r1 ; sp contains right value at this point - mvfc r0, cr0 - st r0, @+r1 ; cr0 == PSW - mvfc r0, cr1 - st r0, @+r1 ; cr1 == CBR - mvfc r0, cr2 - st r0, @+r1 ; cr2 == SPI - mvfc r0, cr3 - st r0, @+r1 ; cr3 == SPU - mvfc r0, cr6 - st r0, @+r1 ; cr6 == BPC - st r0, @+r1 ; PC == BPC - mvfaclo r0 - st r0, @+r1 ; ACCL - mvfachi r0 - st r0, @+r1 ; ACCH +asm ("\n\ +stash_registers:\n\ + push r0\n\ + push r1\n\ + seth r1, #shigh(registers)\n\ + add3 r1, r1, #low(registers)\n\ + pop r0 ; r1\n\ + st r0, @(4,r1)\n\ + pop r0 ; r0\n\ + st r0, @r1\n\ + addi r1, #4 ; only add 4 as subsequent saves are `pre inc'\n\ + st r2, @+r1\n\ + st r3, @+r1\n\ + st r4, @+r1\n\ + st r5, @+r1\n\ + st r6, @+r1\n\ + st r7, @+r1\n\ + st r8, @+r1\n\ + st r9, @+r1\n\ + st r10, @+r1\n\ + st r11, @+r1\n\ + st r12, @+r1\n\ + st r13, @+r1 ; fp\n\ + pop r0 ; lr (r14)\n\ + st r0, @+r1\n\ + st sp, @+r1 ; sp contains right value at this point\n\ + mvfc r0, cr0\n\ + st r0, @+r1 ; cr0 == PSW\n\ + mvfc r0, cr1\n\ + st r0, @+r1 ; cr1 == CBR\n\ + mvfc r0, cr2\n\ + st r0, @+r1 ; cr2 == SPI\n\ + mvfc r0, cr3\n\ + st r0, @+r1 ; cr3 == SPU\n\ + mvfc r0, cr6\n\ + st r0, @+r1 ; cr6 == BPC\n\ + st r0, @+r1 ; PC == BPC\n\ + mvfaclo r0\n\ + st r0, @+r1 ; ACCL\n\ + mvfachi r0\n\ + st r0, @+r1 ; ACCH\n\ jmp lr"); /* C routine to clean up what stash_registers did. @@ -1276,17 +1312,17 @@ stash_registers: but doing stash_registers in C isn't straightforward. */ static void -cleanup_stash () +cleanup_stash (void) { psw = (struct PSWreg *) ®isters[PSW]; /* fields of PSW register */ psw->sm = psw->bsm; /* fix up pre-trap values of psw fields */ psw->ie = psw->bie; - psw->c = psw->bc; - registers[CBR] = psw->bc; /* fix up pre-trap "C" register */ + psw->c = psw->bc; + registers[CBR] = psw->bc; /* fix up pre-trap "C" register */ -#if 0 /* FIXME: Was in previous version. Necessary? - (Remember that we use the "rte" insn to return from the - trap/interrupt so the values of bsm, bie, bc are important. */ +#if 0 /* FIXME: Was in previous version. Necessary? + (Remember that we use the "rte" insn to return from the + trap/interrupt so the values of bsm, bie, bc are important. */ psw->bsm = psw->bie = psw->bc = 0; /* zero post-trap values */ #endif @@ -1301,267 +1337,265 @@ cleanup_stash () registers[SPI] = registers[R15]; } -asm (" -restore_and_return: - seth r0, #shigh(registers+8) - add3 r0, r0, #low(registers+8) - ld r2, @r0+ ; restore r2 - ld r3, @r0+ ; restore r3 - ld r4, @r0+ ; restore r4 - ld r5, @r0+ ; restore r5 - ld r6, @r0+ ; restore r6 - ld r7, @r0+ ; restore r7 - ld r8, @r0+ ; restore r8 - ld r9, @r0+ ; restore r9 - ld r10, @r0+ ; restore r10 - ld r11, @r0+ ; restore r11 - ld r12, @r0+ ; restore r12 - ld r13, @r0+ ; restore r13 - ld r14, @r0+ ; restore r14 - ld r15, @r0+ ; restore r15 - ld r1, @r0+ ; restore cr0 == PSW - mvtc r1, cr0 - ld r1, @r0+ ; restore cr1 == CBR (no-op, because it's read only) - mvtc r1, cr1 - ld r1, @r0+ ; restore cr2 == SPI - mvtc r1, cr2 - ld r1, @r0+ ; restore cr3 == SPU - mvtc r1, cr3 - addi r0, #4 ; skip BPC - ld r1, @r0+ ; restore cr6 (BPC) == PC - mvtc r1, cr6 - ld r1, @r0+ ; restore ACCL - mvtaclo r1 - ld r1, @r0+ ; restore ACCH - mvtachi r1 - seth r0, #shigh(registers) - add3 r0, r0, #low(registers) - ld r1, @(4,r0) ; restore r1 - ld r0, @r0 ; restore r0 +asm ("\n\ +restore_and_return:\n\ + seth r0, #shigh(registers+8)\n\ + add3 r0, r0, #low(registers+8)\n\ + ld r2, @r0+ ; restore r2\n\ + ld r3, @r0+ ; restore r3\n\ + ld r4, @r0+ ; restore r4\n\ + ld r5, @r0+ ; restore r5\n\ + ld r6, @r0+ ; restore r6\n\ + ld r7, @r0+ ; restore r7\n\ + ld r8, @r0+ ; restore r8\n\ + ld r9, @r0+ ; restore r9\n\ + ld r10, @r0+ ; restore r10\n\ + ld r11, @r0+ ; restore r11\n\ + ld r12, @r0+ ; restore r12\n\ + ld r13, @r0+ ; restore r13\n\ + ld r14, @r0+ ; restore r14\n\ + ld r15, @r0+ ; restore r15\n\ + ld r1, @r0+ ; restore cr0 == PSW\n\ + mvtc r1, cr0\n\ + ld r1, @r0+ ; restore cr1 == CBR (no-op, because it's read only)\n\ + mvtc r1, cr1\n\ + ld r1, @r0+ ; restore cr2 == SPI\n\ + mvtc r1, cr2\n\ + ld r1, @r0+ ; restore cr3 == SPU\n\ + mvtc r1, cr3\n\ + addi r0, #4 ; skip BPC\n\ + ld r1, @r0+ ; restore cr6 (BPC) == PC\n\ + mvtc r1, cr6\n\ + ld r1, @r0+ ; restore ACCL\n\ + mvtaclo r1\n\ + ld r1, @r0+ ; restore ACCH\n\ + mvtachi r1\n\ + seth r0, #shigh(registers)\n\ + add3 r0, r0, #low(registers)\n\ + ld r1, @(4,r0) ; restore r1\n\ + ld r0, @r0 ; restore r0\n\ rte"); /* General trap handler, called after the registers have been stashed. NUM is the trap/exception number. */ static void -process_exception (num) - int num; +process_exception (int num) { cleanup_stash (); - asm volatile (" - seth r1, #shigh(stackPtr) - add3 r1, r1, #low(stackPtr) - ld r15, @r1 ; setup local stack (protect user stack) - mv r0, %0 - bl handle_exception - bl restore_and_return" - : : "r" (num) : "r0", "r1"); + asm volatile ("\n\ + seth r1, #shigh(stackPtr)\n\ + add3 r1, r1, #low(stackPtr)\n\ + ld r15, @r1 ; setup local stack (protect user stack)\n\ + mv r0, %0\n\ + bl handle_exception\n\ + bl restore_and_return"::"r" (num):"r0", "r1"); } void _catchException0 (); -asm (" -_catchException0: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #0 +asm ("\n\ +_catchException0:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #0\n\ bl process_exception"); void _catchException1 (); -asm (" -_catchException1: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - bl cleanup_stash - seth r1, #shigh(stackPtr) - add3 r1, r1, #low(stackPtr) - ld r15, @r1 ; setup local stack (protect user stack) - seth r1, #shigh(registers + 21*4) ; PC - add3 r1, r1, #low(registers + 21*4) - ld r0, @r1 - addi r0, #-4 ; back up PC for breakpoint trap. - st r0, @r1 ; FIXME: what about bp in right slot? - ldi r0, #1 - bl handle_exception +asm ("\n\ +_catchException1:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + bl cleanup_stash\n\ + seth r1, #shigh(stackPtr)\n\ + add3 r1, r1, #low(stackPtr)\n\ + ld r15, @r1 ; setup local stack (protect user stack)\n\ + seth r1, #shigh(registers + 21*4) ; PC\n\ + add3 r1, r1, #low(registers + 21*4)\n\ + ld r0, @r1\n\ + addi r0, #-4 ; back up PC for breakpoint trap.\n\ + st r0, @r1 ; FIXME: what about bp in right slot?\n\ + ldi r0, #1\n\ + bl handle_exception\n\ bl restore_and_return"); void _catchException2 (); -asm (" -_catchException2: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #2 +asm ("\n\ +_catchException2:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #2\n\ bl process_exception"); void _catchException3 (); -asm (" -_catchException3: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #3 +asm ("\n\ +_catchException3:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #3\n\ bl process_exception"); void _catchException4 (); -asm (" -_catchException4: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #4 +asm ("\n\ +_catchException4:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #4\n\ bl process_exception"); void _catchException5 (); -asm (" -_catchException5: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #5 +asm ("\n\ +_catchException5:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #5\n\ bl process_exception"); void _catchException6 (); -asm (" -_catchException6: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #6 +asm ("\n\ +_catchException6:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #6\n\ bl process_exception"); void _catchException7 (); -asm (" -_catchException7: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #7 +asm ("\n\ +_catchException7:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #7\n\ bl process_exception"); void _catchException8 (); -asm (" -_catchException8: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #8 +asm ("\n\ +_catchException8:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #8\n\ bl process_exception"); void _catchException9 (); -asm (" -_catchException9: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #9 +asm ("\n\ +_catchException9:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #9\n\ bl process_exception"); void _catchException10 (); -asm (" -_catchException10: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #10 +asm ("\n\ +_catchException10:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #10\n\ bl process_exception"); void _catchException11 (); -asm (" -_catchException11: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #11 +asm ("\n\ +_catchException11:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #11\n\ bl process_exception"); void _catchException12 (); -asm (" -_catchException12: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #12 +asm ("\n\ +_catchException12:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #12\n\ bl process_exception"); void _catchException13 (); -asm (" -_catchException13: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #13 +asm ("\n\ +_catchException13:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #13\n\ bl process_exception"); void _catchException14 (); -asm (" -_catchException14: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #14 +asm ("\n\ +_catchException14:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #14\n\ bl process_exception"); void _catchException15 (); -asm (" -_catchException15: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #15 +asm ("\n\ +_catchException15:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #15\n\ bl process_exception"); void _catchException16 (); -asm (" -_catchException16: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #16 +asm ("\n\ +_catchException16:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #16\n\ bl process_exception"); void _catchException17 (); -asm (" -_catchException17: - push lr - bl stash_registers - ; Note that at this point the pushed value of `lr' has been popped - ldi r0, #17 +asm ("\n\ +_catchException17:\n\ + push lr\n\ + bl stash_registers\n\ + ; Note that at this point the pushed value of `lr' has been popped\n\ + ldi r0, #17\n\ bl process_exception"); /* 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 i; - for (i = 0; i < 18; i++) /* keep a copy of old vectors */ - if (save_vectors[i] == 0) /* only copy them the first time */ + for (i = 0; i < 18; i++) /* keep a copy of old vectors */ + if (save_vectors[i] == 0) /* only copy them the first time */ save_vectors[i] = getExceptionHandler (i); - stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1]; + stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1]; exceptionHandler (0, _catchException0); exceptionHandler (1, _catchException1); @@ -1592,11 +1626,11 @@ set_debug_traps() #define BREAKPOINT() asm volatile (" trap #2"); -void -breakpoint() +void +breakpoint (void) { if (initialized) - BREAKPOINT(); + BREAKPOINT (); } /* STDOUT section: @@ -1606,51 +1640,47 @@ breakpoint() gdb_write(char *str, int len) gdb_error(char *format, char *parm) */ - + /* Function: gdb_putchar(int) Make gdb write a char to stdout. Returns: the char */ - + static int -gdb_putchar(ch) - int ch; +gdb_putchar (int ch) { char buf[4]; - + buf[0] = 'O'; buf[1] = hexchars[ch >> 4]; buf[2] = hexchars[ch & 0x0F]; buf[3] = 0; - putpacket(buf); + putpacket (buf); return ch; } - + /* Function: gdb_write(char *, int) Make gdb write n bytes to stdout (not assumed to be null-terminated). Returns: number of bytes written */ - + static int -gdb_write(data, len) - char *data; - int len; +gdb_write (char *data, int len) { char *buf, *cpy; int i; - + buf = remcomOutBuffer; buf[0] = 'O'; i = 0; while (i < len) { - for (cpy = buf+1; - i < len && cpy < buf + sizeof(remcomOutBuffer) - 3; - i++) + for (cpy = buf + 1; + i < len && cpy < buf + sizeof (remcomOutBuffer) - 3; i++) { *cpy++ = hexchars[data[i] >> 4]; *cpy++ = hexchars[data[i] & 0x0F]; } *cpy = 0; - putpacket(buf); + putpacket (buf); } return len; } @@ -1658,42 +1688,39 @@ gdb_write(data, len) /* Function: gdb_puts(char *) Make gdb write a null-terminated string to stdout. Returns: the length of the string */ - + static int -gdb_puts(str) - char *str; +gdb_puts (char *str) { - return gdb_write(str, strlen(str)); + return gdb_write (str, strlen (str)); } - + /* Function: gdb_error(char *, char *) Send an error message to gdb's stdout. First string may have 1 (one) optional "%s" in it, which will cause the optional second string to be inserted. */ - + static void -gdb_error(format, parm) - char * format; - char * parm; +gdb_error (char *format, char *parm) { char buf[400], *cpy; int len; - + if (remote_debug) { if (format && *format) - len = strlen(format); + len = strlen (format); else - return; /* empty input */ + return; /* empty input */ if (parm && *parm) - len += strlen(parm); - - for (cpy = buf; *format; ) + len += strlen (parm); + + for (cpy = buf; *format;) { - if (format[0] == '%' && format[1] == 's') /* include second string */ + if (format[0] == '%' && format[1] == 's') /* include second string */ { - format += 2; /* advance two chars instead of just one */ + format += 2; /* advance two chars instead of just one */ while (parm && *parm) *cpy++ = *parm++; } @@ -1701,10 +1728,10 @@ gdb_error(format, parm) *cpy++ = *format++; } *cpy = '\0'; - gdb_puts(buf); + gdb_puts (buf); } } - + static unsigned char * strcpy (unsigned char *dest, const unsigned char *src) { @@ -1731,18 +1758,21 @@ strlen (const unsigned char *src) } #if 0 -void exit (code) +void +exit (code) int code; { _exit (code); } -int atexit (void *p) +int +atexit (void *p) { return 0; } -void abort (void) +void +abort (void) { _exit (1); }