-/****************************************************************************
-
- THIS SOFTWARE IS NOT COPYRIGHTED
-
- HP offers the following for use in the public domain. HP makes no
- warranty with regard to the software or it's performance and the
- user accepts the software "AS IS" with all faults.
-
- HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
- TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-
-****************************************************************************/
-
-/****************************************************************************
- * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
- *
- * Module name: remcom.c $
- * Revision: 1.34 $
- * Date: 91/03/09 12:29:49 $
- * Contributor: Lake Stevens Instrument Division$
- *
- * Description: low level support for gdb debugger. $
- *
- * Considerations: only works on target hardware $
- *
- * Written by: Glenn Engel $
- * ModuleState: Experimental $
- *
- * NOTES: See Below $
- *
- * Modified for M32R by Michael Snyder, Cygnus Support.
- *
- * To enable debugger support, two things need to happen. One, a
- * call to set_debug_traps() is necessary in order to allow any breakpoints
- * or error conditions to be properly intercepted and reported to gdb.
- * Two, a breakpoint needs to be generated to begin communication. This
- * is most easily accomplished by a call to breakpoint(). Breakpoint()
- * simulates a breakpoint by executing a trap #1.
- *
- * The external function exceptionHandler() is
- * used to attach a specific handler to a specific M32R vector number.
- * It should use the same privilege level it runs at. It should
- * install it as an interrupt gate so that interrupts are masked
- * while the handler runs.
- *
- * Because gdb will sometimes write to the stack area to execute function
- * calls, this program cannot rely on using the supervisor stack so it
- * uses it's own stack area reserved in the int array remcomStack.
- *
- *************
- *
- * The following gdb commands are supported:
- *
- * command function Return value
- *
- * g return the value of the CPU registers hex data or ENN
- * G set the value of the CPU registers OK or ENN
- *
- * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
- * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
- * XAA..AA,LLLL: Write LLLL binary bytes at address OK or ENN
- * AA..AA
- *
- * c Resume at current address SNN ( signal NN)
- * cAA..AA Continue at address AA..AA SNN
- *
- * s Step one instruction SNN
- * sAA..AA Step one instruction from AA..AA SNN
- *
- * k kill
- *
- * ? What was the last sigval ? SNN (signal NN)
- *
- * All commands and responses are sent with a packet which includes a
- * checksum. A packet consists of
- *
- * $<packet info>#<checksum>.
- *
- * where
- * <packet info> :: <characters representing the command or response>
- * <checksum> :: <two hex digits computed as modulo 256 sum of <packetinfo>>
- *
- * When a packet is received, it is first acknowledged with either '+' or '-'.
- * '+' indicates a successful transfer. '-' indicates a failed transfer.
- *
- * Example:
- *
- * Host: Reply:
- * $m0,10#2a +$00010203040506070809101112131415#42
- *
- ****************************************************************************/
-
-
-/************************************************************************
- *
- * 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 */
-
-/*****************************************************************************
- * BUFMAX defines the maximum number of characters in inbound/outbound buffers
- * at least NUMREGBYTES*2 are needed for register packets
- */
-#define BUFMAX 400
-
-static char initialized; /* boolean flag. != 0 means we've been initialized */
-
-int remote_debug;
-/* debug > 0 prints ill-formed commands in valid packets & checksum errors */
-
-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 };
-
-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]; /* previous exception vectors */
-
-/* Indicate to caller of mem2hex or hex2mem that there has been an error. */
-static volatile int mem_err = 0;
-
-/* Store the vector number here (since GDB only gets the signal
- number through the usual means, and that's not very specific). */
-int gdb_m32r_vector = -1;
-
-#if 0
-#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);
-
-/* 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 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 *);
-
-/*
- * This function does all command procesing for interfacing to gdb.
- */
-
-void
-handle_exception(int exceptionVector)
-{
- 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 */
-
- 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);
- }
-
- /* reply to host that an exception has occurred */
- sigval = computeSignal( exceptionVector );
-
- ptr = remcomOutBuffer;
-
- *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++ = ';';
-
- *ptr++ = hexchars[R13 >> 4];
- *ptr++ = hexchars[R13 & 0xf];
- *ptr++ = ':';
- 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++ = ';';
- *ptr++ = 0;
-
- 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;
- }
- }
-
- 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 */
- {
- 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;
-
- 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 (buf, len, crc)
- unsigned char *buf;
- int len;
- unsigned long crc;
-{
- if (! crc32_table[1])
- {
- /* Initialize the CRC table and the decoding table. */
- 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(ch)
- 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);
-}
-
-/* scan for the sequence $<data>#<checksum> */
-
-unsigned char *
-getpacket ()
-{
- unsigned char *buffer = &remcomInBuffer[0];
- unsigned char checksum;
- unsigned char xmitcsum;
- int count;
- char ch;
-
- while (1)
- {
- /* wait around for the start character, ignore all other characters */
- while ((ch = getDebugChar ()) != '$')
- ;
-
-retry:
- checksum = 0;
- xmitcsum = -1;
- count = 0;
-
- /* now, read until a # or end of buffer is found */
- while (count < BUFMAX)
- {
- 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 ('-'); /* failed checksum */
- }
- else
- {
- putDebugChar ('+'); /* successful transfer */
-
- /* if a sequence char is present, reply the sequence ID */
- if (buffer[2] == ':')
- {
- putDebugChar (buffer[0]);
- putDebugChar (buffer[1]);
-
- return &buffer[3];
- }
-
- return &buffer[0];
- }
- }
- }
-}
-
-/* send the packet in buffer. */
-
-static void
-putpacket(buffer)
- unsigned char *buffer;
-{
- unsigned char checksum;
- int count;
- char ch;
-
- /* $<packet info>#<checksum>. */
- do {
- putDebugChar('$');
- checksum = 0;
- count = 0;
-
- while (ch=buffer[count]) {
- putDebugChar(ch);
- checksum += ch;
- count += 1;
- }
- putDebugChar('#');
- putDebugChar(hexchars[checksum >> 4]);
- putDebugChar(hexchars[checksum % 16]);
- } while (getDebugChar() != '+');
-}
-
-/* Address of a routine to RTE to if we get a memory fault. */
-
-static void (*volatile mem_fault_routine)() = 0;
-
-static void
-set_mem_err ()
-{
- mem_err = 1;
-}
-
-/* Check the address for safe access ranges. As currently defined,
- this routine will reject the "expansion bus" address range(s).
- To make those ranges useable, someone must implement code to detect
- whether there's anything connected to the expansion bus. */
-
-static int
-mem_safe (addr)
- 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 */
-}
-
-/* These are separate functions so that they are so short and sweet
- that the compiler won't save any registers (if there is a fault
- to mem_fault, they won't get restored, so there better not be any
- saved). */
-static int
-get_char (addr)
- unsigned char *addr;
-{
-#if 1
- if (mem_fault_routine && !mem_safe(addr))
- {
- mem_fault_routine ();
- return 0;
- }
-#endif
- return *addr;
-}
-
-static void
-set_char (addr, val)
- unsigned char *addr;
- unsigned char val;
-{
-#if 1
- if (mem_fault_routine && !mem_safe (addr))
- {
- mem_fault_routine ();
- return;
- }
-#endif
- *addr = val;
-}
-
-/* Convert the memory pointed to by mem into hex, placing result in buf.
- Return a pointer to the last char put in buf (null).
- If MAY_FAULT is non-zero, then we should set mem_err in response to
- a fault; if zero treat a fault like any other fault in the stub. */
-
-static unsigned char *
-mem2hex(mem, buf, count, may_fault)
- 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);
-}
-
-/* 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;
-{
- 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);
-}
-
-/* Convert the binary stream in BUF to memory.
-
- Gdb will escape $, #, and the escape char (0x7d).
- 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;
-{
- int i;
- unsigned char ch;
-
- if (may_fault)
- mem_fault_routine = set_mem_err;
- for (i = 0; i < count; i++)
- {
- /* 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;
- }
- }
-
- set_char (mem++, *buf++);
-
- if (may_fault && mem_err)
- return mem;
- }
-
- if (may_fault)
- mem_fault_routine = 0;
- return mem;
-}
-
-/* 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;
-{
- 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" */
- }
- 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;
-{
- 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);
-}
-
-/*
- Table of branch instructions:
-
- 10B6 RTE return from trap or exception
- 1FCr JMP jump
- 1ECr JL jump and link
- 7Fxx BRA branch
- FFxxxxxx BRA branch (long)
- B09rxxxx BNEZ branch not-equal-zero
- Br1rxxxx BNE branch not-equal
- 7Dxx BNC branch not-condition
- FDxxxxxx BNC branch not-condition (long)
- B0Arxxxx BLTZ branch less-than-zero
- B0Crxxxx BLEZ branch less-equal-zero
- 7Exx BL branch and link
- FExxxxxx BL branch and link (long)
- B0Drxxxx BGTZ branch greater-than-zero
- B0Brxxxx BGEZ branch greater-equal-zero
- B08rxxxx BEQZ branch equal-zero
- Br0rxxxx BEQ branch equal
- 7Cxx BC branch condition
- FCxxxxxx BC branch condition (long)
- */
-
-static int
-isShortBranch(instr)
- unsigned char *instr;
-{
- unsigned char instr0 = instr[0] & 0x7F; /* mask off high bit */
-
- if (instr0 == 0x10 && instr[1] == 0xB6) /* RTE */
- return 1; /* return from trap or exception */
-
- if (instr0 == 0x1E || instr0 == 0x1F) /* JL or JMP */
- if ((instr[1] & 0xF0) == 0xC0)
- return 2; /* jump thru a register */
-
- if (instr0 == 0x7C || instr0 == 0x7D || /* BC, BNC, BL, BRA */
- instr0 == 0x7E || instr0 == 0x7F)
- return 3; /* eight bit PC offset */
-
- return 0;
-}
-
-static int
-isLongBranch(instr)
- 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[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 ||
- (instr[1] & 0xF0) == 0xA0 || (instr[1] & 0xF0) == 0xB0 ||
- (instr[1] & 0xF0) == 0xC0 || (instr[1] & 0xF0) == 0xD0)
- return 6;
- }
- return 0;
-}
-
-/* if address is NOT on a 4-byte boundary, or high-bit of instr is zero,
- then it's a 2-byte instruction, else it's a 4-byte instruction. */
-
-#define INSTRUCTION_SIZE(addr) \
- ((((int) addr & 2) || (((unsigned char *) addr)[0] & 0x80) == 0) ? 2 : 4)
-
-static int
-isBranch(instr)
- unsigned char *instr;
-{
- if (INSTRUCTION_SIZE(instr) == 2)
- return isShortBranch(instr);
- else
- return isLongBranch(instr);
-}
-
-static int
-willBranch(instr, branchCode)
- unsigned char *instr;
-{
- switch (branchCode)
- {
- 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)
- {
- case 0xC: /* Branch if Condition Register */
- return (registers[CBR] != 0);
- case 0xD: /* Branch if NOT Condition Register */
- return (registers[CBR] == 0);
- case 0xE: /* Branch and Link */
- case 0xF: /* Branch (unconditional) */
- return 1;
- default: /* oops? */
- return 0;
- }
- 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]);
- case 0x10: /* Branch if r1 NOT 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 0x80: /* Branch if reg equal to zero */
- return (registers[instr[1] & 0x0F] == 0);
- case 0x90: /* Branch if reg NOT equal to zero */
- return (registers[instr[1] & 0x0F] != 0);
- case 0xA0: /* Branch if reg less than zero */
- return (registers[instr[1] & 0x0F] < 0);
- case 0xB0: /* Branch if reg greater or equal to zero */
- return (registers[instr[1] & 0x0F] >= 0);
- case 0xC0: /* Branch if reg less than or equal to zero */
- return (registers[instr[1] & 0x0F] <= 0);
- case 0xD0: /* Branch if reg greater than zero */
- return (registers[instr[1] & 0x0F] > 0);
- default: /* oops? */
- return 0;
- }
- default: /* oops? */
- return 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));
- }
-
- /* An explanatory note: in the last three return expressions, I have
- cast the most-significant byte of the return offset to char.
- What this accomplishes is sign extension. If the other
- less-significant bytes were signed as well, they would get sign
- extended too and, if negative, their leading bits would clobber
- the bits of the more-significant bytes ahead of them. There are
- other ways I could have done this, but sign extension from
- odd-sized integers is always a pain. */
-}
-
-static void
-branchSideEffects(instr, branchCode)
- unsigned char *instr;
- int branchCode;
-{
- switch (branchCode)
- {
- case 1: /* RTE */
- return; /* I <THINK> this is already handled... */
- case 2: /* JL (or JMP) */
- case 3: /* BL (or BC, BNC, BRA) */
- case 4:
- if ((instr[0] & 0x0F) == 0x0E) /* branch/jump and link */
- registers[R14] = (registers[PC] & ~3) + 4;
- return;
- default: /* any other branch has no side effects */
- return;
- }
-}
-
-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 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 */
- unsigned short continue_p; /* true if NOT returning to gdb after step */
-} stepping;
-
-/* Function: prepare_to_step
- Called from handle_exception to prepare the user program to single-step.
- Places a trap instruction after the target instruction, with special
- extra handling for branch instructions and for instructions in the
- second half-word of a word.
-
- Returns: True if we should actually execute the instruction;
- False if we are going to emulate executing the instruction,
- 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 */
-
-static unsigned short trap1 = TRAP1;
-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) */
-{
- unsigned long pc = registers[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 = 0;
-
- 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);
- else
- registers[PC] = pc + INSTRUCTION_SIZE(pc);
- return 0; /* branch "executed" -- just notify GDB */
- }
- 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;
- /* insert trap after pc */
- stepping.trap1_addr = pc + 2;
- stepping.trap1_save = *(unsigned short *) stepping.trap1_addr;
- *(unsigned short *) stepping.trap1_addr = trap1;
- }
- else /* "first-slot" instruction */
- {
- /* insert trap after pc */
- stepping.trap1_addr = pc + INSTRUCTION_SIZE(pc);
- stepping.trap1_save = *(unsigned short *) stepping.trap1_addr;
- *(unsigned short *) stepping.trap1_addr = trap1;
- }
- /* "continue_p" means that we are actually doing a continue, and not
- being requested to single-step by GDB. Sometimes we have to do
- 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 */
- return 1;
-}
-
-/* Function: finish_from_step
- Called from handle_exception to finish up when the user program
- returns from a single-step. Replaces the instructions that had
- been overwritten by traps or no-ops,
-
- Returns: True if we should notify GDB that the target stopped.
- False if we only single-stepped because we had to before we
- could continue (ie. we were trying to continue at a
- half-word boundary). In that case don't notify GDB:
- just "continue continuing". */
-
-static int
-finish_from_step()
-{
- if (stepping.stepping) /* anything to do? */
- {
- int continue_p = stepping.continue_p;
- unsigned char *p;
-
- if (stepping.noop_addr) /* replace instr "under" our no-op */
- *(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 */
- *(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 = 0;
-
- return !(continue_p);
- }
- 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;
-} *psw;
-
-/* Upon entry the value for LR to save has been pushed.
- We unpush that so that the value for the stack pointer saved is correct.
- 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
- jmp lr");
-
-/* C routine to clean up what stash_registers did.
- It is called after calling stash_registers.
- This is separate from stash_registers as we want to do this in C
- but doing stash_registers in C isn't straightforward. */
-
-static void
-cleanup_stash ()
-{
- 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 */
-
-#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
-
- /* FIXME: Copied from previous version. This can probably be deleted
- since methinks stash_registers has already done this. */
- registers[PC] = registers[BPC]; /* pre-trap PC */
-
- /* FIXME: Copied from previous version. Necessary? */
- if (psw->sm) /* copy R15 into (psw->sm ? SPU : SPI) */
- 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
- 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
- rte");
-
-/* General trap handler, called after the registers have been stashed.
- NUM is the trap/exception number. */
-
-static void
-process_exception (num)
- 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");
-
-
-/* this function is used to set up exception handlers for tracing and
- breakpoints */
-void
-set_debug_traps()
-{
- /* 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 */
- 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);
- /* exceptionHandler (17, _catchException17); */
-
- initialized = 1;
-}
-
-/* This function will generate a breakpoint exception. It is used at the
- beginning of a program to sync up with a debugger and can be used
- otherwise as a quick means to stop program execution and "break" into
- the debugger. */
-
-#define BREAKPOINT() asm volatile (" trap #2");
-
-void
-breakpoint()
-{
- if (initialized)
- BREAKPOINT();
-}
-
-/* STDOUT section:
- Stuff pertaining to simulating stdout by sending chars to gdb to be echoed.
- Functions: gdb_putchar(char ch)
- gdb_puts(char *str)
- 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;
-{
- char buf[4];
-
- buf[0] = 'O';
- buf[1] = hexchars[ch >> 4];
- buf[2] = hexchars[ch & 0x0F];
- buf[3] = 0;
- 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;
-{
- 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;
-}
-
-/* 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;
-{
- 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;
-{
- char buf[400], *cpy;
- int len;
-
- if (remote_debug)
- {
- if (format && *format)
- len = strlen(format);
- else
- return; /* empty input */
-
- if (parm && *parm)
- len += strlen(parm);
-
- for (cpy = buf; *format; )
- {
- if (format[0] == '%' && format[1] == 's') /* include second string */
- {
- format += 2; /* advance two chars instead of just one */
- 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
+// OBSOLETE /****************************************************************************
+// OBSOLETE
+// OBSOLETE THIS SOFTWARE IS NOT COPYRIGHTED
+// OBSOLETE
+// OBSOLETE HP offers the following for use in the public domain. HP makes no
+// OBSOLETE warranty with regard to the software or it's performance and the
+// OBSOLETE user accepts the software "AS IS" with all faults.
+// OBSOLETE
+// OBSOLETE HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
+// OBSOLETE TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OBSOLETE OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// OBSOLETE
+// OBSOLETE ****************************************************************************/
+// OBSOLETE
+// OBSOLETE /****************************************************************************
+// OBSOLETE * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
+// OBSOLETE *
+// OBSOLETE * Module name: remcom.c $
+// OBSOLETE * Revision: 1.34 $
+// OBSOLETE * Date: 91/03/09 12:29:49 $
+// OBSOLETE * Contributor: Lake Stevens Instrument Division$
+// OBSOLETE *
+// OBSOLETE * Description: low level support for gdb debugger. $
+// OBSOLETE *
+// OBSOLETE * Considerations: only works on target hardware $
+// OBSOLETE *
+// OBSOLETE * Written by: Glenn Engel $
+// OBSOLETE * ModuleState: Experimental $
+// OBSOLETE *
+// OBSOLETE * NOTES: See Below $
+// OBSOLETE *
+// OBSOLETE * Modified for M32R by Michael Snyder, Cygnus Support.
+// OBSOLETE *
+// OBSOLETE * To enable debugger support, two things need to happen. One, a
+// OBSOLETE * call to set_debug_traps() is necessary in order to allow any breakpoints
+// OBSOLETE * or error conditions to be properly intercepted and reported to gdb.
+// OBSOLETE * Two, a breakpoint needs to be generated to begin communication. This
+// OBSOLETE * is most easily accomplished by a call to breakpoint(). Breakpoint()
+// OBSOLETE * simulates a breakpoint by executing a trap #1.
+// OBSOLETE *
+// OBSOLETE * The external function exceptionHandler() is
+// OBSOLETE * used to attach a specific handler to a specific M32R vector number.
+// OBSOLETE * It should use the same privilege level it runs at. It should
+// OBSOLETE * install it as an interrupt gate so that interrupts are masked
+// OBSOLETE * while the handler runs.
+// OBSOLETE *
+// OBSOLETE * Because gdb will sometimes write to the stack area to execute function
+// OBSOLETE * calls, this program cannot rely on using the supervisor stack so it
+// OBSOLETE * uses it's own stack area reserved in the int array remcomStack.
+// OBSOLETE *
+// OBSOLETE *************
+// OBSOLETE *
+// OBSOLETE * The following gdb commands are supported:
+// OBSOLETE *
+// OBSOLETE * command function Return value
+// OBSOLETE *
+// OBSOLETE * g return the value of the CPU registers hex data or ENN
+// OBSOLETE * G set the value of the CPU registers OK or ENN
+// OBSOLETE *
+// OBSOLETE * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
+// OBSOLETE * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
+// OBSOLETE * XAA..AA,LLLL: Write LLLL binary bytes at address OK or ENN
+// OBSOLETE * AA..AA
+// OBSOLETE *
+// OBSOLETE * c Resume at current address SNN ( signal NN)
+// OBSOLETE * cAA..AA Continue at address AA..AA SNN
+// OBSOLETE *
+// OBSOLETE * s Step one instruction SNN
+// OBSOLETE * sAA..AA Step one instruction from AA..AA SNN
+// OBSOLETE *
+// OBSOLETE * k kill
+// OBSOLETE *
+// OBSOLETE * ? What was the last sigval ? SNN (signal NN)
+// OBSOLETE *
+// OBSOLETE * All commands and responses are sent with a packet which includes a
+// OBSOLETE * checksum. A packet consists of
+// OBSOLETE *
+// OBSOLETE * $<packet info>#<checksum>.
+// OBSOLETE *
+// OBSOLETE * where
+// OBSOLETE * <packet info> :: <characters representing the command or response>
+// OBSOLETE * <checksum> :: <two hex digits computed as modulo 256 sum of <packetinfo>>
+// OBSOLETE *
+// OBSOLETE * When a packet is received, it is first acknowledged with either '+' or '-'.
+// OBSOLETE * '+' indicates a successful transfer. '-' indicates a failed transfer.
+// OBSOLETE *
+// OBSOLETE * Example:
+// OBSOLETE *
+// OBSOLETE * Host: Reply:
+// OBSOLETE * $m0,10#2a +$00010203040506070809101112131415#42
+// OBSOLETE *
+// OBSOLETE ****************************************************************************/
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE /************************************************************************
+// OBSOLETE *
+// OBSOLETE * external low-level support routines
+// OBSOLETE */
+// OBSOLETE extern void putDebugChar(); /* write a single character */
+// OBSOLETE extern int getDebugChar(); /* read and return a single char */
+// OBSOLETE extern void exceptionHandler(); /* assign an exception handler */
+// OBSOLETE
+// OBSOLETE /*****************************************************************************
+// OBSOLETE * BUFMAX defines the maximum number of characters in inbound/outbound buffers
+// OBSOLETE * at least NUMREGBYTES*2 are needed for register packets
+// OBSOLETE */
+// OBSOLETE #define BUFMAX 400
+// OBSOLETE
+// OBSOLETE static char initialized; /* boolean flag. != 0 means we've been initialized */
+// OBSOLETE
+// OBSOLETE int remote_debug;
+// OBSOLETE /* debug > 0 prints ill-formed commands in valid packets & checksum errors */
+// OBSOLETE
+// OBSOLETE static const unsigned char hexchars[]="0123456789abcdef";
+// OBSOLETE
+// OBSOLETE #define NUMREGS 24
+// OBSOLETE
+// OBSOLETE /* Number of bytes of registers. */
+// OBSOLETE #define NUMREGBYTES (NUMREGS * 4)
+// OBSOLETE enum regnames { R0, R1, R2, R3, R4, R5, R6, R7,
+// OBSOLETE R8, R9, R10, R11, R12, R13, R14, R15,
+// OBSOLETE PSW, CBR, SPI, SPU, BPC, PC, ACCL, ACCH };
+// OBSOLETE
+// OBSOLETE enum SYS_calls {
+// OBSOLETE SYS_null,
+// OBSOLETE SYS_exit,
+// OBSOLETE SYS_open,
+// OBSOLETE SYS_close,
+// OBSOLETE SYS_read,
+// OBSOLETE SYS_write,
+// OBSOLETE SYS_lseek,
+// OBSOLETE SYS_unlink,
+// OBSOLETE SYS_getpid,
+// OBSOLETE SYS_kill,
+// OBSOLETE SYS_fstat,
+// OBSOLETE SYS_sbrk,
+// OBSOLETE SYS_fork,
+// OBSOLETE SYS_execve,
+// OBSOLETE SYS_wait4,
+// OBSOLETE SYS_link,
+// OBSOLETE SYS_chdir,
+// OBSOLETE SYS_stat,
+// OBSOLETE SYS_utime,
+// OBSOLETE SYS_chown,
+// OBSOLETE SYS_chmod,
+// OBSOLETE SYS_time,
+// OBSOLETE SYS_pipe };
+// OBSOLETE
+// OBSOLETE static int registers[NUMREGS];
+// OBSOLETE
+// OBSOLETE #define STACKSIZE 8096
+// OBSOLETE static unsigned char remcomInBuffer[BUFMAX];
+// OBSOLETE static unsigned char remcomOutBuffer[BUFMAX];
+// OBSOLETE static int remcomStack[STACKSIZE/sizeof(int)];
+// OBSOLETE static int* stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];
+// OBSOLETE
+// OBSOLETE static unsigned int save_vectors[18]; /* previous exception vectors */
+// OBSOLETE
+// OBSOLETE /* Indicate to caller of mem2hex or hex2mem that there has been an error. */
+// OBSOLETE static volatile int mem_err = 0;
+// OBSOLETE
+// OBSOLETE /* Store the vector number here (since GDB only gets the signal
+// OBSOLETE number through the usual means, and that's not very specific). */
+// OBSOLETE int gdb_m32r_vector = -1;
+// OBSOLETE
+// OBSOLETE #if 0
+// OBSOLETE #include "syscall.h" /* for SYS_exit, SYS_write etc. */
+// OBSOLETE #endif
+// OBSOLETE
+// OBSOLETE /* Global entry points:
+// OBSOLETE */
+// OBSOLETE
+// OBSOLETE extern void handle_exception(int);
+// OBSOLETE extern void set_debug_traps(void);
+// OBSOLETE extern void breakpoint(void);
+// OBSOLETE
+// OBSOLETE /* Local functions:
+// OBSOLETE */
+// OBSOLETE
+// OBSOLETE static int computeSignal(int);
+// OBSOLETE static void putpacket(unsigned char *);
+// OBSOLETE static unsigned char *getpacket(void);
+// OBSOLETE
+// OBSOLETE static unsigned char *mem2hex(unsigned char *, unsigned char *, int, int);
+// OBSOLETE static unsigned char *hex2mem(unsigned char *, unsigned char *, int, int);
+// OBSOLETE static int hexToInt(unsigned char **, int *);
+// OBSOLETE static unsigned char *bin2mem(unsigned char *, unsigned char *, int, int);
+// OBSOLETE static void stash_registers(void);
+// OBSOLETE static void restore_registers(void);
+// OBSOLETE static int prepare_to_step(int);
+// OBSOLETE static int finish_from_step(void);
+// OBSOLETE static unsigned long crc32 (unsigned char *, int, unsigned long);
+// OBSOLETE
+// OBSOLETE static void gdb_error(char *, char *);
+// OBSOLETE static int gdb_putchar(int), gdb_puts(char *), gdb_write(char *, int);
+// OBSOLETE
+// OBSOLETE static unsigned char *strcpy (unsigned char *, const unsigned char *);
+// OBSOLETE static int strlen (const unsigned char *);
+// OBSOLETE
+// OBSOLETE /*
+// OBSOLETE * This function does all command procesing for interfacing to gdb.
+// OBSOLETE */
+// OBSOLETE
+// OBSOLETE void
+// OBSOLETE handle_exception(int exceptionVector)
+// OBSOLETE {
+// OBSOLETE int sigval, stepping;
+// OBSOLETE int addr, length, i;
+// OBSOLETE unsigned char * ptr;
+// OBSOLETE unsigned char buf[16];
+// OBSOLETE int binary;
+// OBSOLETE
+// OBSOLETE /* Do not call finish_from_step() if this is not a trap #1
+// OBSOLETE * (breakpoint trap). Without this check, the finish_from_step()
+// OBSOLETE * might interpret a system call trap as a single step trap. This
+// OBSOLETE * can happen if: the stub receives 's' and exits, but an interrupt
+// OBSOLETE * was pending; the interrupt is now handled and causes the stub to
+// OBSOLETE * be reentered because some function makes a system call.
+// OBSOLETE */
+// OBSOLETE if (exceptionVector == 1) /* Trap exception? */
+// OBSOLETE if (!finish_from_step()) /* Go see if stepping state needs update. */
+// OBSOLETE return; /* "false step": let the target continue */
+// OBSOLETE
+// OBSOLETE gdb_m32r_vector = exceptionVector;
+// OBSOLETE
+// OBSOLETE if (remote_debug)
+// OBSOLETE {
+// OBSOLETE mem2hex((unsigned char *) &exceptionVector, buf, 4, 0);
+// OBSOLETE gdb_error("Handle exception %s, ", buf);
+// OBSOLETE mem2hex((unsigned char *) ®isters[PC], buf, 4, 0);
+// OBSOLETE gdb_error("PC == 0x%s\n", buf);
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* reply to host that an exception has occurred */
+// OBSOLETE sigval = computeSignal( exceptionVector );
+// OBSOLETE
+// OBSOLETE ptr = remcomOutBuffer;
+// OBSOLETE
+// OBSOLETE *ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */
+// OBSOLETE *ptr++ = hexchars[sigval >> 4];
+// OBSOLETE *ptr++ = hexchars[sigval & 0xf];
+// OBSOLETE
+// OBSOLETE *ptr++ = hexchars[PC >> 4];
+// OBSOLETE *ptr++ = hexchars[PC & 0xf];
+// OBSOLETE *ptr++ = ':';
+// OBSOLETE ptr = mem2hex((unsigned char *)®isters[PC], ptr, 4, 0); /* PC */
+// OBSOLETE *ptr++ = ';';
+// OBSOLETE
+// OBSOLETE *ptr++ = hexchars[R13 >> 4];
+// OBSOLETE *ptr++ = hexchars[R13 & 0xf];
+// OBSOLETE *ptr++ = ':';
+// OBSOLETE ptr = mem2hex((unsigned char *)®isters[R13], ptr, 4, 0); /* FP */
+// OBSOLETE *ptr++ = ';';
+// OBSOLETE
+// OBSOLETE *ptr++ = hexchars[R15 >> 4];
+// OBSOLETE *ptr++ = hexchars[R15 & 0xf];
+// OBSOLETE *ptr++ = ':';
+// OBSOLETE ptr = mem2hex((unsigned char *)®isters[R15], ptr, 4, 0); /* SP */
+// OBSOLETE *ptr++ = ';';
+// OBSOLETE *ptr++ = 0;
+// OBSOLETE
+// OBSOLETE if (exceptionVector == 0) /* simulated SYS call stuff */
+// OBSOLETE {
+// OBSOLETE mem2hex((unsigned char *) ®isters[PC], buf, 4, 0);
+// OBSOLETE switch (registers[R0]) {
+// OBSOLETE case SYS_exit:
+// OBSOLETE gdb_error("Target program has exited at %s\n", buf);
+// OBSOLETE ptr = remcomOutBuffer;
+// OBSOLETE *ptr++ = 'W';
+// OBSOLETE sigval = registers[R1] & 0xff;
+// OBSOLETE *ptr++ = hexchars[sigval >> 4];
+// OBSOLETE *ptr++ = hexchars[sigval & 0xf];
+// OBSOLETE *ptr++ = 0;
+// OBSOLETE break;
+// OBSOLETE case SYS_open:
+// OBSOLETE gdb_error("Target attempts SYS_open call at %s\n", buf);
+// OBSOLETE break;
+// OBSOLETE case SYS_close:
+// OBSOLETE gdb_error("Target attempts SYS_close call at %s\n", buf);
+// OBSOLETE break;
+// OBSOLETE case SYS_read:
+// OBSOLETE gdb_error("Target attempts SYS_read call at %s\n", buf);
+// OBSOLETE break;
+// OBSOLETE case SYS_write:
+// OBSOLETE if (registers[R1] == 1 || /* write to stdout */
+// OBSOLETE registers[R1] == 2) /* write to stderr */
+// OBSOLETE { /* (we can do that) */
+// OBSOLETE registers[R0] = gdb_write((void *) registers[R2], registers[R3]);
+// OBSOLETE return;
+// OBSOLETE }
+// OBSOLETE else
+// OBSOLETE gdb_error("Target attempts SYS_write call at %s\n", buf);
+// OBSOLETE break;
+// OBSOLETE case SYS_lseek:
+// OBSOLETE gdb_error("Target attempts SYS_lseek call at %s\n", buf);
+// OBSOLETE break;
+// OBSOLETE case SYS_unlink:
+// OBSOLETE gdb_error("Target attempts SYS_unlink call at %s\n", buf);
+// OBSOLETE break;
+// OBSOLETE case SYS_getpid:
+// OBSOLETE gdb_error("Target attempts SYS_getpid call at %s\n", buf);
+// OBSOLETE break;
+// OBSOLETE case SYS_kill:
+// OBSOLETE gdb_error("Target attempts SYS_kill call at %s\n", buf);
+// OBSOLETE break;
+// OBSOLETE case SYS_fstat:
+// OBSOLETE gdb_error("Target attempts SYS_fstat call at %s\n", buf);
+// OBSOLETE break;
+// OBSOLETE default:
+// OBSOLETE gdb_error("Target attempts unknown SYS call at %s\n", buf);
+// OBSOLETE break;
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE putpacket(remcomOutBuffer);
+// OBSOLETE
+// OBSOLETE stepping = 0;
+// OBSOLETE
+// OBSOLETE while (1==1) {
+// OBSOLETE remcomOutBuffer[0] = 0;
+// OBSOLETE ptr = getpacket();
+// OBSOLETE binary = 0;
+// OBSOLETE switch (*ptr++) {
+// OBSOLETE default: /* Unknown code. Return an empty reply message. */
+// OBSOLETE break;
+// OBSOLETE case 'R':
+// OBSOLETE if (hexToInt (&ptr, &addr))
+// OBSOLETE registers[PC] = addr;
+// OBSOLETE strcpy(remcomOutBuffer, "OK");
+// OBSOLETE break;
+// OBSOLETE case '!':
+// OBSOLETE strcpy(remcomOutBuffer, "OK");
+// OBSOLETE break;
+// OBSOLETE case 'X': /* XAA..AA,LLLL:<binary data>#cs */
+// OBSOLETE binary = 1;
+// OBSOLETE case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
+// OBSOLETE /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
+// OBSOLETE {
+// OBSOLETE if (hexToInt(&ptr,&addr))
+// OBSOLETE if (*(ptr++) == ',')
+// OBSOLETE if (hexToInt(&ptr,&length))
+// OBSOLETE if (*(ptr++) == ':')
+// OBSOLETE {
+// OBSOLETE mem_err = 0;
+// OBSOLETE if (binary)
+// OBSOLETE bin2mem (ptr, (unsigned char *) addr, length, 1);
+// OBSOLETE else
+// OBSOLETE hex2mem(ptr, (unsigned char*) addr, length, 1);
+// OBSOLETE if (mem_err) {
+// OBSOLETE strcpy (remcomOutBuffer, "E03");
+// OBSOLETE gdb_error ("memory fault", "");
+// OBSOLETE } else {
+// OBSOLETE strcpy(remcomOutBuffer,"OK");
+// OBSOLETE }
+// OBSOLETE ptr = 0;
+// OBSOLETE }
+// OBSOLETE if (ptr)
+// OBSOLETE {
+// OBSOLETE strcpy(remcomOutBuffer,"E02");
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE break;
+// OBSOLETE case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
+// OBSOLETE /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
+// OBSOLETE if (hexToInt(&ptr,&addr))
+// OBSOLETE if (*(ptr++) == ',')
+// OBSOLETE if (hexToInt(&ptr,&length))
+// OBSOLETE {
+// OBSOLETE ptr = 0;
+// OBSOLETE mem_err = 0;
+// OBSOLETE mem2hex((unsigned char*) addr, remcomOutBuffer, length, 1);
+// OBSOLETE if (mem_err) {
+// OBSOLETE strcpy (remcomOutBuffer, "E03");
+// OBSOLETE gdb_error ("memory fault", "");
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE if (ptr)
+// OBSOLETE {
+// OBSOLETE strcpy(remcomOutBuffer,"E01");
+// OBSOLETE }
+// OBSOLETE break;
+// OBSOLETE case '?':
+// OBSOLETE remcomOutBuffer[0] = 'S';
+// OBSOLETE remcomOutBuffer[1] = hexchars[sigval >> 4];
+// OBSOLETE remcomOutBuffer[2] = hexchars[sigval % 16];
+// OBSOLETE remcomOutBuffer[3] = 0;
+// OBSOLETE break;
+// OBSOLETE case 'd':
+// OBSOLETE remote_debug = !(remote_debug); /* toggle debug flag */
+// OBSOLETE break;
+// OBSOLETE case 'g': /* return the value of the CPU registers */
+// OBSOLETE mem2hex((unsigned char*) registers, remcomOutBuffer, NUMREGBYTES, 0);
+// OBSOLETE break;
+// OBSOLETE case 'P': /* set the value of a single CPU register - return OK */
+// OBSOLETE {
+// OBSOLETE int regno;
+// OBSOLETE
+// OBSOLETE if (hexToInt (&ptr, ®no) && *ptr++ == '=')
+// OBSOLETE if (regno >= 0 && regno < NUMREGS)
+// OBSOLETE {
+// OBSOLETE int stackmode;
+// OBSOLETE
+// OBSOLETE hex2mem (ptr, (unsigned char *) ®isters[regno], 4, 0);
+// OBSOLETE /*
+// OBSOLETE * Since we just changed a single CPU register, let's
+// OBSOLETE * make sure to keep the several stack pointers consistant.
+// OBSOLETE */
+// OBSOLETE stackmode = registers[PSW] & 0x80;
+// OBSOLETE if (regno == R15) /* stack pointer changed */
+// OBSOLETE { /* need to change SPI or SPU */
+// OBSOLETE if (stackmode == 0)
+// OBSOLETE registers[SPI] = registers[R15];
+// OBSOLETE else
+// OBSOLETE registers[SPU] = registers[R15];
+// OBSOLETE }
+// OBSOLETE else if (regno == SPU) /* "user" stack pointer changed */
+// OBSOLETE {
+// OBSOLETE if (stackmode != 0) /* stack in user mode: copy SP */
+// OBSOLETE registers[R15] = registers[SPU];
+// OBSOLETE }
+// OBSOLETE else if (regno == SPI) /* "interrupt" stack pointer changed */
+// OBSOLETE {
+// OBSOLETE if (stackmode == 0) /* stack in interrupt mode: copy SP */
+// OBSOLETE registers[R15] = registers[SPI];
+// OBSOLETE }
+// OBSOLETE else if (regno == PSW) /* stack mode may have changed! */
+// OBSOLETE { /* force SP to either SPU or SPI */
+// OBSOLETE if (stackmode == 0) /* stack in user mode */
+// OBSOLETE registers[R15] = registers[SPI];
+// OBSOLETE else /* stack in interrupt mode */
+// OBSOLETE registers[R15] = registers[SPU];
+// OBSOLETE }
+// OBSOLETE strcpy (remcomOutBuffer, "OK");
+// OBSOLETE break;
+// OBSOLETE }
+// OBSOLETE strcpy (remcomOutBuffer, "E01");
+// OBSOLETE break;
+// OBSOLETE }
+// OBSOLETE case 'G': /* set the value of the CPU registers - return OK */
+// OBSOLETE hex2mem(ptr, (unsigned char*) registers, NUMREGBYTES, 0);
+// OBSOLETE strcpy(remcomOutBuffer,"OK");
+// OBSOLETE break;
+// OBSOLETE case 's': /* sAA..AA Step one instruction from AA..AA(optional) */
+// OBSOLETE stepping = 1;
+// OBSOLETE case 'c': /* cAA..AA Continue from address AA..AA(optional) */
+// OBSOLETE /* try to read optional parameter, pc unchanged if no parm */
+// OBSOLETE if (hexToInt(&ptr,&addr))
+// OBSOLETE registers[ PC ] = addr;
+// OBSOLETE
+// OBSOLETE if (stepping) /* single-stepping */
+// OBSOLETE {
+// OBSOLETE if (!prepare_to_step(0)) /* set up for single-step */
+// OBSOLETE {
+// OBSOLETE /* prepare_to_step has already emulated the target insn:
+// OBSOLETE Send SIGTRAP to gdb, don't resume the target at all. */
+// OBSOLETE ptr = remcomOutBuffer;
+// OBSOLETE *ptr++ = 'T'; /* Simulate stopping with SIGTRAP */
+// OBSOLETE *ptr++ = '0';
+// OBSOLETE *ptr++ = '5';
+// OBSOLETE
+// OBSOLETE *ptr++ = hexchars[PC >> 4]; /* send PC */
+// OBSOLETE *ptr++ = hexchars[PC & 0xf];
+// OBSOLETE *ptr++ = ':';
+// OBSOLETE ptr = mem2hex((unsigned char *)®isters[PC], ptr, 4, 0);
+// OBSOLETE *ptr++ = ';';
+// OBSOLETE
+// OBSOLETE *ptr++ = hexchars[R13 >> 4]; /* send FP */
+// OBSOLETE *ptr++ = hexchars[R13 & 0xf];
+// OBSOLETE *ptr++ = ':';
+// OBSOLETE ptr = mem2hex((unsigned char *)®isters[R13], ptr, 4, 0);
+// OBSOLETE *ptr++ = ';';
+// OBSOLETE
+// OBSOLETE *ptr++ = hexchars[R15 >> 4]; /* send SP */
+// OBSOLETE *ptr++ = hexchars[R15 & 0xf];
+// OBSOLETE *ptr++ = ':';
+// OBSOLETE ptr = mem2hex((unsigned char *)®isters[R15], ptr, 4, 0);
+// OBSOLETE *ptr++ = ';';
+// OBSOLETE *ptr++ = 0;
+// OBSOLETE
+// OBSOLETE break;
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE else /* continuing, not single-stepping */
+// OBSOLETE {
+// OBSOLETE /* OK, about to do a "continue". First check to see if the
+// OBSOLETE target pc is on an odd boundary (second instruction in the
+// OBSOLETE word). If so, we must do a single-step first, because
+// OBSOLETE ya can't jump or return back to an odd boundary! */
+// OBSOLETE if ((registers[PC] & 2) != 0)
+// OBSOLETE prepare_to_step(1);
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE return;
+// OBSOLETE
+// OBSOLETE case 'D': /* Detach */
+// OBSOLETE #if 0
+// OBSOLETE /* I am interpreting this to mean, release the board from control
+// OBSOLETE by the remote stub. To do this, I am restoring the original
+// OBSOLETE (or at least previous) exception vectors.
+// OBSOLETE */
+// OBSOLETE for (i = 0; i < 18; i++)
+// OBSOLETE exceptionHandler (i, save_vectors[i]);
+// OBSOLETE putpacket ("OK");
+// OBSOLETE return; /* continue the inferior */
+// OBSOLETE #else
+// OBSOLETE strcpy(remcomOutBuffer,"OK");
+// OBSOLETE break;
+// OBSOLETE #endif
+// OBSOLETE case 'q':
+// OBSOLETE if (*ptr++ == 'C' &&
+// OBSOLETE *ptr++ == 'R' &&
+// OBSOLETE *ptr++ == 'C' &&
+// OBSOLETE *ptr++ == ':')
+// OBSOLETE {
+// OBSOLETE unsigned long start, len, our_crc;
+// OBSOLETE
+// OBSOLETE if (hexToInt (&ptr, (int *) &start) &&
+// OBSOLETE *ptr++ == ',' &&
+// OBSOLETE hexToInt (&ptr, (int *) &len))
+// OBSOLETE {
+// OBSOLETE remcomOutBuffer[0] = 'C';
+// OBSOLETE our_crc = crc32 ((unsigned char *) start, len, 0xffffffff);
+// OBSOLETE mem2hex ((char *) &our_crc,
+// OBSOLETE &remcomOutBuffer[1],
+// OBSOLETE sizeof (long),
+// OBSOLETE 0);
+// OBSOLETE } /* else do nothing */
+// OBSOLETE } /* else do nothing */
+// OBSOLETE break;
+// OBSOLETE
+// OBSOLETE case 'k': /* kill the program */
+// OBSOLETE continue;
+// OBSOLETE } /* switch */
+// OBSOLETE
+// OBSOLETE /* reply to the request */
+// OBSOLETE putpacket(remcomOutBuffer);
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* qCRC support */
+// OBSOLETE
+// OBSOLETE /* Table used by the crc32 function to calcuate the checksum. */
+// OBSOLETE static unsigned long crc32_table[256] = {0, 0};
+// OBSOLETE
+// OBSOLETE static unsigned long
+// OBSOLETE crc32 (unsigned char *buf, int len, unsigned long crc)
+// OBSOLETE {
+// OBSOLETE if (! crc32_table[1])
+// OBSOLETE {
+// OBSOLETE /* Initialize the CRC table and the decoding table. */
+// OBSOLETE int i, j;
+// OBSOLETE unsigned long c;
+// OBSOLETE
+// OBSOLETE for (i = 0; i < 256; i++)
+// OBSOLETE {
+// OBSOLETE for (c = i << 24, j = 8; j > 0; --j)
+// OBSOLETE c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
+// OBSOLETE crc32_table[i] = c;
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE while (len--)
+// OBSOLETE {
+// OBSOLETE crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
+// OBSOLETE buf++;
+// OBSOLETE }
+// OBSOLETE return crc;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE hex (unsigned char ch)
+// OBSOLETE {
+// OBSOLETE if ((ch >= 'a') && (ch <= 'f')) return (ch-'a'+10);
+// OBSOLETE if ((ch >= '0') && (ch <= '9')) return (ch-'0');
+// OBSOLETE if ((ch >= 'A') && (ch <= 'F')) return (ch-'A'+10);
+// OBSOLETE return (-1);
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* scan for the sequence $<data>#<checksum> */
+// OBSOLETE
+// OBSOLETE unsigned char *
+// OBSOLETE getpacket (void)
+// OBSOLETE {
+// OBSOLETE unsigned char *buffer = &remcomInBuffer[0];
+// OBSOLETE unsigned char checksum;
+// OBSOLETE unsigned char xmitcsum;
+// OBSOLETE int count;
+// OBSOLETE char ch;
+// OBSOLETE
+// OBSOLETE while (1)
+// OBSOLETE {
+// OBSOLETE /* wait around for the start character, ignore all other characters */
+// OBSOLETE while ((ch = getDebugChar ()) != '$')
+// OBSOLETE ;
+// OBSOLETE
+// OBSOLETE retry:
+// OBSOLETE checksum = 0;
+// OBSOLETE xmitcsum = -1;
+// OBSOLETE count = 0;
+// OBSOLETE
+// OBSOLETE /* now, read until a # or end of buffer is found */
+// OBSOLETE while (count < BUFMAX)
+// OBSOLETE {
+// OBSOLETE ch = getDebugChar ();
+// OBSOLETE if (ch == '$')
+// OBSOLETE goto retry;
+// OBSOLETE if (ch == '#')
+// OBSOLETE break;
+// OBSOLETE checksum = checksum + ch;
+// OBSOLETE buffer[count] = ch;
+// OBSOLETE count = count + 1;
+// OBSOLETE }
+// OBSOLETE buffer[count] = 0;
+// OBSOLETE
+// OBSOLETE if (ch == '#')
+// OBSOLETE {
+// OBSOLETE ch = getDebugChar ();
+// OBSOLETE xmitcsum = hex (ch) << 4;
+// OBSOLETE ch = getDebugChar ();
+// OBSOLETE xmitcsum += hex (ch);
+// OBSOLETE
+// OBSOLETE if (checksum != xmitcsum)
+// OBSOLETE {
+// OBSOLETE if (remote_debug)
+// OBSOLETE {
+// OBSOLETE unsigned char buf[16];
+// OBSOLETE
+// OBSOLETE mem2hex((unsigned char *) &checksum, buf, 4, 0);
+// OBSOLETE gdb_error("Bad checksum: my count = %s, ", buf);
+// OBSOLETE mem2hex((unsigned char *) &xmitcsum, buf, 4, 0);
+// OBSOLETE gdb_error("sent count = %s\n", buf);
+// OBSOLETE gdb_error(" -- Bad buffer: \"%s\"\n", buffer);
+// OBSOLETE }
+// OBSOLETE putDebugChar ('-'); /* failed checksum */
+// OBSOLETE }
+// OBSOLETE else
+// OBSOLETE {
+// OBSOLETE putDebugChar ('+'); /* successful transfer */
+// OBSOLETE
+// OBSOLETE /* if a sequence char is present, reply the sequence ID */
+// OBSOLETE if (buffer[2] == ':')
+// OBSOLETE {
+// OBSOLETE putDebugChar (buffer[0]);
+// OBSOLETE putDebugChar (buffer[1]);
+// OBSOLETE
+// OBSOLETE return &buffer[3];
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE return &buffer[0];
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* send the packet in buffer. */
+// OBSOLETE
+// OBSOLETE static void
+// OBSOLETE putpacket (unsigned char *buffer)
+// OBSOLETE {
+// OBSOLETE unsigned char checksum;
+// OBSOLETE int count;
+// OBSOLETE char ch;
+// OBSOLETE
+// OBSOLETE /* $<packet info>#<checksum>. */
+// OBSOLETE do {
+// OBSOLETE putDebugChar('$');
+// OBSOLETE checksum = 0;
+// OBSOLETE count = 0;
+// OBSOLETE
+// OBSOLETE while (ch=buffer[count]) {
+// OBSOLETE putDebugChar(ch);
+// OBSOLETE checksum += ch;
+// OBSOLETE count += 1;
+// OBSOLETE }
+// OBSOLETE putDebugChar('#');
+// OBSOLETE putDebugChar(hexchars[checksum >> 4]);
+// OBSOLETE putDebugChar(hexchars[checksum % 16]);
+// OBSOLETE } while (getDebugChar() != '+');
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* Address of a routine to RTE to if we get a memory fault. */
+// OBSOLETE
+// OBSOLETE static void (*volatile mem_fault_routine)() = 0;
+// OBSOLETE
+// OBSOLETE static void
+// OBSOLETE set_mem_err (void)
+// OBSOLETE {
+// OBSOLETE mem_err = 1;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* Check the address for safe access ranges. As currently defined,
+// OBSOLETE this routine will reject the "expansion bus" address range(s).
+// OBSOLETE To make those ranges useable, someone must implement code to detect
+// OBSOLETE whether there's anything connected to the expansion bus. */
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE mem_safe (unsigned char *addr)
+// OBSOLETE {
+// OBSOLETE #define BAD_RANGE_ONE_START ((unsigned char *) 0x600000)
+// OBSOLETE #define BAD_RANGE_ONE_END ((unsigned char *) 0xa00000)
+// OBSOLETE #define BAD_RANGE_TWO_START ((unsigned char *) 0xff680000)
+// OBSOLETE #define BAD_RANGE_TWO_END ((unsigned char *) 0xff800000)
+// OBSOLETE
+// OBSOLETE if (addr < BAD_RANGE_ONE_START) return 1; /* safe */
+// OBSOLETE if (addr < BAD_RANGE_ONE_END) return 0; /* unsafe */
+// OBSOLETE if (addr < BAD_RANGE_TWO_START) return 1; /* safe */
+// OBSOLETE if (addr < BAD_RANGE_TWO_END) return 0; /* unsafe */
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* These are separate functions so that they are so short and sweet
+// OBSOLETE that the compiler won't save any registers (if there is a fault
+// OBSOLETE to mem_fault, they won't get restored, so there better not be any
+// OBSOLETE saved). */
+// OBSOLETE static int
+// OBSOLETE get_char (unsigned char *addr)
+// OBSOLETE {
+// OBSOLETE #if 1
+// OBSOLETE if (mem_fault_routine && !mem_safe(addr))
+// OBSOLETE {
+// OBSOLETE mem_fault_routine ();
+// OBSOLETE return 0;
+// OBSOLETE }
+// OBSOLETE #endif
+// OBSOLETE return *addr;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE static void
+// OBSOLETE set_char (unsigned char *addr, unsigned char val)
+// OBSOLETE {
+// OBSOLETE #if 1
+// OBSOLETE if (mem_fault_routine && !mem_safe (addr))
+// OBSOLETE {
+// OBSOLETE mem_fault_routine ();
+// OBSOLETE return;
+// OBSOLETE }
+// OBSOLETE #endif
+// OBSOLETE *addr = val;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* Convert the memory pointed to by mem into hex, placing result in buf.
+// OBSOLETE Return a pointer to the last char put in buf (null).
+// OBSOLETE If MAY_FAULT is non-zero, then we should set mem_err in response to
+// OBSOLETE a fault; if zero treat a fault like any other fault in the stub. */
+// OBSOLETE
+// OBSOLETE static unsigned char *
+// OBSOLETE mem2hex (unsigned char *mem, unsigned char *buf, int count, int may_fault)
+// OBSOLETE {
+// OBSOLETE int i;
+// OBSOLETE unsigned char ch;
+// OBSOLETE
+// OBSOLETE if (may_fault)
+// OBSOLETE mem_fault_routine = set_mem_err;
+// OBSOLETE for (i=0;i<count;i++) {
+// OBSOLETE ch = get_char (mem++);
+// OBSOLETE if (may_fault && mem_err)
+// OBSOLETE return (buf);
+// OBSOLETE *buf++ = hexchars[ch >> 4];
+// OBSOLETE *buf++ = hexchars[ch % 16];
+// OBSOLETE }
+// OBSOLETE *buf = 0;
+// OBSOLETE if (may_fault)
+// OBSOLETE mem_fault_routine = 0;
+// OBSOLETE return(buf);
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* Convert the hex array pointed to by buf into binary to be placed in mem.
+// OBSOLETE Return a pointer to the character AFTER the last byte written. */
+// OBSOLETE
+// OBSOLETE static unsigned char*
+// OBSOLETE hex2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault)
+// OBSOLETE {
+// OBSOLETE int i;
+// OBSOLETE unsigned char ch;
+// OBSOLETE
+// OBSOLETE if (may_fault)
+// OBSOLETE mem_fault_routine = set_mem_err;
+// OBSOLETE for (i=0;i<count;i++) {
+// OBSOLETE ch = hex(*buf++) << 4;
+// OBSOLETE ch = ch + hex(*buf++);
+// OBSOLETE set_char (mem++, ch);
+// OBSOLETE if (may_fault && mem_err)
+// OBSOLETE return (mem);
+// OBSOLETE }
+// OBSOLETE if (may_fault)
+// OBSOLETE mem_fault_routine = 0;
+// OBSOLETE return(mem);
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* Convert the binary stream in BUF to memory.
+// OBSOLETE
+// OBSOLETE Gdb will escape $, #, and the escape char (0x7d).
+// OBSOLETE COUNT is the total number of bytes to write into
+// OBSOLETE memory. */
+// OBSOLETE static unsigned char *
+// OBSOLETE bin2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault)
+// OBSOLETE {
+// OBSOLETE int i;
+// OBSOLETE unsigned char ch;
+// OBSOLETE
+// OBSOLETE if (may_fault)
+// OBSOLETE mem_fault_routine = set_mem_err;
+// OBSOLETE for (i = 0; i < count; i++)
+// OBSOLETE {
+// OBSOLETE /* Check for any escaped characters. Be paranoid and
+// OBSOLETE only unescape chars that should be escaped. */
+// OBSOLETE if (*buf == 0x7d)
+// OBSOLETE {
+// OBSOLETE switch (*(buf+1))
+// OBSOLETE {
+// OBSOLETE case 0x3: /* # */
+// OBSOLETE case 0x4: /* $ */
+// OBSOLETE case 0x5d: /* escape char */
+// OBSOLETE buf++;
+// OBSOLETE *buf |= 0x20;
+// OBSOLETE break;
+// OBSOLETE default:
+// OBSOLETE /* nothing */
+// OBSOLETE break;
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE set_char (mem++, *buf++);
+// OBSOLETE
+// OBSOLETE if (may_fault && mem_err)
+// OBSOLETE return mem;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE if (may_fault)
+// OBSOLETE mem_fault_routine = 0;
+// OBSOLETE return mem;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* this function takes the m32r exception vector and attempts to
+// OBSOLETE translate this number into a unix compatible signal value */
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE computeSignal (int exceptionVector)
+// OBSOLETE {
+// OBSOLETE int sigval;
+// OBSOLETE switch (exceptionVector) {
+// OBSOLETE case 0 : sigval = 23; break; /* I/O trap */
+// OBSOLETE case 1 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 2 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 3 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 4 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 5 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 6 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 7 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 8 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 9 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 10 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 11 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 12 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 13 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 14 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 15 : sigval = 5; break; /* breakpoint */
+// OBSOLETE case 16 : sigval = 10; break; /* BUS ERROR (alignment) */
+// OBSOLETE case 17 : sigval = 2; break; /* INTerrupt */
+// OBSOLETE default : sigval = 7; break; /* "software generated" */
+// OBSOLETE }
+// OBSOLETE return (sigval);
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /**********************************************/
+// OBSOLETE /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
+// OBSOLETE /* RETURN NUMBER OF CHARS PROCESSED */
+// OBSOLETE /**********************************************/
+// OBSOLETE static int
+// OBSOLETE hexToInt (unsigned char **ptr, int *intValue)
+// OBSOLETE {
+// OBSOLETE int numChars = 0;
+// OBSOLETE int hexValue;
+// OBSOLETE
+// OBSOLETE *intValue = 0;
+// OBSOLETE while (**ptr)
+// OBSOLETE {
+// OBSOLETE hexValue = hex(**ptr);
+// OBSOLETE if (hexValue >=0)
+// OBSOLETE {
+// OBSOLETE *intValue = (*intValue <<4) | hexValue;
+// OBSOLETE numChars ++;
+// OBSOLETE }
+// OBSOLETE else
+// OBSOLETE break;
+// OBSOLETE (*ptr)++;
+// OBSOLETE }
+// OBSOLETE return (numChars);
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /*
+// OBSOLETE Table of branch instructions:
+// OBSOLETE
+// OBSOLETE 10B6 RTE return from trap or exception
+// OBSOLETE 1FCr JMP jump
+// OBSOLETE 1ECr JL jump and link
+// OBSOLETE 7Fxx BRA branch
+// OBSOLETE FFxxxxxx BRA branch (long)
+// OBSOLETE B09rxxxx BNEZ branch not-equal-zero
+// OBSOLETE Br1rxxxx BNE branch not-equal
+// OBSOLETE 7Dxx BNC branch not-condition
+// OBSOLETE FDxxxxxx BNC branch not-condition (long)
+// OBSOLETE B0Arxxxx BLTZ branch less-than-zero
+// OBSOLETE B0Crxxxx BLEZ branch less-equal-zero
+// OBSOLETE 7Exx BL branch and link
+// OBSOLETE FExxxxxx BL branch and link (long)
+// OBSOLETE B0Drxxxx BGTZ branch greater-than-zero
+// OBSOLETE B0Brxxxx BGEZ branch greater-equal-zero
+// OBSOLETE B08rxxxx BEQZ branch equal-zero
+// OBSOLETE Br0rxxxx BEQ branch equal
+// OBSOLETE 7Cxx BC branch condition
+// OBSOLETE FCxxxxxx BC branch condition (long)
+// OBSOLETE */
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE isShortBranch (unsigned char *instr)
+// OBSOLETE {
+// OBSOLETE unsigned char instr0 = instr[0] & 0x7F; /* mask off high bit */
+// OBSOLETE
+// OBSOLETE if (instr0 == 0x10 && instr[1] == 0xB6) /* RTE */
+// OBSOLETE return 1; /* return from trap or exception */
+// OBSOLETE
+// OBSOLETE if (instr0 == 0x1E || instr0 == 0x1F) /* JL or JMP */
+// OBSOLETE if ((instr[1] & 0xF0) == 0xC0)
+// OBSOLETE return 2; /* jump thru a register */
+// OBSOLETE
+// OBSOLETE if (instr0 == 0x7C || instr0 == 0x7D || /* BC, BNC, BL, BRA */
+// OBSOLETE instr0 == 0x7E || instr0 == 0x7F)
+// OBSOLETE return 3; /* eight bit PC offset */
+// OBSOLETE
+// OBSOLETE return 0;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE isLongBranch (unsigned char *instr)
+// OBSOLETE {
+// OBSOLETE if (instr[0] == 0xFC || instr[0] == 0xFD || /* BRA, BNC, BL, BC */
+// OBSOLETE instr[0] == 0xFE || instr[0] == 0xFF) /* 24 bit relative */
+// OBSOLETE return 4;
+// OBSOLETE if ((instr[0] & 0xF0) == 0xB0) /* 16 bit relative */
+// OBSOLETE {
+// OBSOLETE if ((instr[1] & 0xF0) == 0x00 || /* BNE, BEQ */
+// OBSOLETE (instr[1] & 0xF0) == 0x10)
+// OBSOLETE return 5;
+// OBSOLETE if (instr[0] == 0xB0) /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ, BEQZ */
+// OBSOLETE if ((instr[1] & 0xF0) == 0x80 || (instr[1] & 0xF0) == 0x90 ||
+// OBSOLETE (instr[1] & 0xF0) == 0xA0 || (instr[1] & 0xF0) == 0xB0 ||
+// OBSOLETE (instr[1] & 0xF0) == 0xC0 || (instr[1] & 0xF0) == 0xD0)
+// OBSOLETE return 6;
+// OBSOLETE }
+// OBSOLETE return 0;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* if address is NOT on a 4-byte boundary, or high-bit of instr is zero,
+// OBSOLETE then it's a 2-byte instruction, else it's a 4-byte instruction. */
+// OBSOLETE
+// OBSOLETE #define INSTRUCTION_SIZE(addr) \
+// OBSOLETE ((((int) addr & 2) || (((unsigned char *) addr)[0] & 0x80) == 0) ? 2 : 4)
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE isBranch (unsigned char *instr)
+// OBSOLETE {
+// OBSOLETE if (INSTRUCTION_SIZE(instr) == 2)
+// OBSOLETE return isShortBranch(instr);
+// OBSOLETE else
+// OBSOLETE return isLongBranch(instr);
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE willBranch (unsigned char *instr, int branchCode)
+// OBSOLETE {
+// OBSOLETE switch (branchCode)
+// OBSOLETE {
+// OBSOLETE case 0: return 0; /* not a branch */
+// OBSOLETE case 1: return 1; /* RTE */
+// OBSOLETE case 2: return 1; /* JL or JMP */
+// OBSOLETE case 3: /* BC, BNC, BL, BRA (short) */
+// OBSOLETE case 4: /* BC, BNC, BL, BRA (long) */
+// OBSOLETE switch (instr[0] & 0x0F)
+// OBSOLETE {
+// OBSOLETE case 0xC: /* Branch if Condition Register */
+// OBSOLETE return (registers[CBR] != 0);
+// OBSOLETE case 0xD: /* Branch if NOT Condition Register */
+// OBSOLETE return (registers[CBR] == 0);
+// OBSOLETE case 0xE: /* Branch and Link */
+// OBSOLETE case 0xF: /* Branch (unconditional) */
+// OBSOLETE return 1;
+// OBSOLETE default: /* oops? */
+// OBSOLETE return 0;
+// OBSOLETE }
+// OBSOLETE case 5: /* BNE, BEQ */
+// OBSOLETE switch (instr[1] & 0xF0)
+// OBSOLETE {
+// OBSOLETE case 0x00: /* Branch if r1 equal to r2 */
+// OBSOLETE return (registers[instr[0] & 0x0F] == registers[instr[1] & 0x0F]);
+// OBSOLETE case 0x10: /* Branch if r1 NOT equal to r2 */
+// OBSOLETE return (registers[instr[0] & 0x0F] != registers[instr[1] & 0x0F]);
+// OBSOLETE default: /* oops? */
+// OBSOLETE return 0;
+// OBSOLETE }
+// OBSOLETE case 6: /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ */
+// OBSOLETE switch (instr[1] & 0xF0)
+// OBSOLETE {
+// OBSOLETE case 0x80: /* Branch if reg equal to zero */
+// OBSOLETE return (registers[instr[1] & 0x0F] == 0);
+// OBSOLETE case 0x90: /* Branch if reg NOT equal to zero */
+// OBSOLETE return (registers[instr[1] & 0x0F] != 0);
+// OBSOLETE case 0xA0: /* Branch if reg less than zero */
+// OBSOLETE return (registers[instr[1] & 0x0F] < 0);
+// OBSOLETE case 0xB0: /* Branch if reg greater or equal to zero */
+// OBSOLETE return (registers[instr[1] & 0x0F] >= 0);
+// OBSOLETE case 0xC0: /* Branch if reg less than or equal to zero */
+// OBSOLETE return (registers[instr[1] & 0x0F] <= 0);
+// OBSOLETE case 0xD0: /* Branch if reg greater than zero */
+// OBSOLETE return (registers[instr[1] & 0x0F] > 0);
+// OBSOLETE default: /* oops? */
+// OBSOLETE return 0;
+// OBSOLETE }
+// OBSOLETE default: /* oops? */
+// OBSOLETE return 0;
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE branchDestination (unsigned char *instr, int branchCode)
+// OBSOLETE {
+// OBSOLETE switch (branchCode) {
+// OBSOLETE default:
+// OBSOLETE case 0: /* not a branch */
+// OBSOLETE return 0;
+// OBSOLETE case 1: /* RTE */
+// OBSOLETE return registers[BPC] & ~3; /* pop BPC into PC */
+// OBSOLETE case 2: /* JL or JMP */
+// OBSOLETE return registers[instr[1] & 0x0F] & ~3; /* jump thru a register */
+// OBSOLETE case 3: /* BC, BNC, BL, BRA (short, 8-bit relative offset) */
+// OBSOLETE return (((int) instr) & ~3) + ((char) instr[1] << 2);
+// OBSOLETE case 4: /* BC, BNC, BL, BRA (long, 24-bit relative offset) */
+// OBSOLETE return ((int) instr +
+// OBSOLETE ((((char) instr[1] << 16) | (instr[2] << 8) | (instr[3])) << 2));
+// OBSOLETE case 5: /* BNE, BEQ (16-bit relative offset) */
+// OBSOLETE case 6: /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ (ditto) */
+// OBSOLETE return ((int) instr + ((((char) instr[2] << 8) | (instr[3])) << 2));
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* An explanatory note: in the last three return expressions, I have
+// OBSOLETE cast the most-significant byte of the return offset to char.
+// OBSOLETE What this accomplishes is sign extension. If the other
+// OBSOLETE less-significant bytes were signed as well, they would get sign
+// OBSOLETE extended too and, if negative, their leading bits would clobber
+// OBSOLETE the bits of the more-significant bytes ahead of them. There are
+// OBSOLETE other ways I could have done this, but sign extension from
+// OBSOLETE odd-sized integers is always a pain. */
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE static void
+// OBSOLETE branchSideEffects (unsigned char *instr, int branchCode)
+// OBSOLETE {
+// OBSOLETE switch (branchCode)
+// OBSOLETE {
+// OBSOLETE case 1: /* RTE */
+// OBSOLETE return; /* I <THINK> this is already handled... */
+// OBSOLETE case 2: /* JL (or JMP) */
+// OBSOLETE case 3: /* BL (or BC, BNC, BRA) */
+// OBSOLETE case 4:
+// OBSOLETE if ((instr[0] & 0x0F) == 0x0E) /* branch/jump and link */
+// OBSOLETE registers[R14] = (registers[PC] & ~3) + 4;
+// OBSOLETE return;
+// OBSOLETE default: /* any other branch has no side effects */
+// OBSOLETE return;
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE static struct STEPPING_CONTEXT {
+// OBSOLETE int stepping; /* true when we've started a single-step */
+// OBSOLETE unsigned long target_addr; /* the instr we're trying to execute */
+// OBSOLETE unsigned long target_size; /* the size of the target instr */
+// OBSOLETE unsigned long noop_addr; /* where we've inserted a no-op, if any */
+// OBSOLETE unsigned long trap1_addr; /* the trap following the target instr */
+// OBSOLETE unsigned long trap2_addr; /* the trap at a branch destination, if any */
+// OBSOLETE unsigned short noop_save; /* instruction overwritten by our no-op */
+// OBSOLETE unsigned short trap1_save; /* instruction overwritten by trap1 */
+// OBSOLETE unsigned short trap2_save; /* instruction overwritten by trap2 */
+// OBSOLETE unsigned short continue_p; /* true if NOT returning to gdb after step */
+// OBSOLETE } stepping;
+// OBSOLETE
+// OBSOLETE /* Function: prepare_to_step
+// OBSOLETE Called from handle_exception to prepare the user program to single-step.
+// OBSOLETE Places a trap instruction after the target instruction, with special
+// OBSOLETE extra handling for branch instructions and for instructions in the
+// OBSOLETE second half-word of a word.
+// OBSOLETE
+// OBSOLETE Returns: True if we should actually execute the instruction;
+// OBSOLETE False if we are going to emulate executing the instruction,
+// OBSOLETE in which case we simply report to GDB that the instruction
+// OBSOLETE has already been executed. */
+// OBSOLETE
+// OBSOLETE #define TRAP1 0x10f1; /* trap #1 instruction */
+// OBSOLETE #define NOOP 0x7000; /* noop instruction */
+// OBSOLETE
+// OBSOLETE static unsigned short trap1 = TRAP1;
+// OBSOLETE static unsigned short noop = NOOP;
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE prepare_to_step(continue_p)
+// OBSOLETE int continue_p; /* if this isn't REALLY a single-step (see below) */
+// OBSOLETE {
+// OBSOLETE unsigned long pc = registers[PC];
+// OBSOLETE int branchCode = isBranch((unsigned char *) pc);
+// OBSOLETE unsigned char *p;
+// OBSOLETE
+// OBSOLETE /* zero out the stepping context
+// OBSOLETE (paranoia -- it should already be zeroed) */
+// OBSOLETE for (p = (unsigned char *) &stepping;
+// OBSOLETE p < ((unsigned char *) &stepping) + sizeof(stepping);
+// OBSOLETE p++)
+// OBSOLETE *p = 0;
+// OBSOLETE
+// OBSOLETE if (branchCode != 0) /* next instruction is a branch */
+// OBSOLETE {
+// OBSOLETE branchSideEffects((unsigned char *) pc, branchCode);
+// OBSOLETE if (willBranch((unsigned char *)pc, branchCode))
+// OBSOLETE registers[PC] = branchDestination((unsigned char *) pc, branchCode);
+// OBSOLETE else
+// OBSOLETE registers[PC] = pc + INSTRUCTION_SIZE(pc);
+// OBSOLETE return 0; /* branch "executed" -- just notify GDB */
+// OBSOLETE }
+// OBSOLETE else if (((int) pc & 2) != 0) /* "second-slot" instruction */
+// OBSOLETE {
+// OBSOLETE /* insert no-op before pc */
+// OBSOLETE stepping.noop_addr = pc - 2;
+// OBSOLETE stepping.noop_save = *(unsigned short *) stepping.noop_addr;
+// OBSOLETE *(unsigned short *) stepping.noop_addr = noop;
+// OBSOLETE /* insert trap after pc */
+// OBSOLETE stepping.trap1_addr = pc + 2;
+// OBSOLETE stepping.trap1_save = *(unsigned short *) stepping.trap1_addr;
+// OBSOLETE *(unsigned short *) stepping.trap1_addr = trap1;
+// OBSOLETE }
+// OBSOLETE else /* "first-slot" instruction */
+// OBSOLETE {
+// OBSOLETE /* insert trap after pc */
+// OBSOLETE stepping.trap1_addr = pc + INSTRUCTION_SIZE(pc);
+// OBSOLETE stepping.trap1_save = *(unsigned short *) stepping.trap1_addr;
+// OBSOLETE *(unsigned short *) stepping.trap1_addr = trap1;
+// OBSOLETE }
+// OBSOLETE /* "continue_p" means that we are actually doing a continue, and not
+// OBSOLETE being requested to single-step by GDB. Sometimes we have to do
+// OBSOLETE one single-step before continuing, because the PC is on a half-word
+// OBSOLETE boundary. There's no way to simply resume at such an address. */
+// OBSOLETE stepping.continue_p = continue_p;
+// OBSOLETE stepping.stepping = 1; /* starting a single-step */
+// OBSOLETE return 1;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* Function: finish_from_step
+// OBSOLETE Called from handle_exception to finish up when the user program
+// OBSOLETE returns from a single-step. Replaces the instructions that had
+// OBSOLETE been overwritten by traps or no-ops,
+// OBSOLETE
+// OBSOLETE Returns: True if we should notify GDB that the target stopped.
+// OBSOLETE False if we only single-stepped because we had to before we
+// OBSOLETE could continue (ie. we were trying to continue at a
+// OBSOLETE half-word boundary). In that case don't notify GDB:
+// OBSOLETE just "continue continuing". */
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE finish_from_step (void)
+// OBSOLETE {
+// OBSOLETE if (stepping.stepping) /* anything to do? */
+// OBSOLETE {
+// OBSOLETE int continue_p = stepping.continue_p;
+// OBSOLETE unsigned char *p;
+// OBSOLETE
+// OBSOLETE if (stepping.noop_addr) /* replace instr "under" our no-op */
+// OBSOLETE *(unsigned short *) stepping.noop_addr = stepping.noop_save;
+// OBSOLETE if (stepping.trap1_addr) /* replace instr "under" our trap */
+// OBSOLETE *(unsigned short *) stepping.trap1_addr = stepping.trap1_save;
+// OBSOLETE if (stepping.trap2_addr) /* ditto our other trap, if any */
+// OBSOLETE *(unsigned short *) stepping.trap2_addr = stepping.trap2_save;
+// OBSOLETE
+// OBSOLETE for (p = (unsigned char *) &stepping; /* zero out the stepping context */
+// OBSOLETE p < ((unsigned char *) &stepping) + sizeof(stepping);
+// OBSOLETE p++)
+// OBSOLETE *p = 0;
+// OBSOLETE
+// OBSOLETE return !(continue_p);
+// OBSOLETE }
+// OBSOLETE else /* we didn't single-step, therefore this must be a legitimate stop */
+// OBSOLETE return 1;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE struct PSWreg { /* separate out the bit flags in the PSW register */
+// OBSOLETE int pad1 : 16;
+// OBSOLETE int bsm : 1;
+// OBSOLETE int bie : 1;
+// OBSOLETE int pad2 : 5;
+// OBSOLETE int bc : 1;
+// OBSOLETE int sm : 1;
+// OBSOLETE int ie : 1;
+// OBSOLETE int pad3 : 5;
+// OBSOLETE int c : 1;
+// OBSOLETE } *psw;
+// OBSOLETE
+// OBSOLETE /* Upon entry the value for LR to save has been pushed.
+// OBSOLETE We unpush that so that the value for the stack pointer saved is correct.
+// OBSOLETE Upon entry, all other registers are assumed to have not been modified
+// OBSOLETE since the interrupt/trap occured. */
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE stash_registers:
+// OBSOLETE push r0
+// OBSOLETE push r1
+// OBSOLETE seth r1, #shigh(registers)
+// OBSOLETE add3 r1, r1, #low(registers)
+// OBSOLETE pop r0 ; r1
+// OBSOLETE st r0, @(4,r1)
+// OBSOLETE pop r0 ; r0
+// OBSOLETE st r0, @r1
+// OBSOLETE addi r1, #4 ; only add 4 as subsequent saves are `pre inc'
+// OBSOLETE st r2, @+r1
+// OBSOLETE st r3, @+r1
+// OBSOLETE st r4, @+r1
+// OBSOLETE st r5, @+r1
+// OBSOLETE st r6, @+r1
+// OBSOLETE st r7, @+r1
+// OBSOLETE st r8, @+r1
+// OBSOLETE st r9, @+r1
+// OBSOLETE st r10, @+r1
+// OBSOLETE st r11, @+r1
+// OBSOLETE st r12, @+r1
+// OBSOLETE st r13, @+r1 ; fp
+// OBSOLETE pop r0 ; lr (r14)
+// OBSOLETE st r0, @+r1
+// OBSOLETE st sp, @+r1 ; sp contains right value at this point
+// OBSOLETE mvfc r0, cr0
+// OBSOLETE st r0, @+r1 ; cr0 == PSW
+// OBSOLETE mvfc r0, cr1
+// OBSOLETE st r0, @+r1 ; cr1 == CBR
+// OBSOLETE mvfc r0, cr2
+// OBSOLETE st r0, @+r1 ; cr2 == SPI
+// OBSOLETE mvfc r0, cr3
+// OBSOLETE st r0, @+r1 ; cr3 == SPU
+// OBSOLETE mvfc r0, cr6
+// OBSOLETE st r0, @+r1 ; cr6 == BPC
+// OBSOLETE st r0, @+r1 ; PC == BPC
+// OBSOLETE mvfaclo r0
+// OBSOLETE st r0, @+r1 ; ACCL
+// OBSOLETE mvfachi r0
+// OBSOLETE st r0, @+r1 ; ACCH
+// OBSOLETE jmp lr");
+// OBSOLETE
+// OBSOLETE /* C routine to clean up what stash_registers did.
+// OBSOLETE It is called after calling stash_registers.
+// OBSOLETE This is separate from stash_registers as we want to do this in C
+// OBSOLETE but doing stash_registers in C isn't straightforward. */
+// OBSOLETE
+// OBSOLETE static void
+// OBSOLETE cleanup_stash (void)
+// OBSOLETE {
+// OBSOLETE psw = (struct PSWreg *) ®isters[PSW]; /* fields of PSW register */
+// OBSOLETE psw->sm = psw->bsm; /* fix up pre-trap values of psw fields */
+// OBSOLETE psw->ie = psw->bie;
+// OBSOLETE psw->c = psw->bc;
+// OBSOLETE registers[CBR] = psw->bc; /* fix up pre-trap "C" register */
+// OBSOLETE
+// OBSOLETE #if 0 /* FIXME: Was in previous version. Necessary?
+// OBSOLETE (Remember that we use the "rte" insn to return from the
+// OBSOLETE trap/interrupt so the values of bsm, bie, bc are important. */
+// OBSOLETE psw->bsm = psw->bie = psw->bc = 0; /* zero post-trap values */
+// OBSOLETE #endif
+// OBSOLETE
+// OBSOLETE /* FIXME: Copied from previous version. This can probably be deleted
+// OBSOLETE since methinks stash_registers has already done this. */
+// OBSOLETE registers[PC] = registers[BPC]; /* pre-trap PC */
+// OBSOLETE
+// OBSOLETE /* FIXME: Copied from previous version. Necessary? */
+// OBSOLETE if (psw->sm) /* copy R15 into (psw->sm ? SPU : SPI) */
+// OBSOLETE registers[SPU] = registers[R15];
+// OBSOLETE else
+// OBSOLETE registers[SPI] = registers[R15];
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE restore_and_return:
+// OBSOLETE seth r0, #shigh(registers+8)
+// OBSOLETE add3 r0, r0, #low(registers+8)
+// OBSOLETE ld r2, @r0+ ; restore r2
+// OBSOLETE ld r3, @r0+ ; restore r3
+// OBSOLETE ld r4, @r0+ ; restore r4
+// OBSOLETE ld r5, @r0+ ; restore r5
+// OBSOLETE ld r6, @r0+ ; restore r6
+// OBSOLETE ld r7, @r0+ ; restore r7
+// OBSOLETE ld r8, @r0+ ; restore r8
+// OBSOLETE ld r9, @r0+ ; restore r9
+// OBSOLETE ld r10, @r0+ ; restore r10
+// OBSOLETE ld r11, @r0+ ; restore r11
+// OBSOLETE ld r12, @r0+ ; restore r12
+// OBSOLETE ld r13, @r0+ ; restore r13
+// OBSOLETE ld r14, @r0+ ; restore r14
+// OBSOLETE ld r15, @r0+ ; restore r15
+// OBSOLETE addi r0, #4 ; don't restore PSW (rte will do it)
+// OBSOLETE ld r1, @r0+ ; restore cr1 == CBR (no-op, because it's read only)
+// OBSOLETE mvtc r1, cr1
+// OBSOLETE ld r1, @r0+ ; restore cr2 == SPI
+// OBSOLETE mvtc r1, cr2
+// OBSOLETE ld r1, @r0+ ; restore cr3 == SPU
+// OBSOLETE mvtc r1, cr3
+// OBSOLETE addi r0, #4 ; skip BPC
+// OBSOLETE ld r1, @r0+ ; restore cr6 (BPC) == PC
+// OBSOLETE mvtc r1, cr6
+// OBSOLETE ld r1, @r0+ ; restore ACCL
+// OBSOLETE mvtaclo r1
+// OBSOLETE ld r1, @r0+ ; restore ACCH
+// OBSOLETE mvtachi r1
+// OBSOLETE seth r0, #shigh(registers)
+// OBSOLETE add3 r0, r0, #low(registers)
+// OBSOLETE ld r1, @(4,r0) ; restore r1
+// OBSOLETE ld r0, @r0 ; restore r0
+// OBSOLETE rte");
+// OBSOLETE
+// OBSOLETE /* General trap handler, called after the registers have been stashed.
+// OBSOLETE NUM is the trap/exception number. */
+// OBSOLETE
+// OBSOLETE static void
+// OBSOLETE process_exception (int num)
+// OBSOLETE {
+// OBSOLETE cleanup_stash ();
+// OBSOLETE asm volatile ("
+// OBSOLETE seth r1, #shigh(stackPtr)
+// OBSOLETE add3 r1, r1, #low(stackPtr)
+// OBSOLETE ld r15, @r1 ; setup local stack (protect user stack)
+// OBSOLETE mv r0, %0
+// OBSOLETE bl handle_exception
+// OBSOLETE bl restore_and_return"
+// OBSOLETE : : "r" (num) : "r0", "r1");
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE void _catchException0 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException0:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #0
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException1 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException1:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE bl cleanup_stash
+// OBSOLETE seth r1, #shigh(stackPtr)
+// OBSOLETE add3 r1, r1, #low(stackPtr)
+// OBSOLETE ld r15, @r1 ; setup local stack (protect user stack)
+// OBSOLETE seth r1, #shigh(registers + 21*4) ; PC
+// OBSOLETE add3 r1, r1, #low(registers + 21*4)
+// OBSOLETE ld r0, @r1
+// OBSOLETE addi r0, #-4 ; back up PC for breakpoint trap.
+// OBSOLETE st r0, @r1 ; FIXME: what about bp in right slot?
+// OBSOLETE ldi r0, #1
+// OBSOLETE bl handle_exception
+// OBSOLETE bl restore_and_return");
+// OBSOLETE
+// OBSOLETE void _catchException2 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException2:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #2
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException3 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException3:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #3
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException4 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException4:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #4
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException5 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException5:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #5
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException6 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException6:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #6
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException7 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException7:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #7
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException8 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException8:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #8
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException9 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException9:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #9
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException10 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException10:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #10
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException11 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException11:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #11
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException12 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException12:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #12
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException13 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException13:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #13
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException14 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException14:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #14
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException15 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException15:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #15
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException16 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException16:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #16
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE void _catchException17 ();
+// OBSOLETE
+// OBSOLETE asm ("
+// OBSOLETE _catchException17:
+// OBSOLETE push lr
+// OBSOLETE bl stash_registers
+// OBSOLETE ; Note that at this point the pushed value of `lr' has been popped
+// OBSOLETE ldi r0, #17
+// OBSOLETE bl process_exception");
+// OBSOLETE
+// OBSOLETE
+// OBSOLETE /* this function is used to set up exception handlers for tracing and
+// OBSOLETE breakpoints */
+// OBSOLETE void
+// OBSOLETE set_debug_traps (void)
+// OBSOLETE {
+// OBSOLETE /* extern void remcomHandler(); */
+// OBSOLETE int i;
+// OBSOLETE
+// OBSOLETE for (i = 0; i < 18; i++) /* keep a copy of old vectors */
+// OBSOLETE if (save_vectors[i] == 0) /* only copy them the first time */
+// OBSOLETE save_vectors[i] = getExceptionHandler (i);
+// OBSOLETE
+// OBSOLETE stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];
+// OBSOLETE
+// OBSOLETE exceptionHandler (0, _catchException0);
+// OBSOLETE exceptionHandler (1, _catchException1);
+// OBSOLETE exceptionHandler (2, _catchException2);
+// OBSOLETE exceptionHandler (3, _catchException3);
+// OBSOLETE exceptionHandler (4, _catchException4);
+// OBSOLETE exceptionHandler (5, _catchException5);
+// OBSOLETE exceptionHandler (6, _catchException6);
+// OBSOLETE exceptionHandler (7, _catchException7);
+// OBSOLETE exceptionHandler (8, _catchException8);
+// OBSOLETE exceptionHandler (9, _catchException9);
+// OBSOLETE exceptionHandler (10, _catchException10);
+// OBSOLETE exceptionHandler (11, _catchException11);
+// OBSOLETE exceptionHandler (12, _catchException12);
+// OBSOLETE exceptionHandler (13, _catchException13);
+// OBSOLETE exceptionHandler (14, _catchException14);
+// OBSOLETE exceptionHandler (15, _catchException15);
+// OBSOLETE exceptionHandler (16, _catchException16);
+// OBSOLETE /* exceptionHandler (17, _catchException17); */
+// OBSOLETE
+// OBSOLETE initialized = 1;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* This function will generate a breakpoint exception. It is used at the
+// OBSOLETE beginning of a program to sync up with a debugger and can be used
+// OBSOLETE otherwise as a quick means to stop program execution and "break" into
+// OBSOLETE the debugger. */
+// OBSOLETE
+// OBSOLETE #define BREAKPOINT() asm volatile (" trap #2");
+// OBSOLETE
+// OBSOLETE void
+// OBSOLETE breakpoint (void)
+// OBSOLETE {
+// OBSOLETE if (initialized)
+// OBSOLETE BREAKPOINT();
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* STDOUT section:
+// OBSOLETE Stuff pertaining to simulating stdout by sending chars to gdb to be echoed.
+// OBSOLETE Functions: gdb_putchar(char ch)
+// OBSOLETE gdb_puts(char *str)
+// OBSOLETE gdb_write(char *str, int len)
+// OBSOLETE gdb_error(char *format, char *parm)
+// OBSOLETE */
+// OBSOLETE
+// OBSOLETE /* Function: gdb_putchar(int)
+// OBSOLETE Make gdb write a char to stdout.
+// OBSOLETE Returns: the char */
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE gdb_putchar (int ch)
+// OBSOLETE {
+// OBSOLETE char buf[4];
+// OBSOLETE
+// OBSOLETE buf[0] = 'O';
+// OBSOLETE buf[1] = hexchars[ch >> 4];
+// OBSOLETE buf[2] = hexchars[ch & 0x0F];
+// OBSOLETE buf[3] = 0;
+// OBSOLETE putpacket(buf);
+// OBSOLETE return ch;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* Function: gdb_write(char *, int)
+// OBSOLETE Make gdb write n bytes to stdout (not assumed to be null-terminated).
+// OBSOLETE Returns: number of bytes written */
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE gdb_write (char *data, int len)
+// OBSOLETE {
+// OBSOLETE char *buf, *cpy;
+// OBSOLETE int i;
+// OBSOLETE
+// OBSOLETE buf = remcomOutBuffer;
+// OBSOLETE buf[0] = 'O';
+// OBSOLETE i = 0;
+// OBSOLETE while (i < len)
+// OBSOLETE {
+// OBSOLETE for (cpy = buf+1;
+// OBSOLETE i < len && cpy < buf + sizeof(remcomOutBuffer) - 3;
+// OBSOLETE i++)
+// OBSOLETE {
+// OBSOLETE *cpy++ = hexchars[data[i] >> 4];
+// OBSOLETE *cpy++ = hexchars[data[i] & 0x0F];
+// OBSOLETE }
+// OBSOLETE *cpy = 0;
+// OBSOLETE putpacket(buf);
+// OBSOLETE }
+// OBSOLETE return len;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* Function: gdb_puts(char *)
+// OBSOLETE Make gdb write a null-terminated string to stdout.
+// OBSOLETE Returns: the length of the string */
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE gdb_puts (char *str)
+// OBSOLETE {
+// OBSOLETE return gdb_write(str, strlen(str));
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE /* Function: gdb_error(char *, char *)
+// OBSOLETE Send an error message to gdb's stdout.
+// OBSOLETE First string may have 1 (one) optional "%s" in it, which
+// OBSOLETE will cause the optional second string to be inserted. */
+// OBSOLETE
+// OBSOLETE static void
+// OBSOLETE gdb_error (char *format, char *parm)
+// OBSOLETE {
+// OBSOLETE char buf[400], *cpy;
+// OBSOLETE int len;
+// OBSOLETE
+// OBSOLETE if (remote_debug)
+// OBSOLETE {
+// OBSOLETE if (format && *format)
+// OBSOLETE len = strlen(format);
+// OBSOLETE else
+// OBSOLETE return; /* empty input */
+// OBSOLETE
+// OBSOLETE if (parm && *parm)
+// OBSOLETE len += strlen(parm);
+// OBSOLETE
+// OBSOLETE for (cpy = buf; *format; )
+// OBSOLETE {
+// OBSOLETE if (format[0] == '%' && format[1] == 's') /* include second string */
+// OBSOLETE {
+// OBSOLETE format += 2; /* advance two chars instead of just one */
+// OBSOLETE while (parm && *parm)
+// OBSOLETE *cpy++ = *parm++;
+// OBSOLETE }
+// OBSOLETE else
+// OBSOLETE *cpy++ = *format++;
+// OBSOLETE }
+// OBSOLETE *cpy = '\0';
+// OBSOLETE gdb_puts(buf);
+// OBSOLETE }
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE static unsigned char *
+// OBSOLETE strcpy (unsigned char *dest, const unsigned char *src)
+// OBSOLETE {
+// OBSOLETE unsigned char *ret = dest;
+// OBSOLETE
+// OBSOLETE if (dest && src)
+// OBSOLETE {
+// OBSOLETE while (*src)
+// OBSOLETE *dest++ = *src++;
+// OBSOLETE *dest = 0;
+// OBSOLETE }
+// OBSOLETE return ret;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE strlen (const unsigned char *src)
+// OBSOLETE {
+// OBSOLETE int ret;
+// OBSOLETE
+// OBSOLETE for (ret = 0; *src; src++)
+// OBSOLETE ret++;
+// OBSOLETE
+// OBSOLETE return ret;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE #if 0
+// OBSOLETE void exit (code)
+// OBSOLETE int code;
+// OBSOLETE {
+// OBSOLETE _exit (code);
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE int atexit (void *p)
+// OBSOLETE {
+// OBSOLETE return 0;
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE void abort (void)
+// OBSOLETE {
+// OBSOLETE _exit (1);
+// OBSOLETE }
+// OBSOLETE #endif
projects / deliverable / binutils-gdb.git / blobdiff