* config/m32r/m32r.mt (GDBSERVER_LIBS): Added ../../intl/libintl.a.
* config/mips/vr5000.mt (GDBSERVER_LIBS): Likewise. * config/tic80/tic80.mt (GDBSERVER_LIBS): Likewise. * gdbserver/low-sim.c (#include "defs.h"): Removed. (mygeneric_load): Rename from generic_load. * gdbserver/low-hppabsd.c (#include "server.h"): Added. (#include "defs.h"): Removed. (inferior_pid, perror_with_name): Remove declarations. * gdbserver/low-linux.c: Likewise. * gdbserver/low-nbsd.c: Likewise. * gdbserver/low-sparc.c: Likewise. * gdbserver/low-sun3.c: Likewise. * i386-stub.c: Re-indent. * m68k-stub.c: Re-indent.
This commit is contained in:
parent
329de80343
commit
f29d9b6d30
|
@ -1,3 +1,22 @@
|
|||
2001-01-23 J.T. Conklin <jtc@redback.com>
|
||||
|
||||
* config/m32r/m32r.mt (GDBSERVER_LIBS): Added ../../intl/libintl.a.
|
||||
* config/mips/vr5000.mt (GDBSERVER_LIBS): Likewise.
|
||||
* config/tic80/tic80.mt (GDBSERVER_LIBS): Likewise.
|
||||
* gdbserver/low-sim.c (#include "defs.h"): Removed.
|
||||
(mygeneric_load): Rename from generic_load.
|
||||
|
||||
* gdbserver/low-hppabsd.c (#include "server.h"): Added.
|
||||
(#include "defs.h"): Removed.
|
||||
(inferior_pid, perror_with_name): Remove declarations.
|
||||
* gdbserver/low-linux.c: Likewise.
|
||||
* gdbserver/low-nbsd.c: Likewise.
|
||||
* gdbserver/low-sparc.c: Likewise.
|
||||
* gdbserver/low-sun3.c: Likewise.
|
||||
|
||||
* i386-stub.c: Re-indent.
|
||||
* m68k-stub.c: Re-indent.
|
||||
|
||||
2001-01-22 Nicholas Duffek <nsd@redhat.com>
|
||||
|
||||
* gdbarch.sh (PARM_BOUNDARY): Define.
|
||||
|
|
|
@ -4,4 +4,4 @@ TM_FILE= tm-m32r.h
|
|||
SIM_OBS = remote-sim.o
|
||||
SIM = ../sim/m32r/libsim.a
|
||||
GDBSERVER_DEPFILES= low-sim.o
|
||||
GDBSERVER_LIBS = ../../sim/m32r/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a ../../opcodes/libopcodes.a
|
||||
GDBSERVER_LIBS = ../../sim/m32r/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a ../../opcodes/libopcodes.a ../../intl/libintl.a
|
||||
|
|
|
@ -4,4 +4,4 @@ TM_FILE= tm-vr5000.h
|
|||
SIM_OBS = remote-sim.o
|
||||
SIM = ../sim/mips/libsim.a
|
||||
GDBSERVER_DEPFILES= low-sim.o
|
||||
GDBSERVER_LIBS = ../../sim/mips/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a -lm
|
||||
GDBSERVER_LIBS = ../../sim/mips/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a -lm ../../intl/libintl.a
|
||||
|
|
|
@ -4,4 +4,4 @@ TM_FILE= tm-tic80.h
|
|||
SIM_OBS = remote-sim.o
|
||||
SIM = ../sim/tic80/libsim.a
|
||||
GDBSERVER_DEPFILES= low-sim.o
|
||||
GDBSERVER_LIBS = ../../sim/tic80/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a -lm
|
||||
GDBSERVER_LIBS = ../../sim/tic80/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a -lm ../../intl/libintl.a
|
||||
|
|
|
@ -18,7 +18,7 @@
|
|||
Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
Boston, MA 02111-1307, USA. */
|
||||
|
||||
#include "defs.h"
|
||||
#include "server.h"
|
||||
#include <sys/wait.h>
|
||||
#include "frame.h"
|
||||
#include "inferior.h"
|
||||
|
@ -41,8 +41,6 @@ char *registers = my_registers;
|
|||
#include <machine/reg.h>
|
||||
|
||||
extern int errno;
|
||||
extern int inferior_pid;
|
||||
void perror_with_name ();
|
||||
|
||||
/* Start an inferior process and returns its pid.
|
||||
ALLARGS is a vector of program-name and args. */
|
||||
|
|
|
@ -18,7 +18,7 @@
|
|||
Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
Boston, MA 02111-1307, USA. */
|
||||
|
||||
#include "defs.h"
|
||||
#include "server.h"
|
||||
#include <sys/wait.h>
|
||||
#include "frame.h"
|
||||
#include "inferior.h"
|
||||
|
@ -47,8 +47,6 @@ char *registers = my_registers;
|
|||
#endif
|
||||
|
||||
extern int errno;
|
||||
extern int inferior_pid;
|
||||
void perror_with_name ();
|
||||
|
||||
static void initialize_arch (void);
|
||||
|
||||
|
|
|
@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License
|
|||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
||||
|
||||
#include "defs.h"
|
||||
#include "server.h"
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
#include "frame.h"
|
||||
|
@ -34,11 +34,6 @@ char *registers = my_registers;
|
|||
#include <sys/ptrace.h>
|
||||
#include <machine/reg.h>
|
||||
|
||||
// extern int sys_nerr;
|
||||
// extern char **sys_errlist;
|
||||
extern int inferior_pid;
|
||||
void perror_with_name ();
|
||||
|
||||
#define RF(dst, src) \
|
||||
memcpy(®isters[REGISTER_BYTE(dst)], &src, sizeof(src))
|
||||
|
||||
|
|
|
@ -18,9 +18,8 @@
|
|||
Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
Boston, MA 02111-1307, USA. */
|
||||
|
||||
#include "defs.h"
|
||||
#include "bfd.h"
|
||||
#include "server.h"
|
||||
#include "bfd.h"
|
||||
#include "callback.h" /* GDB simulator callback interface */
|
||||
#include "remote-sim.h" /* GDB simulator interface */
|
||||
|
||||
|
@ -41,7 +40,7 @@ static SIM_DESC gdbsim_desc = 0;
|
|||
does not support loading itself. */
|
||||
|
||||
static void
|
||||
generic_load (bfd *loadfile_bfd)
|
||||
mygeneric_load (bfd *loadfile_bfd)
|
||||
{
|
||||
asection *s;
|
||||
|
||||
|
@ -131,7 +130,7 @@ create_inferior (char *program, char **argv)
|
|||
/* Load the program into the simulator. */
|
||||
if (abfd)
|
||||
if (sim_load (gdbsim_desc, program, NULL, 0) == SIM_RC_FAIL)
|
||||
generic_load (abfd);
|
||||
mygeneric_load (abfd);
|
||||
|
||||
/* Create an inferior process in the simulator. This initializes SP. */
|
||||
sim_create_inferior (gdbsim_desc, abfd, argv, /* env */ NULL);
|
||||
|
|
|
@ -18,7 +18,7 @@
|
|||
Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
Boston, MA 02111-1307, USA. */
|
||||
|
||||
#include "defs.h"
|
||||
#include "server.h"
|
||||
#include <sys/wait.h>
|
||||
#include "frame.h"
|
||||
#include "inferior.h"
|
||||
|
@ -46,8 +46,6 @@ char *registers = my_registers;
|
|||
extern int sys_nerr;
|
||||
extern char **sys_errlist;
|
||||
extern int errno;
|
||||
extern int inferior_pid;
|
||||
void perror_with_name ();
|
||||
|
||||
/* Start an inferior process and returns its pid.
|
||||
ALLARGS is a vector of program-name and args. */
|
||||
|
|
|
@ -18,7 +18,7 @@
|
|||
Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
Boston, MA 02111-1307, USA. */
|
||||
|
||||
#include "defs.h"
|
||||
#include "server.h"
|
||||
#include "<sys/wait.h>"
|
||||
#include "frame.h"
|
||||
#include "inferior.h"
|
||||
|
@ -43,8 +43,6 @@ char *registers = my_registers;
|
|||
extern int sys_nerr;
|
||||
extern char **sys_errlist;
|
||||
extern int errno;
|
||||
extern int inferior_pid;
|
||||
void perror_with_name ();
|
||||
|
||||
/* Start an inferior process and returns its pid.
|
||||
ALLARGS is a vector of program-name and args. */
|
||||
|
|
501
gdb/i386-stub.c
501
gdb/i386-stub.c
|
@ -429,17 +429,22 @@ asm(" movl _stackPtr, %esp"); /* move to remcom stack area */
|
|||
asm(" pushl %eax"); /* push exception onto stack */
|
||||
asm(" call _handle_exception"); /* this never returns */
|
||||
|
||||
void _returnFromException()
|
||||
void
|
||||
_returnFromException ()
|
||||
{
|
||||
return_to_prog ();
|
||||
}
|
||||
|
||||
int hex(ch)
|
||||
char ch;
|
||||
int
|
||||
hex (ch)
|
||||
char ch;
|
||||
{
|
||||
if ((ch >= 'a') && (ch <= 'f')) return (ch-'a'+10);
|
||||
if ((ch >= '0') && (ch <= '9')) return (ch-'0');
|
||||
if ((ch >= 'A') && (ch <= 'F')) return (ch-'A'+10);
|
||||
if ((ch >= 'a') && (ch <= 'f'))
|
||||
return (ch - 'a' + 10);
|
||||
if ((ch >= '0') && (ch <= '9'))
|
||||
return (ch - '0');
|
||||
if ((ch >= 'A') && (ch <= 'F'))
|
||||
return (ch - 'A' + 10);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
|
@ -463,7 +468,7 @@ getpacket (void)
|
|||
while ((ch = getDebugChar ()) != '$')
|
||||
;
|
||||
|
||||
retry:
|
||||
retry:
|
||||
checksum = 0;
|
||||
xmitcsum = -1;
|
||||
count = 0;
|
||||
|
@ -472,7 +477,7 @@ retry:
|
|||
while (count < BUFMAX)
|
||||
{
|
||||
ch = getDebugChar ();
|
||||
if (ch == '$')
|
||||
if (ch == '$')
|
||||
goto retry;
|
||||
if (ch == '#')
|
||||
break;
|
||||
|
@ -494,7 +499,7 @@ retry:
|
|||
if (remote_debug)
|
||||
{
|
||||
fprintf (stderr,
|
||||
"bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
|
||||
"bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
|
||||
checksum, xmitcsum, buffer);
|
||||
}
|
||||
putDebugChar ('-'); /* failed checksum */
|
||||
|
@ -520,42 +525,46 @@ retry:
|
|||
|
||||
/* send the packet in buffer. */
|
||||
|
||||
void putpacket(buffer)
|
||||
unsigned char *buffer;
|
||||
void
|
||||
putpacket (unsigned char *buffer)
|
||||
{
|
||||
unsigned char checksum;
|
||||
int count;
|
||||
int count;
|
||||
char ch;
|
||||
|
||||
/* $<packet info>#<checksum>. */
|
||||
do {
|
||||
putDebugChar('$');
|
||||
checksum = 0;
|
||||
count = 0;
|
||||
do
|
||||
{
|
||||
putDebugChar ('$');
|
||||
checksum = 0;
|
||||
count = 0;
|
||||
|
||||
while (ch=buffer[count]) {
|
||||
putDebugChar(ch);
|
||||
checksum += ch;
|
||||
count += 1;
|
||||
}
|
||||
while (ch = buffer[count])
|
||||
{
|
||||
putDebugChar (ch);
|
||||
checksum += ch;
|
||||
count += 1;
|
||||
}
|
||||
|
||||
putDebugChar('#');
|
||||
putDebugChar(hexchars[checksum >> 4]);
|
||||
putDebugChar(hexchars[checksum % 16]);
|
||||
|
||||
} while (getDebugChar() != '+');
|
||||
putDebugChar ('#');
|
||||
putDebugChar (hexchars[checksum >> 4]);
|
||||
putDebugChar (hexchars[checksum % 16]);
|
||||
|
||||
}
|
||||
while (getDebugChar () != '+');
|
||||
}
|
||||
|
||||
void debug_error(format, parm)
|
||||
char * format;
|
||||
char * parm;
|
||||
void
|
||||
debug_error (format, parm)
|
||||
char *format;
|
||||
char *parm;
|
||||
{
|
||||
if (remote_debug) fprintf (stderr,format,parm);
|
||||
if (remote_debug)
|
||||
fprintf (stderr, format, parm);
|
||||
}
|
||||
|
||||
/* Address of a routine to RTE to if we get a memory fault. */
|
||||
static void (*volatile mem_fault_routine)() = NULL;
|
||||
static void (*volatile mem_fault_routine) () = NULL;
|
||||
|
||||
/* Indicate to caller of mem2hex or hex2mem that there has been an
|
||||
error. */
|
||||
|
@ -587,80 +596,115 @@ set_char (char *addr, int val)
|
|||
/* return a pointer to the last char put in buf (null) */
|
||||
/* If MAY_FAULT is non-zero, then we should set mem_err in response to
|
||||
a fault; if zero treat a fault like any other fault in the stub. */
|
||||
char* mem2hex(mem, buf, count, may_fault)
|
||||
char* mem;
|
||||
char* buf;
|
||||
int count;
|
||||
int may_fault;
|
||||
char *
|
||||
mem2hex (mem, buf, count, may_fault)
|
||||
char *mem;
|
||||
char *buf;
|
||||
int count;
|
||||
int may_fault;
|
||||
{
|
||||
int i;
|
||||
unsigned char ch;
|
||||
int i;
|
||||
unsigned char ch;
|
||||
|
||||
if (may_fault)
|
||||
mem_fault_routine = set_mem_err;
|
||||
for (i=0;i<count;i++) {
|
||||
ch = get_char (mem++);
|
||||
if (may_fault && mem_err)
|
||||
return (buf);
|
||||
*buf++ = hexchars[ch >> 4];
|
||||
*buf++ = hexchars[ch % 16];
|
||||
}
|
||||
*buf = 0;
|
||||
if (may_fault)
|
||||
mem_fault_routine = NULL;
|
||||
return(buf);
|
||||
if (may_fault)
|
||||
mem_fault_routine = set_mem_err;
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
ch = get_char (mem++);
|
||||
if (may_fault && mem_err)
|
||||
return (buf);
|
||||
*buf++ = hexchars[ch >> 4];
|
||||
*buf++ = hexchars[ch % 16];
|
||||
}
|
||||
*buf = 0;
|
||||
if (may_fault)
|
||||
mem_fault_routine = NULL;
|
||||
return (buf);
|
||||
}
|
||||
|
||||
/* convert the hex array pointed to by buf into binary to be placed in mem */
|
||||
/* return a pointer to the character AFTER the last byte written */
|
||||
char* hex2mem(buf, mem, count, may_fault)
|
||||
char* buf;
|
||||
char* mem;
|
||||
int count;
|
||||
int may_fault;
|
||||
char *
|
||||
hex2mem (buf, mem, count, may_fault)
|
||||
char *buf;
|
||||
char *mem;
|
||||
int count;
|
||||
int may_fault;
|
||||
{
|
||||
int i;
|
||||
unsigned char ch;
|
||||
int i;
|
||||
unsigned char ch;
|
||||
|
||||
if (may_fault)
|
||||
mem_fault_routine = set_mem_err;
|
||||
for (i=0;i<count;i++) {
|
||||
ch = hex(*buf++) << 4;
|
||||
ch = ch + hex(*buf++);
|
||||
set_char (mem++, ch);
|
||||
if (may_fault && mem_err)
|
||||
return (mem);
|
||||
}
|
||||
if (may_fault)
|
||||
mem_fault_routine = NULL;
|
||||
return(mem);
|
||||
if (may_fault)
|
||||
mem_fault_routine = set_mem_err;
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
ch = hex (*buf++) << 4;
|
||||
ch = ch + hex (*buf++);
|
||||
set_char (mem++, ch);
|
||||
if (may_fault && mem_err)
|
||||
return (mem);
|
||||
}
|
||||
if (may_fault)
|
||||
mem_fault_routine = NULL;
|
||||
return (mem);
|
||||
}
|
||||
|
||||
/* this function takes the 386 exception vector and attempts to
|
||||
translate this number into a unix compatible signal value */
|
||||
int computeSignal( exceptionVector )
|
||||
int exceptionVector;
|
||||
int
|
||||
computeSignal (int exceptionVector)
|
||||
{
|
||||
int sigval;
|
||||
switch (exceptionVector) {
|
||||
case 0 : sigval = 8; break; /* divide by zero */
|
||||
case 1 : sigval = 5; break; /* debug exception */
|
||||
case 3 : sigval = 5; break; /* breakpoint */
|
||||
case 4 : sigval = 16; break; /* into instruction (overflow) */
|
||||
case 5 : sigval = 16; break; /* bound instruction */
|
||||
case 6 : sigval = 4; break; /* Invalid opcode */
|
||||
case 7 : sigval = 8; break; /* coprocessor not available */
|
||||
case 8 : sigval = 7; break; /* double fault */
|
||||
case 9 : sigval = 11; break; /* coprocessor segment overrun */
|
||||
case 10 : sigval = 11; break; /* Invalid TSS */
|
||||
case 11 : sigval = 11; break; /* Segment not present */
|
||||
case 12 : sigval = 11; break; /* stack exception */
|
||||
case 13 : sigval = 11; break; /* general protection */
|
||||
case 14 : sigval = 11; break; /* page fault */
|
||||
case 16 : sigval = 7; break; /* coprocessor error */
|
||||
switch (exceptionVector)
|
||||
{
|
||||
case 0:
|
||||
sigval = 8;
|
||||
break; /* divide by zero */
|
||||
case 1:
|
||||
sigval = 5;
|
||||
break; /* debug exception */
|
||||
case 3:
|
||||
sigval = 5;
|
||||
break; /* breakpoint */
|
||||
case 4:
|
||||
sigval = 16;
|
||||
break; /* into instruction (overflow) */
|
||||
case 5:
|
||||
sigval = 16;
|
||||
break; /* bound instruction */
|
||||
case 6:
|
||||
sigval = 4;
|
||||
break; /* Invalid opcode */
|
||||
case 7:
|
||||
sigval = 8;
|
||||
break; /* coprocessor not available */
|
||||
case 8:
|
||||
sigval = 7;
|
||||
break; /* double fault */
|
||||
case 9:
|
||||
sigval = 11;
|
||||
break; /* coprocessor segment overrun */
|
||||
case 10:
|
||||
sigval = 11;
|
||||
break; /* Invalid TSS */
|
||||
case 11:
|
||||
sigval = 11;
|
||||
break; /* Segment not present */
|
||||
case 12:
|
||||
sigval = 11;
|
||||
break; /* stack exception */
|
||||
case 13:
|
||||
sigval = 11;
|
||||
break; /* general protection */
|
||||
case 14:
|
||||
sigval = 11;
|
||||
break; /* page fault */
|
||||
case 16:
|
||||
sigval = 7;
|
||||
break; /* coprocessor error */
|
||||
default:
|
||||
sigval = 7; /* "software generated"*/
|
||||
}
|
||||
sigval = 7; /* "software generated" */
|
||||
}
|
||||
return (sigval);
|
||||
}
|
||||
|
||||
|
@ -668,184 +712,194 @@ int exceptionVector;
|
|||
/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
|
||||
/* RETURN NUMBER OF CHARS PROCESSED */
|
||||
/**********************************************/
|
||||
int hexToInt(char **ptr, int *intValue)
|
||||
int
|
||||
hexToInt (char **ptr, int *intValue)
|
||||
{
|
||||
int numChars = 0;
|
||||
int hexValue;
|
||||
int numChars = 0;
|
||||
int hexValue;
|
||||
|
||||
*intValue = 0;
|
||||
*intValue = 0;
|
||||
|
||||
while (**ptr)
|
||||
while (**ptr)
|
||||
{
|
||||
hexValue = hex(**ptr);
|
||||
if (hexValue >=0)
|
||||
{
|
||||
*intValue = (*intValue <<4) | hexValue;
|
||||
numChars ++;
|
||||
}
|
||||
else
|
||||
break;
|
||||
hexValue = hex (**ptr);
|
||||
if (hexValue >= 0)
|
||||
{
|
||||
*intValue = (*intValue << 4) | hexValue;
|
||||
numChars++;
|
||||
}
|
||||
else
|
||||
break;
|
||||
|
||||
(*ptr)++;
|
||||
(*ptr)++;
|
||||
}
|
||||
|
||||
return (numChars);
|
||||
return (numChars);
|
||||
}
|
||||
|
||||
/*
|
||||
* This function does all command procesing for interfacing to gdb.
|
||||
*/
|
||||
void handle_exception(int exceptionVector)
|
||||
void
|
||||
handle_exception (int exceptionVector)
|
||||
{
|
||||
int sigval, stepping;
|
||||
int addr, length;
|
||||
char * ptr;
|
||||
int newPC;
|
||||
int sigval, stepping;
|
||||
int addr, length;
|
||||
char *ptr;
|
||||
int newPC;
|
||||
|
||||
gdb_i386vector = exceptionVector;
|
||||
|
||||
if (remote_debug) printf("vector=%d, sr=0x%x, pc=0x%x\n",
|
||||
exceptionVector,
|
||||
registers[ PS ],
|
||||
registers[ PC ]);
|
||||
if (remote_debug)
|
||||
{
|
||||
printf ("vector=%d, sr=0x%x, pc=0x%x\n",
|
||||
exceptionVector, registers[PS], registers[PC]);
|
||||
}
|
||||
|
||||
/* reply to host that an exception has occurred */
|
||||
sigval = computeSignal( exceptionVector );
|
||||
sigval = computeSignal (exceptionVector);
|
||||
remcomOutBuffer[0] = 'S';
|
||||
remcomOutBuffer[1] = hexchars[sigval >> 4];
|
||||
remcomOutBuffer[2] = hexchars[sigval % 16];
|
||||
remcomOutBuffer[1] = hexchars[sigval >> 4];
|
||||
remcomOutBuffer[2] = hexchars[sigval % 16];
|
||||
remcomOutBuffer[3] = 0;
|
||||
|
||||
putpacket(remcomOutBuffer);
|
||||
putpacket (remcomOutBuffer);
|
||||
|
||||
stepping = 0;
|
||||
|
||||
while (1==1) {
|
||||
remcomOutBuffer[0] = 0;
|
||||
ptr = getpacket();
|
||||
while (1 == 1)
|
||||
{
|
||||
remcomOutBuffer[0] = 0;
|
||||
ptr = getpacket ();
|
||||
|
||||
switch (*ptr++) {
|
||||
case '?' : remcomOutBuffer[0] = 'S';
|
||||
remcomOutBuffer[1] = hexchars[sigval >> 4];
|
||||
remcomOutBuffer[2] = hexchars[sigval % 16];
|
||||
remcomOutBuffer[3] = 0;
|
||||
break;
|
||||
case 'd' : remote_debug = !(remote_debug); /* toggle debug flag */
|
||||
break;
|
||||
case 'g' : /* return the value of the CPU registers */
|
||||
mem2hex((char*) registers, remcomOutBuffer, NUMREGBYTES, 0);
|
||||
break;
|
||||
case 'G' : /* set the value of the CPU registers - return OK */
|
||||
hex2mem(ptr, (char*) registers, NUMREGBYTES, 0);
|
||||
strcpy(remcomOutBuffer,"OK");
|
||||
break;
|
||||
case 'P' : /* set the value of a single CPU register - return OK */
|
||||
{
|
||||
int regno;
|
||||
switch (*ptr++)
|
||||
{
|
||||
case '?':
|
||||
remcomOutBuffer[0] = 'S';
|
||||
remcomOutBuffer[1] = hexchars[sigval >> 4];
|
||||
remcomOutBuffer[2] = hexchars[sigval % 16];
|
||||
remcomOutBuffer[3] = 0;
|
||||
break;
|
||||
case 'd':
|
||||
remote_debug = !(remote_debug); /* toggle debug flag */
|
||||
break;
|
||||
case 'g': /* return the value of the CPU registers */
|
||||
mem2hex ((char *) registers, remcomOutBuffer, NUMREGBYTES, 0);
|
||||
break;
|
||||
case 'G': /* set the value of the CPU registers - return OK */
|
||||
hex2mem (ptr, (char *) registers, NUMREGBYTES, 0);
|
||||
strcpy (remcomOutBuffer, "OK");
|
||||
break;
|
||||
case 'P': /* set the value of a single CPU register - return OK */
|
||||
{
|
||||
int regno;
|
||||
|
||||
if (hexToInt (&ptr, ®no) && *ptr++ == '=')
|
||||
if (regno >= 0 && regno < NUMREGS)
|
||||
{
|
||||
hex2mem (ptr, (char *)®isters[regno], 4, 0);
|
||||
strcpy(remcomOutBuffer,"OK");
|
||||
break;
|
||||
}
|
||||
if (hexToInt (&ptr, ®no) && *ptr++ == '=')
|
||||
if (regno >= 0 && regno < NUMREGS)
|
||||
{
|
||||
hex2mem (ptr, (char *) ®isters[regno], 4, 0);
|
||||
strcpy (remcomOutBuffer, "OK");
|
||||
break;
|
||||
}
|
||||
|
||||
strcpy (remcomOutBuffer, "E01");
|
||||
break;
|
||||
}
|
||||
strcpy (remcomOutBuffer, "E01");
|
||||
break;
|
||||
}
|
||||
|
||||
/* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
|
||||
case 'm' :
|
||||
/* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
|
||||
if (hexToInt(&ptr,&addr))
|
||||
if (*(ptr++) == ',')
|
||||
if (hexToInt(&ptr,&length))
|
||||
{
|
||||
ptr = 0;
|
||||
mem_err = 0;
|
||||
mem2hex((char*) addr, remcomOutBuffer, length, 1);
|
||||
if (mem_err) {
|
||||
strcpy (remcomOutBuffer, "E03");
|
||||
debug_error ("memory fault");
|
||||
}
|
||||
}
|
||||
|
||||
if (ptr)
|
||||
{
|
||||
strcpy(remcomOutBuffer,"E01");
|
||||
/* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
|
||||
case 'm':
|
||||
/* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
|
||||
if (hexToInt (&ptr, &addr))
|
||||
if (*(ptr++) == ',')
|
||||
if (hexToInt (&ptr, &length))
|
||||
{
|
||||
ptr = 0;
|
||||
mem_err = 0;
|
||||
mem2hex ((char *) addr, remcomOutBuffer, length, 1);
|
||||
if (mem_err)
|
||||
{
|
||||
strcpy (remcomOutBuffer, "E03");
|
||||
debug_error ("memory fault");
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
/* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
|
||||
case 'M' :
|
||||
/* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
|
||||
if (hexToInt(&ptr,&addr))
|
||||
if (*(ptr++) == ',')
|
||||
if (hexToInt(&ptr,&length))
|
||||
if (*(ptr++) == ':')
|
||||
{
|
||||
mem_err = 0;
|
||||
hex2mem(ptr, (char*) addr, length, 1);
|
||||
if (ptr)
|
||||
{
|
||||
strcpy (remcomOutBuffer, "E01");
|
||||
}
|
||||
break;
|
||||
|
||||
if (mem_err) {
|
||||
strcpy (remcomOutBuffer, "E03");
|
||||
debug_error ("memory fault");
|
||||
} else {
|
||||
strcpy(remcomOutBuffer,"OK");
|
||||
}
|
||||
/* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
|
||||
case 'M':
|
||||
/* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
|
||||
if (hexToInt (&ptr, &addr))
|
||||
if (*(ptr++) == ',')
|
||||
if (hexToInt (&ptr, &length))
|
||||
if (*(ptr++) == ':')
|
||||
{
|
||||
mem_err = 0;
|
||||
hex2mem (ptr, (char *) addr, length, 1);
|
||||
|
||||
ptr = 0;
|
||||
}
|
||||
if (ptr)
|
||||
{
|
||||
strcpy(remcomOutBuffer,"E02");
|
||||
}
|
||||
break;
|
||||
if (mem_err)
|
||||
{
|
||||
strcpy (remcomOutBuffer, "E03");
|
||||
debug_error ("memory fault");
|
||||
}
|
||||
else
|
||||
{
|
||||
strcpy (remcomOutBuffer, "OK");
|
||||
}
|
||||
|
||||
/* cAA..AA Continue at address AA..AA(optional) */
|
||||
/* sAA..AA Step one instruction from AA..AA(optional) */
|
||||
case 's' :
|
||||
stepping = 1;
|
||||
case 'c' :
|
||||
/* try to read optional parameter, pc unchanged if no parm */
|
||||
if (hexToInt(&ptr,&addr))
|
||||
registers[ PC ] = addr;
|
||||
ptr = 0;
|
||||
}
|
||||
if (ptr)
|
||||
{
|
||||
strcpy (remcomOutBuffer, "E02");
|
||||
}
|
||||
break;
|
||||
|
||||
newPC = registers[ PC];
|
||||
/* cAA..AA Continue at address AA..AA(optional) */
|
||||
/* sAA..AA Step one instruction from AA..AA(optional) */
|
||||
case 's':
|
||||
stepping = 1;
|
||||
case 'c':
|
||||
/* try to read optional parameter, pc unchanged if no parm */
|
||||
if (hexToInt (&ptr, &addr))
|
||||
registers[PC] = addr;
|
||||
|
||||
/* clear the trace bit */
|
||||
registers[ PS ] &= 0xfffffeff;
|
||||
newPC = registers[PC];
|
||||
|
||||
/* set the trace bit if we're stepping */
|
||||
if (stepping) registers[ PS ] |= 0x100;
|
||||
/* clear the trace bit */
|
||||
registers[PS] &= 0xfffffeff;
|
||||
|
||||
_returnFromException(); /* this is a jump */
|
||||
break;
|
||||
/* set the trace bit if we're stepping */
|
||||
if (stepping)
|
||||
registers[PS] |= 0x100;
|
||||
|
||||
/* kill the program */
|
||||
case 'k' : /* do nothing */
|
||||
_returnFromException (); /* this is a jump */
|
||||
break;
|
||||
|
||||
/* kill the program */
|
||||
case 'k': /* do nothing */
|
||||
#if 0
|
||||
/* Huh? This doesn't look like "nothing".
|
||||
m68k-stub.c and sparc-stub.c don't have it. */
|
||||
BREAKPOINT();
|
||||
/* Huh? This doesn't look like "nothing".
|
||||
m68k-stub.c and sparc-stub.c don't have it. */
|
||||
BREAKPOINT ();
|
||||
#endif
|
||||
break;
|
||||
} /* switch */
|
||||
break;
|
||||
} /* switch */
|
||||
|
||||
/* reply to the request */
|
||||
putpacket(remcomOutBuffer);
|
||||
/* reply to the request */
|
||||
putpacket (remcomOutBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
/* this function is used to set up exception handlers for tracing and
|
||||
breakpoints */
|
||||
void set_debug_traps()
|
||||
void
|
||||
set_debug_traps (void)
|
||||
{
|
||||
extern void remcomHandler();
|
||||
int exception;
|
||||
|
||||
stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];
|
||||
stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
|
||||
|
||||
exceptionHandler (0, _catchException0);
|
||||
exceptionHandler (1, _catchException1);
|
||||
|
@ -871,8 +925,9 @@ int exception;
|
|||
otherwise as a quick means to stop program execution and "break" into
|
||||
the debugger. */
|
||||
|
||||
void breakpoint()
|
||||
void
|
||||
breakpoint (void)
|
||||
{
|
||||
if (initialized)
|
||||
BREAKPOINT();
|
||||
BREAKPOINT ();
|
||||
}
|
||||
|
|
772
gdb/m68k-stub.c
772
gdb/m68k-stub.c
|
@ -477,48 +477,53 @@ asm(" movel d0,sp@-"); /* push exception onto stack */
|
|||
asm(" jbsr _handle_exception"); /* this never returns */
|
||||
asm(" rts"); /* return */
|
||||
|
||||
void _returnFromException( Frame *frame )
|
||||
void
|
||||
_returnFromException (Frame * frame)
|
||||
{
|
||||
/* if no passed in frame, use the last one */
|
||||
if (! frame)
|
||||
/* if no passed in frame, use the last one */
|
||||
if (!frame)
|
||||
{
|
||||
frame = lastFrame;
|
||||
frame->frameSize = 4;
|
||||
frame->format = 0;
|
||||
frame->fsaveHeader = -1; /* restore regs, but we dont have fsave info*/
|
||||
frame = lastFrame;
|
||||
frame->frameSize = 4;
|
||||
frame->format = 0;
|
||||
frame->fsaveHeader = -1; /* restore regs, but we dont have fsave info */
|
||||
}
|
||||
|
||||
#if !defined (mc68020) && !defined (mc68332)
|
||||
/* a 68000 cannot use the internal info pushed onto a bus error
|
||||
* or address error frame when doing an RTE so don't put this info
|
||||
* onto the stack or the stack will creep every time this happens.
|
||||
*/
|
||||
frame->frameSize=3;
|
||||
/* a 68000 cannot use the internal info pushed onto a bus error
|
||||
* or address error frame when doing an RTE so don't put this info
|
||||
* onto the stack or the stack will creep every time this happens.
|
||||
*/
|
||||
frame->frameSize = 3;
|
||||
#endif
|
||||
|
||||
/* throw away any frames in the list after this frame */
|
||||
lastFrame = frame;
|
||||
/* throw away any frames in the list after this frame */
|
||||
lastFrame = frame;
|
||||
|
||||
frame->sr = registers[(int) PS];
|
||||
frame->pc = registers[(int) PC];
|
||||
frame->sr = registers[(int) PS];
|
||||
frame->pc = registers[(int) PC];
|
||||
|
||||
if (registers[(int) PS] & 0x2000)
|
||||
{
|
||||
/* return to supervisor mode... */
|
||||
return_to_super();
|
||||
if (registers[(int) PS] & 0x2000)
|
||||
{
|
||||
/* return to supervisor mode... */
|
||||
return_to_super ();
|
||||
}
|
||||
else
|
||||
{ /* return to user mode */
|
||||
return_to_user();
|
||||
else
|
||||
{ /* return to user mode */
|
||||
return_to_user ();
|
||||
}
|
||||
}
|
||||
|
||||
int hex(ch)
|
||||
char ch;
|
||||
int
|
||||
hex (ch)
|
||||
char ch;
|
||||
{
|
||||
if ((ch >= 'a') && (ch <= 'f')) return (ch-'a'+10);
|
||||
if ((ch >= '0') && (ch <= '9')) return (ch-'0');
|
||||
if ((ch >= 'A') && (ch <= 'F')) return (ch-'A'+10);
|
||||
if ((ch >= 'a') && (ch <= 'f'))
|
||||
return (ch - 'a' + 10);
|
||||
if ((ch >= '0') && (ch <= '9'))
|
||||
return (ch - '0');
|
||||
if ((ch >= 'A') && (ch <= 'F'))
|
||||
return (ch - 'A' + 10);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
|
@ -526,7 +531,7 @@ static char remcomInBuffer[BUFMAX];
|
|||
static char remcomOutBuffer[BUFMAX];
|
||||
|
||||
/* scan for the sequence $<data>#<checksum> */
|
||||
|
||||
|
||||
unsigned char *
|
||||
getpacket (void)
|
||||
{
|
||||
|
@ -542,7 +547,7 @@ getpacket (void)
|
|||
while ((ch = getDebugChar ()) != '$')
|
||||
;
|
||||
|
||||
retry:
|
||||
retry:
|
||||
checksum = 0;
|
||||
xmitcsum = -1;
|
||||
count = 0;
|
||||
|
@ -552,7 +557,7 @@ retry:
|
|||
{
|
||||
ch = getDebugChar ();
|
||||
if (ch == '$')
|
||||
goto retry;
|
||||
goto retry;
|
||||
if (ch == '#')
|
||||
break;
|
||||
checksum = checksum + ch;
|
||||
|
@ -573,7 +578,7 @@ retry:
|
|||
if (remote_debug)
|
||||
{
|
||||
fprintf (stderr,
|
||||
"bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
|
||||
"bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
|
||||
checksum, xmitcsum, buffer);
|
||||
}
|
||||
putDebugChar ('-'); /* failed checksum */
|
||||
|
@ -599,125 +604,179 @@ retry:
|
|||
|
||||
/* send the packet in buffer. */
|
||||
|
||||
|
||||
void putpacket(buffer)
|
||||
char * buffer;
|
||||
void
|
||||
putpacket (buffer)
|
||||
char *buffer;
|
||||
{
|
||||
unsigned char checksum;
|
||||
int count;
|
||||
int count;
|
||||
char ch;
|
||||
|
||||
/* $<packet info>#<checksum>. */
|
||||
do {
|
||||
putDebugChar('$');
|
||||
checksum = 0;
|
||||
count = 0;
|
||||
|
||||
while (ch=buffer[count]) {
|
||||
putDebugChar(ch);
|
||||
checksum += ch;
|
||||
count += 1;
|
||||
}
|
||||
|
||||
putDebugChar('#');
|
||||
putDebugChar(hexchars[checksum >> 4]);
|
||||
putDebugChar(hexchars[checksum % 16]);
|
||||
|
||||
} while (getDebugChar() != '+');
|
||||
|
||||
/* $<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 () != '+');
|
||||
|
||||
}
|
||||
|
||||
void debug_error(format, parm)
|
||||
char * format;
|
||||
char * parm;
|
||||
void
|
||||
debug_error (format, parm)
|
||||
char *format;
|
||||
char *parm;
|
||||
{
|
||||
if (remote_debug) fprintf (stderr,format,parm);
|
||||
if (remote_debug)
|
||||
fprintf (stderr, format, parm);
|
||||
}
|
||||
|
||||
/* convert the memory pointed to by mem into hex, placing result in buf */
|
||||
/* return a pointer to the last char put in buf (null) */
|
||||
char* mem2hex(mem, buf, count)
|
||||
char* mem;
|
||||
char* buf;
|
||||
int count;
|
||||
char *
|
||||
mem2hex (mem, buf, count)
|
||||
char *mem;
|
||||
char *buf;
|
||||
int count;
|
||||
{
|
||||
int i;
|
||||
unsigned char ch;
|
||||
for (i=0;i<count;i++) {
|
||||
ch = *mem++;
|
||||
*buf++ = hexchars[ch >> 4];
|
||||
*buf++ = hexchars[ch % 16];
|
||||
}
|
||||
*buf = 0;
|
||||
return(buf);
|
||||
int i;
|
||||
unsigned char ch;
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
ch = *mem++;
|
||||
*buf++ = hexchars[ch >> 4];
|
||||
*buf++ = hexchars[ch % 16];
|
||||
}
|
||||
*buf = 0;
|
||||
return (buf);
|
||||
}
|
||||
|
||||
/* convert the hex array pointed to by buf into binary to be placed in mem */
|
||||
/* return a pointer to the character AFTER the last byte written */
|
||||
char* hex2mem(buf, mem, count)
|
||||
char* buf;
|
||||
char* mem;
|
||||
int count;
|
||||
char *
|
||||
hex2mem (buf, mem, count)
|
||||
char *buf;
|
||||
char *mem;
|
||||
int count;
|
||||
{
|
||||
int i;
|
||||
unsigned char ch;
|
||||
for (i=0;i<count;i++) {
|
||||
ch = hex(*buf++) << 4;
|
||||
ch = ch + hex(*buf++);
|
||||
*mem++ = ch;
|
||||
}
|
||||
return(mem);
|
||||
int i;
|
||||
unsigned char ch;
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
ch = hex (*buf++) << 4;
|
||||
ch = ch + hex (*buf++);
|
||||
*mem++ = ch;
|
||||
}
|
||||
return (mem);
|
||||
}
|
||||
|
||||
/* a bus error has occurred, perform a longjmp
|
||||
to return execution and allow handling of the error */
|
||||
|
||||
void handle_buserror()
|
||||
void
|
||||
handle_buserror ()
|
||||
{
|
||||
longjmp(remcomEnv,1);
|
||||
longjmp (remcomEnv, 1);
|
||||
}
|
||||
|
||||
/* this function takes the 68000 exception number and attempts to
|
||||
translate this number into a unix compatible signal value */
|
||||
int computeSignal( exceptionVector )
|
||||
int exceptionVector;
|
||||
int
|
||||
computeSignal (exceptionVector)
|
||||
int exceptionVector;
|
||||
{
|
||||
int sigval;
|
||||
switch (exceptionVector) {
|
||||
case 2 : sigval = 10; break; /* bus error */
|
||||
case 3 : sigval = 10; break; /* address error */
|
||||
case 4 : sigval = 4; break; /* illegal instruction */
|
||||
case 5 : sigval = 8; break; /* zero divide */
|
||||
case 6 : sigval = 8; break; /* chk instruction */
|
||||
case 7 : sigval = 8; break; /* trapv instruction */
|
||||
case 8 : sigval = 11; break; /* privilege violation */
|
||||
case 9 : sigval = 5; break; /* trace trap */
|
||||
case 10: sigval = 4; break; /* line 1010 emulator */
|
||||
case 11: sigval = 4; break; /* line 1111 emulator */
|
||||
switch (exceptionVector)
|
||||
{
|
||||
case 2:
|
||||
sigval = 10;
|
||||
break; /* bus error */
|
||||
case 3:
|
||||
sigval = 10;
|
||||
break; /* address error */
|
||||
case 4:
|
||||
sigval = 4;
|
||||
break; /* illegal instruction */
|
||||
case 5:
|
||||
sigval = 8;
|
||||
break; /* zero divide */
|
||||
case 6:
|
||||
sigval = 8;
|
||||
break; /* chk instruction */
|
||||
case 7:
|
||||
sigval = 8;
|
||||
break; /* trapv instruction */
|
||||
case 8:
|
||||
sigval = 11;
|
||||
break; /* privilege violation */
|
||||
case 9:
|
||||
sigval = 5;
|
||||
break; /* trace trap */
|
||||
case 10:
|
||||
sigval = 4;
|
||||
break; /* line 1010 emulator */
|
||||
case 11:
|
||||
sigval = 4;
|
||||
break; /* line 1111 emulator */
|
||||
|
||||
/* Coprocessor protocol violation. Using a standard MMU or FPU
|
||||
this cannot be triggered by software. Call it a SIGBUS. */
|
||||
case 13: sigval = 10; break;
|
||||
this cannot be triggered by software. Call it a SIGBUS. */
|
||||
case 13:
|
||||
sigval = 10;
|
||||
break;
|
||||
|
||||
case 31: sigval = 2; break; /* interrupt */
|
||||
case 33: sigval = 5; break; /* breakpoint */
|
||||
case 31:
|
||||
sigval = 2;
|
||||
break; /* interrupt */
|
||||
case 33:
|
||||
sigval = 5;
|
||||
break; /* breakpoint */
|
||||
|
||||
/* This is a trap #8 instruction. Apparently it is someone's software
|
||||
convention for some sort of SIGFPE condition. Whose? How many
|
||||
people are being screwed by having this code the way it is?
|
||||
Is there a clean solution? */
|
||||
case 40: sigval = 8; break; /* floating point err */
|
||||
convention for some sort of SIGFPE condition. Whose? How many
|
||||
people are being screwed by having this code the way it is?
|
||||
Is there a clean solution? */
|
||||
case 40:
|
||||
sigval = 8;
|
||||
break; /* floating point err */
|
||||
|
||||
case 48: sigval = 8; break; /* floating point err */
|
||||
case 49: sigval = 8; break; /* floating point err */
|
||||
case 50: sigval = 8; break; /* zero divide */
|
||||
case 51: sigval = 8; break; /* underflow */
|
||||
case 52: sigval = 8; break; /* operand error */
|
||||
case 53: sigval = 8; break; /* overflow */
|
||||
case 54: sigval = 8; break; /* NAN */
|
||||
default:
|
||||
sigval = 7; /* "software generated"*/
|
||||
}
|
||||
case 48:
|
||||
sigval = 8;
|
||||
break; /* floating point err */
|
||||
case 49:
|
||||
sigval = 8;
|
||||
break; /* floating point err */
|
||||
case 50:
|
||||
sigval = 8;
|
||||
break; /* zero divide */
|
||||
case 51:
|
||||
sigval = 8;
|
||||
break; /* underflow */
|
||||
case 52:
|
||||
sigval = 8;
|
||||
break; /* operand error */
|
||||
case 53:
|
||||
sigval = 8;
|
||||
break; /* overflow */
|
||||
case 54:
|
||||
sigval = 8;
|
||||
break; /* NAN */
|
||||
default:
|
||||
sigval = 7; /* "software generated" */
|
||||
}
|
||||
return (sigval);
|
||||
}
|
||||
|
||||
|
@ -725,242 +784,255 @@ int exceptionVector;
|
|||
/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
|
||||
/* RETURN NUMBER OF CHARS PROCESSED */
|
||||
/**********************************************/
|
||||
int hexToInt(char **ptr, int *intValue)
|
||||
int
|
||||
hexToInt (char **ptr, int *intValue)
|
||||
{
|
||||
int numChars = 0;
|
||||
int hexValue;
|
||||
|
||||
*intValue = 0;
|
||||
int numChars = 0;
|
||||
int hexValue;
|
||||
|
||||
while (**ptr)
|
||||
*intValue = 0;
|
||||
|
||||
while (**ptr)
|
||||
{
|
||||
hexValue = hex(**ptr);
|
||||
if (hexValue >=0)
|
||||
{
|
||||
*intValue = (*intValue <<4) | hexValue;
|
||||
numChars ++;
|
||||
}
|
||||
else
|
||||
break;
|
||||
|
||||
(*ptr)++;
|
||||
hexValue = hex (**ptr);
|
||||
if (hexValue >= 0)
|
||||
{
|
||||
*intValue = (*intValue << 4) | hexValue;
|
||||
numChars++;
|
||||
}
|
||||
else
|
||||
break;
|
||||
|
||||
(*ptr)++;
|
||||
}
|
||||
|
||||
return (numChars);
|
||||
return (numChars);
|
||||
}
|
||||
|
||||
/*
|
||||
* This function does all command procesing for interfacing to gdb.
|
||||
*/
|
||||
void handle_exception(int exceptionVector)
|
||||
void
|
||||
handle_exception (int exceptionVector)
|
||||
{
|
||||
int sigval, stepping;
|
||||
int addr, length;
|
||||
char * ptr;
|
||||
int newPC;
|
||||
Frame *frame;
|
||||
|
||||
if (remote_debug) printf("vector=%d, sr=0x%x, pc=0x%x\n",
|
||||
exceptionVector,
|
||||
registers[ PS ],
|
||||
registers[ PC ]);
|
||||
int sigval, stepping;
|
||||
int addr, length;
|
||||
char *ptr;
|
||||
int newPC;
|
||||
Frame *frame;
|
||||
|
||||
if (remote_debug)
|
||||
printf ("vector=%d, sr=0x%x, pc=0x%x\n",
|
||||
exceptionVector, registers[PS], registers[PC]);
|
||||
|
||||
/* reply to host that an exception has occurred */
|
||||
sigval = computeSignal( exceptionVector );
|
||||
sigval = computeSignal (exceptionVector);
|
||||
remcomOutBuffer[0] = 'S';
|
||||
remcomOutBuffer[1] = hexchars[sigval >> 4];
|
||||
remcomOutBuffer[2] = hexchars[sigval % 16];
|
||||
remcomOutBuffer[1] = hexchars[sigval >> 4];
|
||||
remcomOutBuffer[2] = hexchars[sigval % 16];
|
||||
remcomOutBuffer[3] = 0;
|
||||
|
||||
putpacket(remcomOutBuffer);
|
||||
putpacket (remcomOutBuffer);
|
||||
|
||||
stepping = 0;
|
||||
|
||||
while (1==1) {
|
||||
remcomOutBuffer[0] = 0;
|
||||
ptr = getpacket();
|
||||
switch (*ptr++) {
|
||||
case '?' : remcomOutBuffer[0] = 'S';
|
||||
remcomOutBuffer[1] = hexchars[sigval >> 4];
|
||||
remcomOutBuffer[2] = hexchars[sigval % 16];
|
||||
remcomOutBuffer[3] = 0;
|
||||
break;
|
||||
case 'd' : remote_debug = !(remote_debug); /* toggle debug flag */
|
||||
break;
|
||||
case 'g' : /* return the value of the CPU registers */
|
||||
mem2hex((char*) registers, remcomOutBuffer, NUMREGBYTES);
|
||||
break;
|
||||
case 'G' : /* set the value of the CPU registers - return OK */
|
||||
hex2mem(ptr, (char*) registers, NUMREGBYTES);
|
||||
strcpy(remcomOutBuffer,"OK");
|
||||
break;
|
||||
|
||||
/* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
|
||||
case 'm' :
|
||||
if (setjmp(remcomEnv) == 0)
|
||||
{
|
||||
exceptionHandler(2,handle_buserror);
|
||||
while (1 == 1)
|
||||
{
|
||||
remcomOutBuffer[0] = 0;
|
||||
ptr = getpacket ();
|
||||
switch (*ptr++)
|
||||
{
|
||||
case '?':
|
||||
remcomOutBuffer[0] = 'S';
|
||||
remcomOutBuffer[1] = hexchars[sigval >> 4];
|
||||
remcomOutBuffer[2] = hexchars[sigval % 16];
|
||||
remcomOutBuffer[3] = 0;
|
||||
break;
|
||||
case 'd':
|
||||
remote_debug = !(remote_debug); /* toggle debug flag */
|
||||
break;
|
||||
case 'g': /* return the value of the CPU registers */
|
||||
mem2hex ((char *) registers, remcomOutBuffer, NUMREGBYTES);
|
||||
break;
|
||||
case 'G': /* set the value of the CPU registers - return OK */
|
||||
hex2mem (ptr, (char *) registers, NUMREGBYTES);
|
||||
strcpy (remcomOutBuffer, "OK");
|
||||
break;
|
||||
|
||||
/* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
|
||||
if (hexToInt(&ptr,&addr))
|
||||
if (*(ptr++) == ',')
|
||||
if (hexToInt(&ptr,&length))
|
||||
{
|
||||
ptr = 0;
|
||||
mem2hex((char*) addr, remcomOutBuffer, length);
|
||||
}
|
||||
/* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
|
||||
case 'm':
|
||||
if (setjmp (remcomEnv) == 0)
|
||||
{
|
||||
exceptionHandler (2, handle_buserror);
|
||||
|
||||
if (ptr)
|
||||
{
|
||||
strcpy(remcomOutBuffer,"E01");
|
||||
}
|
||||
} else {
|
||||
exceptionHandler(2,_catchException);
|
||||
strcpy(remcomOutBuffer,"E03");
|
||||
debug_error("bus error");
|
||||
}
|
||||
|
||||
/* restore handler for bus error */
|
||||
exceptionHandler(2,_catchException);
|
||||
/* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
|
||||
if (hexToInt (&ptr, &addr))
|
||||
if (*(ptr++) == ',')
|
||||
if (hexToInt (&ptr, &length))
|
||||
{
|
||||
ptr = 0;
|
||||
mem2hex ((char *) addr, remcomOutBuffer, length);
|
||||
}
|
||||
|
||||
if (ptr)
|
||||
{
|
||||
strcpy (remcomOutBuffer, "E01");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
exceptionHandler (2, _catchException);
|
||||
strcpy (remcomOutBuffer, "E03");
|
||||
debug_error ("bus error");
|
||||
}
|
||||
|
||||
/* restore handler for bus error */
|
||||
exceptionHandler (2, _catchException);
|
||||
break;
|
||||
|
||||
/* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
|
||||
case 'M':
|
||||
if (setjmp (remcomEnv) == 0)
|
||||
{
|
||||
exceptionHandler (2, handle_buserror);
|
||||
|
||||
/* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
|
||||
if (hexToInt (&ptr, &addr))
|
||||
if (*(ptr++) == ',')
|
||||
if (hexToInt (&ptr, &length))
|
||||
if (*(ptr++) == ':')
|
||||
{
|
||||
hex2mem (ptr, (char *) addr, length);
|
||||
ptr = 0;
|
||||
strcpy (remcomOutBuffer, "OK");
|
||||
}
|
||||
if (ptr)
|
||||
{
|
||||
strcpy (remcomOutBuffer, "E02");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
exceptionHandler (2, _catchException);
|
||||
strcpy (remcomOutBuffer, "E03");
|
||||
debug_error ("bus error");
|
||||
}
|
||||
|
||||
/* restore handler for bus error */
|
||||
exceptionHandler (2, _catchException);
|
||||
break;
|
||||
|
||||
/* cAA..AA Continue at address AA..AA(optional) */
|
||||
/* sAA..AA Step one instruction from AA..AA(optional) */
|
||||
case 's':
|
||||
stepping = 1;
|
||||
case 'c':
|
||||
/* try to read optional parameter, pc unchanged if no parm */
|
||||
if (hexToInt (&ptr, &addr))
|
||||
registers[PC] = addr;
|
||||
|
||||
newPC = registers[PC];
|
||||
|
||||
/* clear the trace bit */
|
||||
registers[PS] &= 0x7fff;
|
||||
|
||||
/* set the trace bit if we're stepping */
|
||||
if (stepping)
|
||||
registers[PS] |= 0x8000;
|
||||
|
||||
/*
|
||||
* look for newPC in the linked list of exception frames.
|
||||
* if it is found, use the old frame it. otherwise,
|
||||
* fake up a dummy frame in returnFromException().
|
||||
*/
|
||||
if (remote_debug)
|
||||
printf ("new pc = 0x%x\n", newPC);
|
||||
frame = lastFrame;
|
||||
while (frame)
|
||||
{
|
||||
if (remote_debug)
|
||||
printf ("frame at 0x%x has pc=0x%x, except#=%d\n",
|
||||
frame, frame->exceptionPC, frame->exceptionVector);
|
||||
if (frame->exceptionPC == newPC)
|
||||
break; /* bingo! a match */
|
||||
/*
|
||||
* for a breakpoint instruction, the saved pc may
|
||||
* be off by two due to re-executing the instruction
|
||||
* replaced by the trap instruction. Check for this.
|
||||
*/
|
||||
if ((frame->exceptionVector == 33) &&
|
||||
(frame->exceptionPC == (newPC + 2)))
|
||||
break;
|
||||
|
||||
/* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
|
||||
case 'M' :
|
||||
if (setjmp(remcomEnv) == 0) {
|
||||
exceptionHandler(2,handle_buserror);
|
||||
|
||||
/* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
|
||||
if (hexToInt(&ptr,&addr))
|
||||
if (*(ptr++) == ',')
|
||||
if (hexToInt(&ptr,&length))
|
||||
if (*(ptr++) == ':')
|
||||
{
|
||||
hex2mem(ptr, (char*) addr, length);
|
||||
ptr = 0;
|
||||
strcpy(remcomOutBuffer,"OK");
|
||||
}
|
||||
if (ptr)
|
||||
{
|
||||
strcpy(remcomOutBuffer,"E02");
|
||||
}
|
||||
} else {
|
||||
exceptionHandler(2,_catchException);
|
||||
strcpy(remcomOutBuffer,"E03");
|
||||
debug_error("bus error");
|
||||
}
|
||||
|
||||
/* restore handler for bus error */
|
||||
exceptionHandler(2,_catchException);
|
||||
break;
|
||||
|
||||
/* cAA..AA Continue at address AA..AA(optional) */
|
||||
/* sAA..AA Step one instruction from AA..AA(optional) */
|
||||
case 's' :
|
||||
stepping = 1;
|
||||
case 'c' :
|
||||
/* try to read optional parameter, pc unchanged if no parm */
|
||||
if (hexToInt(&ptr,&addr))
|
||||
registers[ PC ] = addr;
|
||||
|
||||
newPC = registers[ PC];
|
||||
|
||||
/* clear the trace bit */
|
||||
registers[ PS ] &= 0x7fff;
|
||||
|
||||
/* set the trace bit if we're stepping */
|
||||
if (stepping) registers[ PS ] |= 0x8000;
|
||||
|
||||
/*
|
||||
* look for newPC in the linked list of exception frames.
|
||||
* if it is found, use the old frame it. otherwise,
|
||||
* fake up a dummy frame in returnFromException().
|
||||
*/
|
||||
if (remote_debug) printf("new pc = 0x%x\n",newPC);
|
||||
frame = lastFrame;
|
||||
while (frame)
|
||||
{
|
||||
if (remote_debug)
|
||||
printf("frame at 0x%x has pc=0x%x, except#=%d\n",
|
||||
frame,frame->exceptionPC,
|
||||
frame->exceptionVector);
|
||||
if (frame->exceptionPC == newPC) break; /* bingo! a match */
|
||||
/*
|
||||
* for a breakpoint instruction, the saved pc may
|
||||
* be off by two due to re-executing the instruction
|
||||
* replaced by the trap instruction. Check for this.
|
||||
*/
|
||||
if ((frame->exceptionVector == 33) &&
|
||||
(frame->exceptionPC == (newPC+2))) break;
|
||||
if (frame == frame->previous)
|
||||
{
|
||||
frame = 0; /* no match found */
|
||||
break;
|
||||
}
|
||||
if (frame == frame->previous)
|
||||
{
|
||||
frame = 0; /* no match found */
|
||||
break;
|
||||
}
|
||||
frame = frame->previous;
|
||||
}
|
||||
|
||||
/*
|
||||
* If we found a match for the PC AND we are not returning
|
||||
* as a result of a breakpoint (33),
|
||||
* trace exception (9), nmi (31), jmp to
|
||||
* the old exception handler as if this code never ran.
|
||||
*/
|
||||
if (frame)
|
||||
{
|
||||
if ((frame->exceptionVector != 9) &&
|
||||
(frame->exceptionVector != 31) &&
|
||||
(frame->exceptionVector != 33))
|
||||
{
|
||||
/*
|
||||
* invoke the previous handler.
|
||||
*/
|
||||
if (oldExceptionHook)
|
||||
(*oldExceptionHook) (frame->exceptionVector);
|
||||
newPC = registers[ PC ]; /* pc may have changed */
|
||||
if (newPC != frame->exceptionPC)
|
||||
{
|
||||
if (remote_debug)
|
||||
printf("frame at 0x%x has pc=0x%x, except#=%d\n",
|
||||
frame,frame->exceptionPC,
|
||||
frame->exceptionVector);
|
||||
/* re-use the last frame, we're skipping it (longjump?)*/
|
||||
}
|
||||
|
||||
/*
|
||||
* If we found a match for the PC AND we are not returning
|
||||
* as a result of a breakpoint (33),
|
||||
* trace exception (9), nmi (31), jmp to
|
||||
* the old exception handler as if this code never ran.
|
||||
*/
|
||||
if (frame)
|
||||
{
|
||||
if ((frame->exceptionVector != 9) &&
|
||||
(frame->exceptionVector != 31) &&
|
||||
(frame->exceptionVector != 33))
|
||||
{
|
||||
/*
|
||||
* invoke the previous handler.
|
||||
*/
|
||||
if (oldExceptionHook)
|
||||
(*oldExceptionHook) (frame->exceptionVector);
|
||||
newPC = registers[PC]; /* pc may have changed */
|
||||
if (newPC != frame->exceptionPC)
|
||||
{
|
||||
if (remote_debug)
|
||||
printf ("frame at 0x%x has pc=0x%x, except#=%d\n",
|
||||
frame, frame->exceptionPC,
|
||||
frame->exceptionVector);
|
||||
/* re-use the last frame, we're skipping it (longjump?) */
|
||||
frame = (Frame *) 0;
|
||||
_returnFromException( frame ); /* this is a jump */
|
||||
}
|
||||
}
|
||||
}
|
||||
_returnFromException (frame); /* this is a jump */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* if we couldn't find a frame, create one */
|
||||
if (frame == 0)
|
||||
{
|
||||
frame = lastFrame - 1;
|
||||
|
||||
/* if we couldn't find a frame, create one */
|
||||
if (frame == 0)
|
||||
{
|
||||
frame = lastFrame -1 ;
|
||||
|
||||
/* by using a bunch of print commands with breakpoints,
|
||||
it's possible for the frame stack to creep down. If it creeps
|
||||
too far, give up and reset it to the top. Normal use should
|
||||
not see this happen.
|
||||
*/
|
||||
if ((unsigned int) (frame-2) < (unsigned int) &gdbFrameStack)
|
||||
{
|
||||
initializeRemcomErrorFrame();
|
||||
frame = lastFrame;
|
||||
}
|
||||
frame->previous = lastFrame;
|
||||
lastFrame = frame;
|
||||
frame = 0; /* null so _return... will properly initialize it */
|
||||
}
|
||||
|
||||
_returnFromException( frame ); /* this is a jump */
|
||||
it's possible for the frame stack to creep down. If it creeps
|
||||
too far, give up and reset it to the top. Normal use should
|
||||
not see this happen.
|
||||
*/
|
||||
if ((unsigned int) (frame - 2) < (unsigned int) &gdbFrameStack)
|
||||
{
|
||||
initializeRemcomErrorFrame ();
|
||||
frame = lastFrame;
|
||||
}
|
||||
frame->previous = lastFrame;
|
||||
lastFrame = frame;
|
||||
frame = 0; /* null so _return... will properly initialize it */
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
/* kill the program */
|
||||
case 'k' : /* do nothing */
|
||||
break;
|
||||
} /* switch */
|
||||
|
||||
/* reply to the request */
|
||||
putpacket(remcomOutBuffer);
|
||||
_returnFromException (frame); /* this is a jump */
|
||||
|
||||
break;
|
||||
|
||||
/* kill the program */
|
||||
case 'k': /* do nothing */
|
||||
break;
|
||||
} /* switch */
|
||||
|
||||
/* reply to the request */
|
||||
putpacket (remcomOutBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -968,46 +1040,47 @@ void handle_exception(int exceptionVector)
|
|||
void
|
||||
initializeRemcomErrorFrame (void)
|
||||
{
|
||||
lastFrame = ((Frame *) &gdbFrameStack[FRAMESIZE-1]) - 1;
|
||||
lastFrame->previous = lastFrame;
|
||||
lastFrame = ((Frame *) & gdbFrameStack[FRAMESIZE - 1]) - 1;
|
||||
lastFrame->previous = lastFrame;
|
||||
}
|
||||
|
||||
/* this function is used to set up exception handlers for tracing and
|
||||
breakpoints */
|
||||
void set_debug_traps()
|
||||
void
|
||||
set_debug_traps ()
|
||||
{
|
||||
extern void _debug_level7();
|
||||
extern void remcomHandler();
|
||||
extern void _debug_level7 ();
|
||||
extern void remcomHandler ();
|
||||
int exception;
|
||||
|
||||
initializeRemcomErrorFrame();
|
||||
stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];
|
||||
initializeRemcomErrorFrame ();
|
||||
stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
|
||||
|
||||
for (exception = 2; exception <= 23; exception++)
|
||||
exceptionHandler(exception,_catchException);
|
||||
exceptionHandler (exception, _catchException);
|
||||
|
||||
/* level 7 interrupt */
|
||||
exceptionHandler(31,_debug_level7);
|
||||
|
||||
exceptionHandler (31, _debug_level7);
|
||||
|
||||
/* breakpoint exception (trap #1) */
|
||||
exceptionHandler(33,_catchException);
|
||||
|
||||
exceptionHandler (33, _catchException);
|
||||
|
||||
/* This is a trap #8 instruction. Apparently it is someone's software
|
||||
convention for some sort of SIGFPE condition. Whose? How many
|
||||
people are being screwed by having this code the way it is?
|
||||
Is there a clean solution? */
|
||||
exceptionHandler(40,_catchException);
|
||||
|
||||
exceptionHandler (40, _catchException);
|
||||
|
||||
/* 48 to 54 are floating point coprocessor errors */
|
||||
for (exception = 48; exception <= 54; exception++)
|
||||
exceptionHandler(exception,_catchException);
|
||||
exceptionHandler (exception, _catchException);
|
||||
|
||||
if (oldExceptionHook != remcomHandler)
|
||||
{
|
||||
{
|
||||
oldExceptionHook = exceptionHook;
|
||||
exceptionHook = remcomHandler;
|
||||
}
|
||||
|
||||
exceptionHook = remcomHandler;
|
||||
}
|
||||
|
||||
initialized = 1;
|
||||
|
||||
}
|
||||
|
@ -1016,9 +1089,10 @@ void set_debug_traps()
|
|||
beginning of a program to sync up with a debugger and can be used
|
||||
otherwise as a quick means to stop program execution and "break" into
|
||||
the debugger. */
|
||||
|
||||
void breakpoint()
|
||||
{
|
||||
if (initialized) BREAKPOINT();
|
||||
}
|
||||
|
||||
void
|
||||
breakpoint ()
|
||||
{
|
||||
if (initialized)
|
||||
BREAKPOINT ();
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue