gdb/m68k-stub.c - Issue 11969036: Merge GDB 7.5.1

Unified Diff: gdb/m68k-stub.c

Issue 11969036: Merge GDB 7.5.1 (Closed) Base URL: http://git.chromium.org/native_client/nacl-gdb.git@master

Patch Set: Created 7 years, 11 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: gdb/m68k-stub.c

diff --git a/gdb/m68k-stub.c b/gdb/m68k-stub.c

deleted file mode 100644

index 4ef4069bc3dfab4ad7b740826c0be597fd064da3..0000000000000000000000000000000000000000

--- a/gdb/m68k-stub.c

+++ /dev/null

@@ -1,1098 +0,0 @@

-/****************************************************************************

- 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 $

- *

- * 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 breakpoint instruction

- * is hardwired to trap #1 because not to do so is a compatibility problem--

- * there either should be a standard breakpoint instruction, or the protocol

- * should be extended to provide some means to communicate which breakpoint

- * instruction is in use (or have the stub insert the breakpoint).

- *

- * Some explanation is probably necessary to explain how exceptions are

- * handled. When an exception is encountered the 68000 pushes the current

- * program counter and status register onto the supervisor stack and then

- * transfers execution to a location specified in it's vector table.

- * The handlers for the exception vectors are hardwired to jmp to an address

- * given by the relation: (exception - 256) * 6. These are decending

- * addresses starting from -6, -12, -18, ... By allowing 6 bytes for

- * each entry, a jsr, jmp, bsr, ... can be used to enter the exception

- * handler. Using a jsr to handle an exception has an added benefit of

- * allowing a single handler to service several exceptions and use the

- * return address as the key differentiation. The vector number can be

- * computed from the return address by [ exception = (addr + 1530) / 6 ].

- * The sole purpose of the routine _catchException is to compute the

- * exception number and push it on the stack in place of the return address.

- * The external function exceptionHandler() is

- * used to attach a specific handler to a specific m68k exception.

- * For 68020 machines, the ability to have a return address around just

- * so the vector can be determined is not necessary because the '020 pushes an

- * extra word onto the stack containing the vector offset

- *

- * 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

- *

- * 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

- *

- ****************************************************************************/

-#include <stdio.h>

-#include <string.h>

-#include <setjmp.h>

-/************************************************************************

- *

- * external low-level support routines

- */

-typedef void (*ExceptionHook)(int); /* pointer to function with int parm */

-typedef void (*Function)(); /* pointer to a function */

-extern void putDebugChar(); /* write a single character */

-extern int getDebugChar(); /* read and return a single char */

-extern Function exceptionHandler(); /* assign an exception handler */

-extern ExceptionHook exceptionHook; /* hook variable for errors/exceptions */

-/************************/

-/* FORWARD DECLARATIONS */

-/************************/

-static void

-initializeRemcomErrorFrame ();

-/************************************************************************/

-/* 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 char hexchars[]="0123456789abcdef";

-/* there are 180 bytes of registers on a 68020 w/68881 */

-/* many of the fpa registers are 12 byte (96 bit) registers */

-#define NUMREGBYTES 180

-enum regnames {D0,D1,D2,D3,D4,D5,D6,D7,

- A0,A1,A2,A3,A4,A5,A6,A7,

- PS,PC,

- FP0,FP1,FP2,FP3,FP4,FP5,FP6,FP7,

- FPCONTROL,FPSTATUS,FPIADDR

- };

-/* We keep a whole frame cache here. "Why?", I hear you cry, "doesn't

- GDB handle that sort of thing?" Well, yes, I believe the only

- reason for this cache is to save and restore floating point state

- (fsave/frestore). A cleaner way to do this would be to make the

- fsave data part of the registers which GDB deals with like any

- other registers. This should not be a performance problem if the

- ability to read individual registers is added to the protocol. */

-typedef struct FrameStruct

- struct FrameStruct *previous;

- int exceptionPC; /* pc value when this frame created */

- int exceptionVector; /* cpu vector causing exception */

- short frameSize; /* size of cpu frame in words */

- short sr; /* for 68000, this not always sr */

- int pc;

- short format;

- int fsaveHeader;

- int morejunk[0]; /* exception frame, fp save... */

-} Frame;

-#define FRAMESIZE 500

-int gdbFrameStack[FRAMESIZE];

-static Frame *lastFrame;

-/*

- * these should not be static cuz they can be used outside this module

- */

-int registers[NUMREGBYTES/4];

-int superStack;

-#define STACKSIZE 10000

-int remcomStack[STACKSIZE/sizeof(int)];

-static int* stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];

-/*

- * In many cases, the system will want to continue exception processing

- * when a continue command is given.

- * oldExceptionHook is a function to invoke in this case.

- */

-static ExceptionHook oldExceptionHook;

-#ifdef mc68020

-/* the size of the exception stack on the 68020 varies with the type of

- * exception. The following table is the number of WORDS used

- * for each exception format.

- */

-const short exceptionSize[] = { 4,4,6,4,4,4,4,4,29,10,16,46,12,4,4,4 };

-#endif

-#ifdef mc68332

-static const short exceptionSize[] = { 4,4,6,4,4,4,4,4,4,4,4,4,16,4,4,4 };

-#endif

-/************* jump buffer used for setjmp/longjmp **************************/

-jmp_buf remcomEnv;

-/*************************** ASSEMBLY CODE MACROS *************************/

-/* */

-#ifdef __HAVE_68881__

-/* do an fsave, then remember the address to begin a restore from */

-#define SAVE_FP_REGS() asm(" fsave a0@-"); \

- asm(" fmovemx fp0-fp7,_registers+72"); \

- asm(" fmoveml fpcr/fpsr/fpi,_registers+168");

-#define RESTORE_FP_REGS() \

-asm(" \n\

- fmoveml _registers+168,fpcr/fpsr/fpi \n\

- fmovemx _registers+72,fp0-fp7 \n\

- cmpl #-1,a0@ | skip frestore flag set ? \n\

- beq skip_frestore \n\

- frestore a0@+ \n\

-skip_frestore: \n\

-");

-#else

-#define SAVE_FP_REGS()

-#define RESTORE_FP_REGS()

-#endif /* __HAVE_68881__ */

-void return_to_super();

-void return_to_user();

-asm("

-.text

-.globl _return_to_super

-_return_to_super:

- movel _registers+60,sp /* get new stack pointer */

- movel _lastFrame,a0 /* get last frame info */

- bra return_to_any

-.globl _return_to_user

-_return_to_user:

- movel _registers+60,a0 /* get usp */

- movel a0,usp /* set usp */

- movel _superStack,sp /* get original stack pointer */

-return_to_any:

- movel _lastFrame,a0 /* get last frame info */

- movel a0@+,_lastFrame /* link in previous frame */

- addql #8,a0 /* skip over pc, vector#*/

- movew a0@+,d0 /* get # of words in cpu frame */

- addw d0,a0 /* point to end of data */

- movel a0,a1

-# copy the stack frame

- subql #1,d0

-copyUserLoop:

- movew a1@-,sp@-

- dbf d0,copyUserLoop

-");

- RESTORE_FP_REGS()

- asm(" moveml _registers,d0-d7/a0-a6");

- asm(" rte"); /* pop and go! */

-#define DISABLE_INTERRUPTS() asm(" oriw #0x0700,sr");

-#define BREAKPOINT() asm(" trap #1");

-/* this function is called immediately when a level 7 interrupt occurs */

-/* if the previous interrupt level was 7 then we're already servicing */

-/* this interrupt and an rte is in order to return to the debugger. */

-/* For the 68000, the offset for sr is 6 due to the jsr return address */

-asm("

-.text

-.globl __debug_level7

-__debug_level7:

- movew d0,sp@-");

-#if defined (mc68020) || defined (mc68332)

-asm(" movew sp@(2),d0");

-#else

-asm(" movew sp@(6),d0");

-#endif

-asm(" andiw #0x700,d0

- cmpiw #0x700,d0

- beq _already7

- movew sp@+,d0

- bra __catchException

-_already7:

- movew sp@+,d0");

-#if !defined (mc68020) && !defined (mc68332)

-asm(" lea sp@(4),sp"); /* pull off 68000 return address */

-#endif

-asm(" rte");

-extern void _catchException ();

-#if defined (mc68020) || defined (mc68332)

-/* This function is called when a 68020 exception occurs. It saves

- * all the cpu and fpcp regs in the _registers array, creates a frame on a

- * linked list of frames which has the cpu and fpcp stack frames needed

- * to properly restore the context of these processors, and invokes

- * an exception handler (remcom_handler).

- *

- * stack on entry: stack on exit:

- * N bytes of junk exception # MSWord

- * Exception Format Word exception # MSWord

- * Program counter LSWord

- * Program counter MSWord

- * Status Register

- *

- */

-asm("

-.text

-.globl __catchException

-__catchException:");

-DISABLE_INTERRUPTS();

-asm("

- moveml d0-d7/a0-a6,_registers /* save registers */

- movel _lastFrame,a0 /* last frame pointer */

-");

-SAVE_FP_REGS();

-asm("

- lea _registers,a5 /* get address of registers */

- movew sp@,d1 /* get status register */

- movew d1,a5@(66) /* save sr */

- movel sp@(2),a4 /* save pc in a4 for later use */

- movel a4,a5@(68) /* save pc in _regisers[] */

-# figure out how many bytes in the stack frame

- movew sp@(6),d0 /* get '020 exception format */

- movew d0,d2 /* make a copy of format word */

- andiw #0xf000,d0 /* mask off format type */

- rolw #5,d0 /* rotate into the low byte *2 */

- lea _exceptionSize,a1

- addw d0,a1 /* index into the table */

- movew a1@,d0 /* get number of words in frame */

- movew d0,d3 /* save it */

- subw d0,a0 /* adjust save pointer */

- subw d0,a0 /* adjust save pointer(bytes) */

- movel a0,a1 /* copy save pointer */

- subql #1,d0 /* predecrement loop counter */

-# copy the frame

-saveFrameLoop:

- movew sp@+,a1@+

- dbf d0,saveFrameLoop

-# now that the stack has been clenaed,

-# save the a7 in use at time of exception

- movel sp,_superStack /* save supervisor sp */

- andiw #0x2000,d1 /* were we in supervisor mode ? */

- beq userMode

- movel a7,a5@(60) /* save a7 */

- bra a7saveDone

-userMode:

- movel usp,a1

- movel a1,a5@(60) /* save user stack pointer */

-a7saveDone:

-# save size of frame

- movew d3,a0@-

-# compute exception number

- andl #0xfff,d2 /* mask off vector offset */

- lsrw #2,d2 /* divide by 4 to get vect num */

- movel d2,a0@- /* save it */

-# save pc causing exception

- movel a4,a0@-

-# save old frame link and set the new value

- movel _lastFrame,a1 /* last frame pointer */

- movel a1,a0@- /* save pointer to prev frame */

- movel a0,_lastFrame

- movel d2,sp@- /* push exception num */

- movel _exceptionHook,a0 /* get address of handler */

- jbsr a0@ /* and call it */

- clrl sp@ /* replace exception num parm with frame ptr */

- jbsr __returnFromException /* jbsr, but never returns */

-");

-#else /* mc68000 */

-/* This function is called when an exception occurs. It translates the

- * return address found on the stack into an exception vector # which

- * is then handled by either handle_exception or a system handler.

- * _catchException provides a front end for both.

- *

- * stack on entry: stack on exit:

- * Program counter MSWord exception # MSWord

- * Program counter LSWord exception # MSWord

- * Status Register

- * Return Address MSWord

- * Return Address LSWord

- */

-asm("

-.text

-.globl __catchException

-__catchException:");

-DISABLE_INTERRUPTS();

-asm("

- moveml d0-d7/a0-a6,_registers /* save registers */

- movel _lastFrame,a0 /* last frame pointer */

-");

-SAVE_FP_REGS();

-asm("

- lea _registers,a5 /* get address of registers */

- movel sp@+,d2 /* pop return address */

- addl #1530,d2 /* convert return addr to */

- divs #6,d2 /* exception number */

- extl d2

- moveql #3,d3 /* assume a three word frame */

- cmpiw #3,d2 /* bus error or address error ? */

- bgt normal /* if >3 then normal error */

- movel sp@+,a0@- /* copy error info to frame buff*/

- movel sp@+,a0@- /* these are never used */

- moveql #7,d3 /* this is a 7 word frame */

-normal:

- movew sp@+,d1 /* pop status register */

- movel sp@+,a4 /* pop program counter */

- movew d1,a5@(66) /* save sr */

- movel a4,a5@(68) /* save pc in _regisers[] */

- movel a4,a0@- /* copy pc to frame buffer */

- movew d1,a0@- /* copy sr to frame buffer */

- movel sp,_superStack /* save supervisor sp */

- andiw #0x2000,d1 /* were we in supervisor mode ? */

- beq userMode

- movel a7,a5@(60) /* save a7 */

- bra saveDone

-userMode:

- movel usp,a1 /* save user stack pointer */

- movel a1,a5@(60) /* save user stack pointer */

-saveDone:

- movew d3,a0@- /* push frame size in words */

- movel d2,a0@- /* push vector number */

- movel a4,a0@- /* push exception pc */

-# save old frame link and set the new value

- movel _lastFrame,a1 /* last frame pointer */

- movel a1,a0@- /* save pointer to prev frame */

- movel a0,_lastFrame

- movel d2,sp@- /* push exception num */

- movel _exceptionHook,a0 /* get address of handler */

- jbsr a0@ /* and call it */

- clrl sp@ /* replace exception num parm with frame ptr */

- jbsr __returnFromException /* jbsr, but never returns */

-");

-#endif

-/*

- * remcomHandler is a front end for handle_exception. It moves the

- * stack pointer into an area reserved for debugger use in case the

- * breakpoint happened in supervisor mode.

- */

-asm("_remcomHandler:");

-asm(" addl #4,sp"); /* pop off return address */

-asm(" movel sp@+,d0"); /* get the exception number */

-asm(" movel _stackPtr,sp"); /* move to remcom stack area */

-asm(" movel d0,sp@-"); /* push exception onto stack */

-asm(" jbsr _handle_exception"); /* this never returns */

-asm(" rts"); /* return */

-void

-_returnFromException (Frame * 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 */

- }

-#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;

-#endif

- /* throw away any frames in the list after this frame */

- lastFrame = frame;

- frame->sr = registers[(int) PS];

- frame->pc = registers[(int) PC];

- if (registers[(int) PS] & 0x2000)

- {

- /* return to supervisor mode... */

- return_to_super ();

- }

- else

- { /* return to user mode */

- return_to_user ();

- }

-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);

- return (-1);

-static char remcomInBuffer[BUFMAX];

-static char remcomOutBuffer[BUFMAX];

-/* scan for the sequence $<data>#<checksum> */

-unsigned char *

-getpacket (void)

- 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 - 1)

- {

- 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)

- {

- fprintf (stderr,

- "bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",

- checksum, xmitcsum, 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. */

-void

-putpacket (buffer)

- 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 () != '+');

-void

-debug_error (format, parm)

- char *format;

- char *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;

- 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;

- 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 ()

- 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 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 */

- /* Coprocessor protocol violation. Using a standard MMU or FPU

- 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 */

- /* 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 */

- 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);

-/**********************************************/

-/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */

-/* RETURN NUMBER OF CHARS PROCESSED */

-/**********************************************/

-int

-hexToInt (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);

-/*

- * This function does all command procesing for interfacing to gdb.

- */

-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]);

- /* reply to host that an exception has occurred */

- sigval = computeSignal (exceptionVector);

- remcomOutBuffer[0] = 'S';

- remcomOutBuffer[1] = hexchars[sigval >> 4];

- remcomOutBuffer[2] = hexchars[sigval % 16];

- remcomOutBuffer[3] = 0;

- 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);

- /* 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;

- 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?) */

- frame = (Frame *) 0;

- _returnFromException (frame); /* this is a jump */

- }

- /* 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 */

- break;

- /* kill the program */

- case 'k': /* do nothing */

- break;

- } /* switch */

- /* reply to the request */

- putpacket (remcomOutBuffer);

- }

-void

-initializeRemcomErrorFrame (void)

- 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 ()

- extern void _debug_level7 ();

- extern void remcomHandler ();

- int exception;

- initializeRemcomErrorFrame ();

- stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];

- for (exception = 2; exception <= 23; exception++)

- exceptionHandler (exception, _catchException);

- /* level 7 interrupt */

- exceptionHandler (31, _debug_level7);

- /* breakpoint exception (trap #1) */

- 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);

- /* 48 to 54 are floating point coprocessor errors */

- for (exception = 48; exception <= 54; exception++)

- exceptionHandler (exception, _catchException);

- if (oldExceptionHook != remcomHandler)

- {

- oldExceptionHook = exceptionHook;

- exceptionHook = remcomHandler;

- }

- 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. */

-void

-breakpoint ()

- if (initialized)

- BREAKPOINT ();

« no previous file with comments | « gdb/m68hc11-tdep.c ('k') | gdb/m68k-tdep.c » ('j') | no next file with comments »