*
* 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
*/
#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 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 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
+};
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 */
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 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 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 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:<binary data>#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:<binary data>#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 */
+ 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 */
{
- /* 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);
+ 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");
+ 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;
+ return;
- case 'D': /* Detach */
+ 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 */
+ /* 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;
+ 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))
+ case 'q':
+ if (*ptr++ == 'C' &&
+ *ptr++ == 'R' && *ptr++ == 'C' && *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;
-
- case 'k': /* kill the program */
- continue;
- } /* switch */
-
- /* reply to the request */
- putpacket(remcomOutBuffer);
- }
+ 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;
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 $<data>#<checksum> */
unsigned char *
-getpacket ()
+getpacket (void)
{
unsigned char *buffer = &remcomInBuffer[0];
unsigned char checksum;
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;
{
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 */
}
/* 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;
/* $<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;
+
+ 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;
}
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
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;
}
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))
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<count;i++) {
- ch = get_char (mem++);
- if (may_fault && mem_err)
- return (buf);
- *buf++ = hexchars[ch >> 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<count;i++) {
- ch = hex(*buf++) << 4;
- ch = ch + hex(*buf++);
- set_char (mem++, ch);
- if (may_fault && mem_err)
- return (mem);
- }
+ 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 = 0;
- return(mem);
+ return (mem);
}
/* Convert the binary stream in BUF to memory.
COUNT is the total number of bytes to write into
memory. */
static unsigned char *
-bin2mem (buf, mem, count, may_fault)
- unsigned char *buf;
- unsigned char *mem;
- int count;
- int may_fault;
+bin2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault)
{
int i;
unsigned char ch;
/* Check for any escaped characters. Be paranoid and
only unescape chars that should be escaped. */
if (*buf == 0x7d)
- {
- switch (*(buf+1))
- {
- case 0x3: /* # */
- case 0x4: /* $ */
- case 0x5d: /* escape char */
- buf++;
- *buf |= 0x20;
- break;
- default:
- /* nothing */
- break;
- }
- }
+ {
+ switch (*(buf + 1))
+ {
+ case 0x3: /* # */
+ case 0x4: /* $ */
+ case 0x5d: /* escape char */
+ buf++;
+ *buf |= 0x20;
+ break;
+ default:
+ /* nothing */
+ break;
+ }
+ }
set_char (mem++, *buf++);
if (may_fault && mem_err)
- return mem;
+ return mem;
}
if (may_fault)
/* this function takes the m32r exception vector and attempts to
translate this number into a unix compatible signal value */
-static int
-computeSignal(exceptionVector)
- int exceptionVector;
+static int
+computeSignal (int exceptionVector)
{
int sigval;
- switch (exceptionVector) {
- case 0 : sigval = 23; break; /* I/O trap */
- case 1 : sigval = 5; break; /* breakpoint */
- case 2 : sigval = 5; break; /* breakpoint */
- case 3 : sigval = 5; break; /* breakpoint */
- case 4 : sigval = 5; break; /* breakpoint */
- case 5 : sigval = 5; break; /* breakpoint */
- case 6 : sigval = 5; break; /* breakpoint */
- case 7 : sigval = 5; break; /* breakpoint */
- case 8 : sigval = 5; break; /* breakpoint */
- case 9 : sigval = 5; break; /* breakpoint */
- case 10 : sigval = 5; break; /* breakpoint */
- case 11 : sigval = 5; break; /* breakpoint */
- case 12 : sigval = 5; break; /* breakpoint */
- case 13 : sigval = 5; break; /* breakpoint */
- case 14 : sigval = 5; break; /* breakpoint */
- case 15 : sigval = 5; break; /* breakpoint */
- case 16 : sigval = 10; break; /* BUS ERROR (alignment) */
- case 17 : sigval = 2; break; /* INTerrupt */
- default : sigval = 7; break; /* "software generated" */
- }
+ switch (exceptionVector)
+ {
+ case 0:
+ sigval = 23;
+ break; /* I/O trap */
+ case 1:
+ sigval = 5;
+ break; /* breakpoint */
+ case 2:
+ sigval = 5;
+ break; /* breakpoint */
+ case 3:
+ sigval = 5;
+ break; /* breakpoint */
+ case 4:
+ sigval = 5;
+ break; /* breakpoint */
+ case 5:
+ sigval = 5;
+ break; /* breakpoint */
+ case 6:
+ sigval = 5;
+ break; /* breakpoint */
+ case 7:
+ sigval = 5;
+ break; /* breakpoint */
+ case 8:
+ sigval = 5;
+ break; /* breakpoint */
+ case 9:
+ sigval = 5;
+ break; /* breakpoint */
+ case 10:
+ sigval = 5;
+ break; /* breakpoint */
+ case 11:
+ sigval = 5;
+ break; /* breakpoint */
+ case 12:
+ sigval = 5;
+ break; /* breakpoint */
+ case 13:
+ sigval = 5;
+ break; /* breakpoint */
+ case 14:
+ sigval = 5;
+ break; /* breakpoint */
+ case 15:
+ sigval = 5;
+ break; /* breakpoint */
+ case 16:
+ sigval = 10;
+ break; /* BUS ERROR (alignment) */
+ case 17:
+ sigval = 2;
+ break; /* INTerrupt */
+ default:
+ sigval = 7;
+ break; /* "software generated" */
+ }
return (sigval);
}
/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
/* RETURN NUMBER OF CHARS PROCESSED */
/**********************************************/
-static int
-hexToInt(ptr, intValue)
- unsigned char **ptr;
- int *intValue;
+static int
+hexToInt (unsigned char **ptr, int *intValue)
{
int numChars = 0;
int hexValue;
*intValue = 0;
while (**ptr)
{
- hexValue = hex(**ptr);
- if (hexValue >=0)
- {
- *intValue = (*intValue <<4) | hexValue;
- numChars ++;
- }
+ hexValue = hex (**ptr);
+ if (hexValue >= 0)
+ {
+ *intValue = (*intValue << 4) | hexValue;
+ numChars++;
+ }
else
break;
(*ptr)++;
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;
((((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);
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]);
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);
}
}
-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.
}
static void
-branchSideEffects(instr, branchCode)
- unsigned char *instr;
- int branchCode;
+branchSideEffects (unsigned char *instr, int branchCode)
{
switch (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 */
}
}
-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 */
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;
}
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;
}
just "continue continuing". */
static int
-finish_from_step()
+finish_from_step (void)
{
if (stepping.stepping) /* anything to do? */
{
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.
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.
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
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);
#define BREAKPOINT() asm volatile (" trap #2");
-void
-breakpoint()
+void
+breakpoint (void)
{
if (initialized)
- BREAKPOINT();
+ BREAKPOINT ();
}
/* STDOUT section:
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;
}
/* 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++;
}
*cpy++ = *format++;
}
*cpy = '\0';
- gdb_puts(buf);
+ gdb_puts (buf);
}
}
-
+
static unsigned char *
strcpy (unsigned char *dest, 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);
}
OSDN Git Service
