extern void putDebugChar();
extern int getDebugChar();
extern void exceptionHandler();
#define BUFMAX 400
static char initialized;
int remote_debug;
static const unsigned char hexchars[]="0123456789abcdef";
#define NUMREGS 24
#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 };
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 unsigned int save_vectors[18];
static volatile int mem_err = 0;
int gdb_m32r_vector = -1;
#if 0
#include "syscall.h"
#endif
extern void handle_exception(int);
extern void set_debug_traps(void);
extern void breakpoint(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 unsigned char *strcpy (unsigned char *, const unsigned char *);
static int strlen (const unsigned char *);
void
handle_exception(int exceptionVector)
{
int sigval, stepping;
int addr, length, i;
unsigned char * ptr;
unsigned char buf[16];
int binary;
if (exceptionVector == 1)
if (!finish_from_step())
return;
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);
}
sigval = computeSignal( exceptionVector );
ptr = remcomOutBuffer;
*ptr++ = 'T';
*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);
*ptr++ = ';';
*ptr++ = hexchars[R13 >> 4];
*ptr++ = hexchars[R13 & 0xf];
*ptr++ = ':';
ptr = mem2hex((unsigned char *)®isters[R13], ptr, 4, 0);
*ptr++ = ';';
*ptr++ = hexchars[R15 >> 4];
*ptr++ = hexchars[R15 & 0xf];
*ptr++ = ':';
ptr = mem2hex((unsigned char *)®isters[R15], ptr, 4, 0);
*ptr++ = ';';
*ptr++ = 0;
if (exceptionVector == 0)
{
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 ||
registers[R1] == 2)
{
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);
stepping = 0;
while (1==1) {
remcomOutBuffer[0] = 0;
ptr = getpacket();
binary = 0;
switch (*ptr++) {
default:
break;
case 'R':
if (hexToInt (&ptr, &addr))
registers[PC] = addr;
strcpy(remcomOutBuffer, "OK");
break;
case '!':
strcpy(remcomOutBuffer, "OK");
break;
case 'X':
binary = 1;
case 'M':
{
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':
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);
break;
case 'g':
mem2hex((unsigned char*) registers, remcomOutBuffer, NUMREGBYTES, 0);
break;
case 'P':
{
int regno;
if (hexToInt (&ptr, ®no) && *ptr++ == '=')
if (regno >= 0 && regno < NUMREGS)
{
int stackmode;
hex2mem (ptr, (unsigned char *) ®isters[regno], 4, 0);
stackmode = registers[PSW] & 0x80;
if (regno == R15)
{
if (stackmode == 0)
registers[SPI] = registers[R15];
else
registers[SPU] = registers[R15];
}
else if (regno == SPU)
{
if (stackmode != 0)
registers[R15] = registers[SPU];
}
else if (regno == SPI)
{
if (stackmode == 0)
registers[R15] = registers[SPI];
}
else if (regno == PSW)
{
if (stackmode == 0)
registers[R15] = registers[SPI];
else
registers[R15] = registers[SPU];
}
strcpy (remcomOutBuffer, "OK");
break;
}
strcpy (remcomOutBuffer, "E01");
break;
}
case 'G':
hex2mem(ptr, (unsigned char*) registers, NUMREGBYTES, 0);
strcpy(remcomOutBuffer,"OK");
break;
case 's':
stepping = 1;
case 'c':
if (hexToInt(&ptr,&addr))
registers[ PC ] = addr;
if (stepping)
{
if (!prepare_to_step(0))
{
ptr = remcomOutBuffer;
*ptr++ = 'T';
*ptr++ = '0';
*ptr++ = '5';
*ptr++ = hexchars[PC >> 4];
*ptr++ = hexchars[PC & 0xf];
*ptr++ = ':';
ptr = mem2hex((unsigned char *)®isters[PC], ptr, 4, 0);
*ptr++ = ';';
*ptr++ = hexchars[R13 >> 4];
*ptr++ = hexchars[R13 & 0xf];
*ptr++ = ':';
ptr = mem2hex((unsigned char *)®isters[R13], ptr, 4, 0);
*ptr++ = ';';
*ptr++ = hexchars[R15 >> 4];
*ptr++ = hexchars[R15 & 0xf];
*ptr++ = ':';
ptr = mem2hex((unsigned char *)®isters[R15], ptr, 4, 0);
*ptr++ = ';';
*ptr++ = 0;
break;
}
}
else
{
if ((registers[PC] & 2) != 0)
prepare_to_step(1);
}
return;
case 'D':
#if 0
for (i = 0; i < 18; i++)
exceptionHandler (i, save_vectors[i]);
putpacket ("OK");
return;
#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);
}
}
break;
case 'k':
continue;
}
putpacket(remcomOutBuffer);
}
}
static unsigned long crc32_table[256] = {0, 0};
static unsigned long
crc32 (unsigned char *buf, int len, unsigned long crc)
{
if (! crc32_table[1])
{
int i, j;
unsigned long c;
for (i = 0; i < 256; i++)
{
for (c = i << 24, j = 8; j > 0; --j)
c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
crc32_table[i] = c;
}
}
while (len--)
{
crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
buf++;
}
return crc;
}
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);
return (-1);
}
unsigned char *
getpacket (void)
{
unsigned char *buffer = &remcomInBuffer[0];
unsigned char checksum;
unsigned char xmitcsum;
int count;
char ch;
while (1)
{
while ((ch = getDebugChar ()) != '$')
;
retry:
checksum = 0;
xmitcsum = -1;
count = 0;
while (count < BUFMAX)
{
ch = getDebugChar ();
if (ch == '$')
goto retry;
if (ch == '#')
break;
checksum = checksum + ch;
buffer[count] = ch;
count = count + 1;
}
buffer[count] = 0;
if (ch == '#')
{
ch = getDebugChar ();
xmitcsum = hex (ch) << 4;
ch = getDebugChar ();
xmitcsum += hex (ch);
if (checksum != xmitcsum)
{
if (remote_debug)
{
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);
}
putDebugChar ('-');
}
else
{
putDebugChar ('+');
if (buffer[2] == ':')
{
putDebugChar (buffer[0]);
putDebugChar (buffer[1]);
return &buffer[3];
}
return &buffer[0];
}
}
}
}
static void
putpacket (unsigned char *buffer)
{
unsigned char checksum;
int count;
char ch;
do {
putDebugChar('$');
checksum = 0;
count = 0;
while (ch=buffer[count]) {
putDebugChar(ch);
checksum += ch;
count += 1;
}
putDebugChar('#');
putDebugChar(hexchars[checksum >> 4]);
putDebugChar(hexchars[checksum % 16]);
} while (getDebugChar() != '+');
}
static void (*volatile mem_fault_routine)() = 0;
static void
set_mem_err (void)
{
mem_err = 1;
}
static int
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;
if (addr < BAD_RANGE_ONE_END) return 0;
if (addr < BAD_RANGE_TWO_START) return 1;
if (addr < BAD_RANGE_TWO_END) return 0;
}
static int
get_char (unsigned char *addr)
{
#if 1
if (mem_fault_routine && !mem_safe(addr))
{
mem_fault_routine ();
return 0;
}
#endif
return *addr;
}
static void
set_char (unsigned char *addr, unsigned char val)
{
#if 1
if (mem_fault_routine && !mem_safe (addr))
{
mem_fault_routine ();
return;
}
#endif
*addr = val;
}
static unsigned char *
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];
}
*buf = 0;
if (may_fault)
mem_fault_routine = 0;
return(buf);
}
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);
}
if (may_fault)
mem_fault_routine = 0;
return(mem);
}
static unsigned char *
bin2mem (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++)
{
if (*buf == 0x7d)
{
switch (*(buf+1))
{
case 0x3:
case 0x4:
case 0x5d:
buf++;
*buf |= 0x20;
break;
default:
break;
}
}
set_char (mem++, *buf++);
if (may_fault && mem_err)
return mem;
}
if (may_fault)
mem_fault_routine = 0;
return mem;
}
static int
computeSignal (int exceptionVector)
{
int sigval;
switch (exceptionVector) {
case 0 : sigval = 23; break;
case 1 : sigval = 5; break;
case 2 : sigval = 5; break;
case 3 : sigval = 5; break;
case 4 : sigval = 5; break;
case 5 : sigval = 5; break;
case 6 : sigval = 5; break;
case 7 : sigval = 5; break;
case 8 : sigval = 5; break;
case 9 : sigval = 5; break;
case 10 : sigval = 5; break;
case 11 : sigval = 5; break;
case 12 : sigval = 5; break;
case 13 : sigval = 5; break;
case 14 : sigval = 5; break;
case 15 : sigval = 5; break;
case 16 : sigval = 10; break;
case 17 : sigval = 2; break;
default : sigval = 7; break;
}
return (sigval);
}
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 ++;
}
else
break;
(*ptr)++;
}
return (numChars);
}
static int
isShortBranch (unsigned char *instr)
{
unsigned char instr0 = instr[0] & 0x7F;
if (instr0 == 0x10 && instr[1] == 0xB6)
return 1;
if (instr0 == 0x1E || instr0 == 0x1F)
if ((instr[1] & 0xF0) == 0xC0)
return 2;
if (instr0 == 0x7C || instr0 == 0x7D ||
instr0 == 0x7E || instr0 == 0x7F)
return 3;
return 0;
}
static int
isLongBranch (unsigned char *instr)
{
if (instr[0] == 0xFC || instr[0] == 0xFD ||
instr[0] == 0xFE || instr[0] == 0xFF)
return 4;
if ((instr[0] & 0xF0) == 0xB0)
{
if ((instr[1] & 0xF0) == 0x00 ||
(instr[1] & 0xF0) == 0x10)
return 5;
if (instr[0] == 0xB0)
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;
}
return 0;
}
#define INSTRUCTION_SIZE(addr) \
((((int) addr & 2) || (((unsigned char *) addr)[0] & 0x80) == 0) ? 2 : 4)
static int
isBranch (unsigned char *instr)
{
if (INSTRUCTION_SIZE(instr) == 2)
return isShortBranch(instr);
else
return isLongBranch(instr);
}
static int
willBranch (unsigned char *instr, int branchCode)
{
switch (branchCode)
{
case 0: return 0;
case 1: return 1;
case 2: return 1;
case 3:
case 4:
switch (instr[0] & 0x0F)
{
case 0xC:
return (registers[CBR] != 0);
case 0xD:
return (registers[CBR] == 0);
case 0xE:
case 0xF:
return 1;
default:
return 0;
}
case 5:
switch (instr[1] & 0xF0)
{
case 0x00:
return (registers[instr[0] & 0x0F] == registers[instr[1] & 0x0F]);
case 0x10:
return (registers[instr[0] & 0x0F] != registers[instr[1] & 0x0F]);
default:
return 0;
}
case 6:
switch (instr[1] & 0xF0)
{
case 0x80:
return (registers[instr[1] & 0x0F] == 0);
case 0x90:
return (registers[instr[1] & 0x0F] != 0);
case 0xA0:
return (registers[instr[1] & 0x0F] < 0);
case 0xB0:
return (registers[instr[1] & 0x0F] >= 0);
case 0xC0:
return (registers[instr[1] & 0x0F] <= 0);
case 0xD0:
return (registers[instr[1] & 0x0F] > 0);
default:
return 0;
}
default:
return 0;
}
}
static int
branchDestination (unsigned char *instr, int branchCode)
{
switch (branchCode) {
default:
case 0:
return 0;
case 1:
return registers[BPC] & ~3;
case 2:
return registers[instr[1] & 0x0F] & ~3;
case 3:
return (((int) instr) & ~3) + ((char) instr[1] << 2);
case 4:
return ((int) instr +
((((char) instr[1] << 16) | (instr[2] << 8) | (instr[3])) << 2));
case 5:
case 6:
return ((int) instr + ((((char) instr[2] << 8) | (instr[3])) << 2));
}
}
static void
branchSideEffects (unsigned char *instr, int branchCode)
{
switch (branchCode)
{
case 1:
return;
case 2:
case 3:
case 4:
if ((instr[0] & 0x0F) == 0x0E)
registers[R14] = (registers[PC] & ~3) + 4;
return;
default:
return;
}
}
static struct STEPPING_CONTEXT {
int stepping;
unsigned long target_addr;
unsigned long target_size;
unsigned long noop_addr;
unsigned long trap1_addr;
unsigned long trap2_addr;
unsigned short noop_save;
unsigned short trap1_save;
unsigned short trap2_save;
unsigned short continue_p;
} stepping;
#define TRAP1 0x10f1;
#define NOOP 0x7000;
static unsigned short trap1 = TRAP1;
static unsigned short noop = NOOP;
static int
prepare_to_step(continue_p)
int continue_p;
{
unsigned long pc = registers[PC];
int branchCode = isBranch((unsigned char *) pc);
unsigned char *p;
for (p = (unsigned char *) &stepping;
p < ((unsigned char *) &stepping) + sizeof(stepping);
p++)
*p = 0;
if (branchCode != 0)
{
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);
return 0;
}
else if (((int) pc & 2) != 0)
{
stepping.noop_addr = pc - 2;
stepping.noop_save = *(unsigned short *) stepping.noop_addr;
*(unsigned short *) stepping.noop_addr = noop;
stepping.trap1_addr = pc + 2;
stepping.trap1_save = *(unsigned short *) stepping.trap1_addr;
*(unsigned short *) stepping.trap1_addr = trap1;
}
else
{
stepping.trap1_addr = pc + INSTRUCTION_SIZE(pc);
stepping.trap1_save = *(unsigned short *) stepping.trap1_addr;
*(unsigned short *) stepping.trap1_addr = trap1;
}
stepping.continue_p = continue_p;
stepping.stepping = 1;
return 1;
}
static int
finish_from_step (void)
{
if (stepping.stepping)
{
int continue_p = stepping.continue_p;
unsigned char *p;
if (stepping.noop_addr)
*(unsigned short *) stepping.noop_addr = stepping.noop_save;
if (stepping.trap1_addr)
*(unsigned short *) stepping.trap1_addr = stepping.trap1_save;
if (stepping.trap2_addr)
*(unsigned short *) stepping.trap2_addr = stepping.trap2_save;
for (p = (unsigned char *) &stepping;
p < ((unsigned char *) &stepping) + sizeof(stepping);
p++)
*p = 0;
return !(continue_p);
}
else
return 1;
}
struct PSWreg {
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;
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
jmp lr");
static void
cleanup_stash (void)
{
psw = (struct PSWreg *) ®isters[PSW];
psw->sm = psw->bsm;
psw->ie = psw->bie;
psw->c = psw->bc;
registers[CBR] = psw->bc;
#if 0
psw->bsm = psw->bie = psw->bc = 0;
#endif
registers[PC] = registers[BPC];
if (psw->sm)
registers[SPU] = registers[R15];
else
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
addi r0, #4 ; don't restore PSW (rte will do it)
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
rte");
static void
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");
}
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
bl process_exception");
void
set_debug_traps (void)
{
int i;
for (i = 0; i < 18; i++)
if (save_vectors[i] == 0)
save_vectors[i] = getExceptionHandler (i);
stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];
exceptionHandler (0, _catchException0);
exceptionHandler (1, _catchException1);
exceptionHandler (2, _catchException2);
exceptionHandler (3, _catchException3);
exceptionHandler (4, _catchException4);
exceptionHandler (5, _catchException5);
exceptionHandler (6, _catchException6);
exceptionHandler (7, _catchException7);
exceptionHandler (8, _catchException8);
exceptionHandler (9, _catchException9);
exceptionHandler (10, _catchException10);
exceptionHandler (11, _catchException11);
exceptionHandler (12, _catchException12);
exceptionHandler (13, _catchException13);
exceptionHandler (14, _catchException14);
exceptionHandler (15, _catchException15);
exceptionHandler (16, _catchException16);
initialized = 1;
}
#define BREAKPOINT() asm volatile (" trap #2");
void
breakpoint (void)
{
if (initialized)
BREAKPOINT();
}
static int
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);
return ch;
}
static int
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++)
{
*cpy++ = hexchars[data[i] >> 4];
*cpy++ = hexchars[data[i] & 0x0F];
}
*cpy = 0;
putpacket(buf);
}
return len;
}
static int
gdb_puts (char *str)
{
return gdb_write(str, strlen(str));
}
static void
gdb_error (char *format, char *parm)
{
char buf[400], *cpy;
int len;
if (remote_debug)
{
if (format && *format)
len = strlen(format);
else
return;
if (parm && *parm)
len += strlen(parm);
for (cpy = buf; *format; )
{
if (format[0] == '%' && format[1] == 's')
{
format += 2;
while (parm && *parm)
*cpy++ = *parm++;
}
else
*cpy++ = *format++;
}
*cpy = '\0';
gdb_puts(buf);
}
}
static unsigned char *
strcpy (unsigned char *dest, const unsigned char *src)
{
unsigned char *ret = dest;
if (dest && src)
{
while (*src)
*dest++ = *src++;
*dest = 0;
}
return ret;
}
static int
strlen (const unsigned char *src)
{
int ret;
for (ret = 0; *src; src++)
ret++;
return ret;
}
#if 0
void exit (code)
int code;
{
_exit (code);
}
int atexit (void *p)
{
return 0;
}
void abort (void)
{
_exit (1);
}
#endif