Subversion Repositories or1k

/* sh-stub.c -- debugging stub for the Hitachi-SH.

/* sh-stub.c -- debugging stub for the Hitachi-SH.

 NOTE!! This code has to be compiled with optimization, otherwise the

 NOTE!! This code has to be compiled with optimization, otherwise the

 function inlining which generates the exception handlers won't work.

 function inlining which generates the exception handlers won't work.

*/

*/

/*   This is originally based on an m68k software stub written by Glenn

/*   This is originally based on an m68k software stub written by Glenn

     Engel at HP, but has changed quite a bit.

     Engel at HP, but has changed quite a bit.

     Modifications for the SH by Ben Lee and Steve Chamberlain

     Modifications for the SH by Ben Lee and Steve Chamberlain

*/

*/

/****************************************************************************

/****************************************************************************

                THIS SOFTWARE IS NOT COPYRIGHTED

                THIS SOFTWARE IS NOT COPYRIGHTED

   HP offers the following for use in the public domain.  HP makes no

   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

   warranty with regard to the software or it's performance and the

   user accepts the software "AS IS" with all faults.

   user accepts the software "AS IS" with all faults.

   HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD

   HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD

   TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES

   TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES

   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

****************************************************************************/

****************************************************************************/

/* Remote communication protocol.

/* Remote communication protocol.

   A debug packet whose contents are <data>

   A debug packet whose contents are <data>

   is encapsulated for transmission in the form:

   is encapsulated for transmission in the form:

        $ <data> # CSUM1 CSUM2

        $ <data> # CSUM1 CSUM2

        <data> must be ASCII alphanumeric and cannot include characters

        <data> must be ASCII alphanumeric and cannot include characters

        '$' or '#'.  If <data> starts with two characters followed by

        '$' or '#'.  If <data> starts with two characters followed by

        ':', then the existing stubs interpret this as a sequence number.

        ':', then the existing stubs interpret this as a sequence number.

        CSUM1 and CSUM2 are ascii hex representation of an 8-bit

        CSUM1 and CSUM2 are ascii hex representation of an 8-bit

        checksum of <data>, the most significant nibble is sent first.

        checksum of <data>, the most significant nibble is sent first.

        the hex digits 0-9,a-f are used.

        the hex digits 0-9,a-f are used.

   Receiver responds with:

   Receiver responds with:

        +       - if CSUM is correct and ready for next packet

        +       - if CSUM is correct and ready for next packet

        -       - if CSUM is incorrect

        -       - if CSUM is incorrect

   <data> is as follows:

   <data> is as follows:

   All values are encoded in ascii hex digits.

   All values are encoded in ascii hex digits.

        Request         Packet

        Request         Packet

        read registers  g

        read registers  g

        reply           XX....X         Each byte of register data

        reply           XX....X         Each byte of register data

                                        is described by two hex digits.

                                        is described by two hex digits.

                                        Registers are in the internal order

                                        Registers are in the internal order

                                        for GDB, and the bytes in a register

                                        for GDB, and the bytes in a register

                                        are in the same order the machine uses.

                                        are in the same order the machine uses.

                        or ENN          for an error.

                        or ENN          for an error.

        write regs      GXX..XX         Each byte of register data

        write regs      GXX..XX         Each byte of register data

                                        is described by two hex digits.

                                        is described by two hex digits.

        reply           OK              for success

        reply           OK              for success

                        ENN             for an error

                        ENN             for an error

        write reg       Pn...=r...      Write register n... with value r...,

        write reg       Pn...=r...      Write register n... with value r...,

                                        which contains two hex digits for each

                                        which contains two hex digits for each

                                        byte in the register (target byte

                                        byte in the register (target byte

                                        order).

                                        order).

        reply           OK              for success

        reply           OK              for success

                        ENN             for an error

                        ENN             for an error

        (not supported by all stubs).

        (not supported by all stubs).

        read mem        mAA..AA,LLLL    AA..AA is address, LLLL is length.

        read mem        mAA..AA,LLLL    AA..AA is address, LLLL is length.

        reply           XX..XX          XX..XX is mem contents

        reply           XX..XX          XX..XX is mem contents

                                        Can be fewer bytes than requested

                                        Can be fewer bytes than requested

                                        if able to read only part of the data.

                                        if able to read only part of the data.

                        or ENN          NN is errno

                        or ENN          NN is errno

        write mem       MAA..AA,LLLL:XX..XX

        write mem       MAA..AA,LLLL:XX..XX

                                        AA..AA is address,

                                        AA..AA is address,

                                        LLLL is number of bytes,

                                        LLLL is number of bytes,

                                        XX..XX is data

                                        XX..XX is data

        reply           OK              for success

        reply           OK              for success

                        ENN             for an error (this includes the case

                        ENN             for an error (this includes the case

                                        where only part of the data was

                                        where only part of the data was

                                        written).

                                        written).

        cont            cAA..AA         AA..AA is address to resume

        cont            cAA..AA         AA..AA is address to resume

                                        If AA..AA is omitted,

                                        If AA..AA is omitted,

                                        resume at same address.

                                        resume at same address.

        step            sAA..AA         AA..AA is address to resume

        step            sAA..AA         AA..AA is address to resume

                                        If AA..AA is omitted,

                                        If AA..AA is omitted,

                                        resume at same address.

                                        resume at same address.

        last signal     ?               Reply the current reason for stopping.

        last signal     ?               Reply the current reason for stopping.

                                        This is the same reply as is generated

                                        This is the same reply as is generated

                                        for step or cont : SAA where AA is the

                                        for step or cont : SAA where AA is the

                                        signal number.

                                        signal number.

        There is no immediate reply to step or cont.

        There is no immediate reply to step or cont.

        The reply comes when the machine stops.

        The reply comes when the machine stops.

        It is           SAA             AA is the "signal number"

        It is           SAA             AA is the "signal number"

        or...           TAAn...:r...;n:r...;n...:r...;

        or...           TAAn...:r...;n:r...;n...:r...;

                                        AA = signal number

                                        AA = signal number

                                        n... = register number

                                        n... = register number

                                        r... = register contents

                                        r... = register contents

        or...           WAA             The process exited, and AA is

        or...           WAA             The process exited, and AA is

                                        the exit status.  This is only

                                        the exit status.  This is only

                                        applicable for certains sorts of

                                        applicable for certains sorts of

                                        targets.

                                        targets.

        kill request    k

        kill request    k

        toggle debug    d               toggle debug flag (see 386 & 68k stubs)

        toggle debug    d               toggle debug flag (see 386 & 68k stubs)

        reset           r               reset -- see sparc stub.

        reset           r               reset -- see sparc stub.

        reserved        <other>         On other requests, the stub should

        reserved        <other>         On other requests, the stub should

                                        ignore the request and send an empty

                                        ignore the request and send an empty

                                        response ($#<checksum>).  This way

                                        response ($#<checksum>).  This way

                                        we can extend the protocol and GDB

                                        we can extend the protocol and GDB

                                        can tell whether the stub it is

                                        can tell whether the stub it is

                                        talking to uses the old or the new.

                                        talking to uses the old or the new.

        search          tAA:PP,MM       Search backwards starting at address

        search          tAA:PP,MM       Search backwards starting at address

                                        AA for a match with pattern PP and

                                        AA for a match with pattern PP and

                                        mask MM.  PP and MM are 4 bytes.

                                        mask MM.  PP and MM are 4 bytes.

                                        Not supported by all stubs.

                                        Not supported by all stubs.

        general query   qXXXX           Request info about XXXX.

        general query   qXXXX           Request info about XXXX.

        general set     QXXXX=yyyy      Set value of XXXX to yyyy.

        general set     QXXXX=yyyy      Set value of XXXX to yyyy.

        query sect offs qOffsets        Get section offsets.  Reply is

        query sect offs qOffsets        Get section offsets.  Reply is

                                        Text=xxx;Data=yyy;Bss=zzz

                                        Text=xxx;Data=yyy;Bss=zzz

        console output  Otext           Send text to stdout.  Only comes from

        console output  Otext           Send text to stdout.  Only comes from

                                        remote target.

                                        remote target.

        Responses can be run-length encoded to save space.  A '*' means that

        Responses can be run-length encoded to save space.  A '*' means that

        the next character is an ASCII encoding giving a repeat count which

        the next character is an ASCII encoding giving a repeat count which

        stands for that many repititions of the character preceding the '*'.

        stands for that many repititions of the character preceding the '*'.

        The encoding is n+29, yielding a printable character where n >=3

        The encoding is n+29, yielding a printable character where n >=3

        (which is where rle starts to win).  Don't use an n > 126.

        (which is where rle starts to win).  Don't use an n > 126.

        So

        So

        "0* " means the same as "0000".  */

        "0* " means the same as "0000".  */

#include <string.h>

#include <string.h>

#include <setjmp.h>

#include <setjmp.h>

/* Hitachi SH architecture instruction encoding masks */

/* Hitachi SH architecture instruction encoding masks */

#define COND_BR_MASK   0xff00

#define COND_BR_MASK   0xff00

#define UCOND_DBR_MASK 0xe000

#define UCOND_DBR_MASK 0xe000

#define UCOND_RBR_MASK 0xf0df

#define UCOND_RBR_MASK 0xf0df

#define TRAPA_MASK     0xff00

#define TRAPA_MASK     0xff00

#define COND_DISP      0x00ff

#define COND_DISP      0x00ff

#define UCOND_DISP     0x0fff

#define UCOND_DISP     0x0fff

#define UCOND_REG      0x0f00

#define UCOND_REG      0x0f00

/* Hitachi SH instruction opcodes */

/* Hitachi SH instruction opcodes */

#define BF_INSTR       0x8b00

#define BF_INSTR       0x8b00

#define BT_INSTR       0x8900

#define BT_INSTR       0x8900

#define BRA_INSTR      0xa000

#define BRA_INSTR      0xa000

#define BSR_INSTR      0xb000

#define BSR_INSTR      0xb000

#define JMP_INSTR      0x402b

#define JMP_INSTR      0x402b

#define JSR_INSTR      0x400b

#define JSR_INSTR      0x400b

#define RTS_INSTR      0x000b

#define RTS_INSTR      0x000b

#define RTE_INSTR      0x002b

#define RTE_INSTR      0x002b

#define TRAPA_INSTR    0xc300

#define TRAPA_INSTR    0xc300

#define SSTEP_INSTR    0xc3ff

#define SSTEP_INSTR    0xc3ff

/* Hitachi SH processor register masks */

/* Hitachi SH processor register masks */

#define T_BIT_MASK     0x0001

#define T_BIT_MASK     0x0001

/*

/*

 * BUFMAX defines the maximum number of characters in inbound/outbound

 * BUFMAX defines the maximum number of characters in inbound/outbound

 * buffers. At least NUMREGBYTES*2 are needed for register packets.

 * buffers. At least NUMREGBYTES*2 are needed for register packets.

 */

 */

#define BUFMAX 1024

#define BUFMAX 1024

/*

/*

 * Number of bytes for registers

 * Number of bytes for registers

 */

 */

#define NUMREGBYTES 112         /* 92 */

#define NUMREGBYTES 112         /* 92 */

/*

/*

 * typedef

 * typedef

 */

 */

typedef void (*Function) ();

typedef void (*Function) ();

/*

/*

 * Forward declarations

 * Forward declarations

 */

 */

static int hex (char);

static int hex (char);

static char *mem2hex (char *, char *, int);

static char *mem2hex (char *, char *, int);

static char *hex2mem (char *, char *, int);

static char *hex2mem (char *, char *, int);

static int hexToInt (char **, int *);

static int hexToInt (char **, int *);

static unsigned char *getpacket (void);

static unsigned char *getpacket (void);

static void putpacket (char *);

static void putpacket (char *);

static void handle_buserror (void);

static void handle_buserror (void);

static int computeSignal (int exceptionVector);

static int computeSignal (int exceptionVector);

static void handle_exception (int exceptionVector);

static void handle_exception (int exceptionVector);

void init_serial();

void init_serial();

void putDebugChar (char);

void putDebugChar (char);

char getDebugChar (void);

char getDebugChar (void);

/* These are in the file but in asm statements so the compiler can't see them */

/* These are in the file but in asm statements so the compiler can't see them */

void catch_exception_4 (void);

void catch_exception_4 (void);

void catch_exception_6 (void);

void catch_exception_6 (void);

void catch_exception_9 (void);

void catch_exception_9 (void);

void catch_exception_10 (void);

void catch_exception_10 (void);

void catch_exception_11 (void);

void catch_exception_11 (void);

void catch_exception_32 (void);

void catch_exception_32 (void);

void catch_exception_33 (void);

void catch_exception_33 (void);

void catch_exception_255 (void);

void catch_exception_255 (void);

#define catch_exception_random catch_exception_255 /* Treat all odd ones like 255 */

#define catch_exception_random catch_exception_255 /* Treat all odd ones like 255 */

void breakpoint (void);

void breakpoint (void);

#define init_stack_size 8*1024  /* if you change this you should also modify BINIT */

#define init_stack_size 8*1024  /* if you change this you should also modify BINIT */

#define stub_stack_size 8*1024

#define stub_stack_size 8*1024

int init_stack[init_stack_size] __attribute__ ((section ("stack"))) = {0};

int init_stack[init_stack_size] __attribute__ ((section ("stack"))) = {0};

int stub_stack[stub_stack_size] __attribute__ ((section ("stack"))) = {0};

int stub_stack[stub_stack_size] __attribute__ ((section ("stack"))) = {0};

void INIT ();

void INIT ();

void BINIT ();

void BINIT ();

#define CPU_BUS_ERROR_VEC  9

#define CPU_BUS_ERROR_VEC  9

#define DMA_BUS_ERROR_VEC 10

#define DMA_BUS_ERROR_VEC 10

#define NMI_VEC           11

#define NMI_VEC           11

#define INVALID_INSN_VEC   4

#define INVALID_INSN_VEC   4

#define INVALID_SLOT_VEC   6

#define INVALID_SLOT_VEC   6

#define TRAP_VEC          32

#define TRAP_VEC          32

#define IO_VEC            33

#define IO_VEC            33

#define USER_VEC         255

#define USER_VEC         255

char in_nmi;   /* Set when handling an NMI, so we don't reenter */

char in_nmi;   /* Set when handling an NMI, so we don't reenter */

int dofault;  /* Non zero, bus errors will raise exception */

int dofault;  /* Non zero, bus errors will raise exception */

int *stub_sp;

int *stub_sp;

/* debug > 0 prints ill-formed commands in valid packets & checksum errors */

/* debug > 0 prints ill-formed commands in valid packets & checksum errors */

int remote_debug;

int remote_debug;

/* jump buffer used for setjmp/longjmp */

/* jump buffer used for setjmp/longjmp */

jmp_buf remcomEnv;

jmp_buf remcomEnv;

enum regnames

enum regnames

  {

  {

    R0, R1, R2, R3, R4, R5, R6, R7,

    R0, R1, R2, R3, R4, R5, R6, R7,

    R8, R9, R10, R11, R12, R13, R14,

    R8, R9, R10, R11, R12, R13, R14,

    R15, PC, PR, GBR, VBR, MACH, MACL, SR,

    R15, PC, PR, GBR, VBR, MACH, MACL, SR,

    TICKS, STALLS, CYCLES, INSTS, PLR

    TICKS, STALLS, CYCLES, INSTS, PLR

  };

  };

typedef struct

typedef struct

  {

  {

    short *memAddr;

    short *memAddr;

    short oldInstr;

    short oldInstr;

  }

  }

stepData;

stepData;

int registers[NUMREGBYTES / 4];

int registers[NUMREGBYTES / 4];

stepData instrBuffer;

stepData instrBuffer;

char stepped;

char stepped;

static const char hexchars[] = "0123456789abcdef";

static const char hexchars[] = "0123456789abcdef";

static char remcomInBuffer[BUFMAX];

static char remcomInBuffer[BUFMAX];

static char remcomOutBuffer[BUFMAX];

static char remcomOutBuffer[BUFMAX];

char highhex(int  x)

char highhex(int  x)

{

{

  return hexchars[(x >> 4) & 0xf];

  return hexchars[(x >> 4) & 0xf];

}

}

char lowhex(int  x)

char lowhex(int  x)

{

{

  return hexchars[x & 0xf];

  return hexchars[x & 0xf];

}

}

/*

/*

 * Assembly macros

 * Assembly macros

 */

 */

#define BREAKPOINT()   asm("trapa       #0x20"::);

#define BREAKPOINT()   asm("trapa       #0x20"::);

/*

/*

 * Routines to handle hex data

 * Routines to handle hex data

 */

 */

static int

static int

hex (char ch)

hex (char ch)

{

{

  if ((ch >= 'a') && (ch <= 'f'))

  if ((ch >= 'a') && (ch <= 'f'))

    return (ch - 'a' + 10);

    return (ch - 'a' + 10);

  if ((ch >= '0') && (ch <= '9'))

  if ((ch >= '0') && (ch <= '9'))

    return (ch - '0');

    return (ch - '0');

  if ((ch >= 'A') && (ch <= 'F'))

  if ((ch >= 'A') && (ch <= 'F'))

    return (ch - 'A' + 10);

    return (ch - 'A' + 10);

  return (-1);

  return (-1);

}

}

/* convert the memory, pointed to by mem into hex, placing result in buf */

/* convert the memory, pointed to by mem into hex, placing result in buf */

/* return a pointer to the last char put in buf (null) */

/* return a pointer to the last char put in buf (null) */

static char *

static char *

mem2hex (char *mem, char *buf, int count)

mem2hex (char *mem, char *buf, int count)

{

{

  int i;

  int i;

  int ch;

  int ch;

  for (i = 0; i < count; i++)

  for (i = 0; i < count; i++)

    {

    {

      ch = *mem++;

      ch = *mem++;

      *buf++ = highhex (ch);

      *buf++ = highhex (ch);

      *buf++ = lowhex (ch);

      *buf++ = lowhex (ch);

    }

    }

  *buf = 0;

  *buf = 0;

  return (buf);

  return (buf);

}

}

/* convert the hex array pointed to by buf into binary, to be placed in mem */

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

/* return a pointer to the character after the last byte written */

static char *

static char *

hex2mem (char *buf, char *mem, int count)

hex2mem (char *buf, char *mem, int count)

{

{

  int i;

  int i;

  unsigned char ch;

  unsigned char ch;

  for (i = 0; i < count; i++)

  for (i = 0; i < count; i++)

    {

    {

      ch = hex (*buf++) << 4;

      ch = hex (*buf++) << 4;

      ch = ch + hex (*buf++);

      ch = ch + hex (*buf++);

      *mem++ = ch;

      *mem++ = ch;

    }

    }

  return (mem);

  return (mem);

}

}

/**********************************************/

/**********************************************/

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

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

/* RETURN NUMBER OF CHARS PROCESSED           */

/* RETURN NUMBER OF CHARS PROCESSED           */

/**********************************************/

/**********************************************/

static int

static int

hexToInt (char **ptr, int *intValue)

hexToInt (char **ptr, int *intValue)

{

{

  int numChars = 0;

  int numChars = 0;

  int hexValue;

  int hexValue;

  *intValue = 0;

  *intValue = 0;

  while (**ptr)

  while (**ptr)

    {

    {

      hexValue = hex (**ptr);

      hexValue = hex (**ptr);

      if (hexValue >= 0)

      if (hexValue >= 0)

        {

        {

          *intValue = (*intValue << 4) | hexValue;

          *intValue = (*intValue << 4) | hexValue;

          numChars++;

          numChars++;

        }

        }

      else

      else

        break;

        break;

      (*ptr)++;

      (*ptr)++;

    }

    }

  return (numChars);

  return (numChars);

}

}

/*

/*

 * Routines to get and put packets

 * Routines to get and put packets

 */

 */

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

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

char *

char *

getpacket ()

getpacket ()

{

{

  unsigned char *buffer = &remcomInBuffer[0];

  unsigned char *buffer = &remcomInBuffer[0];

  unsigned char checksum;

  unsigned char checksum;

  unsigned char xmitcsum;

  unsigned char xmitcsum;

  int count;

  int count;

  char ch;

  char ch;

  while (1)

  while (1)

    {

    {

      /* wait around for the start character, ignore all other characters */

      /* wait around for the start character, ignore all other characters */

      while ((ch = getDebugChar ()) != '$')

      while ((ch = getDebugChar ()) != '$')

        ;

        ;

retry:

retry:

      checksum = 0;

      checksum = 0;

      xmitcsum = -1;

      xmitcsum = -1;

      count = 0;

      count = 0;

      /* now, read until a # or end of buffer is found */

      /* now, read until a # or end of buffer is found */

      while (count < BUFMAX)

      while (count < BUFMAX)

        {

        {

          ch = getDebugChar ();

          ch = getDebugChar ();

          if (ch == '$')

          if (ch == '$')

            goto retry;

            goto retry;

          if (ch == '#')

          if (ch == '#')

            break;

            break;

          checksum = checksum + ch;

          checksum = checksum + ch;

          buffer[count] = ch;

          buffer[count] = ch;

          count = count + 1;

          count = count + 1;

        }

        }

      buffer[count] = 0;

      buffer[count] = 0;

      if (ch == '#')

      if (ch == '#')

        {

        {

          ch = getDebugChar ();

          ch = getDebugChar ();

          xmitcsum = hex (ch) << 4;

          xmitcsum = hex (ch) << 4;

          ch = getDebugChar ();

          ch = getDebugChar ();

          xmitcsum += hex (ch);

          xmitcsum += hex (ch);

          if (checksum != xmitcsum)

          if (checksum != xmitcsum)

            {

            {

              putDebugChar ('-');       /* failed checksum */

              putDebugChar ('-');       /* failed checksum */

            }

            }

          else

          else

            {

            {

              putDebugChar ('+');       /* successful transfer */

              putDebugChar ('+');       /* successful transfer */

              /* if a sequence char is present, reply the sequence ID */

              /* if a sequence char is present, reply the sequence ID */

              if (buffer[2] == ':')

              if (buffer[2] == ':')

                {

                {

                  putDebugChar (buffer[0]);

                  putDebugChar (buffer[0]);

                  putDebugChar (buffer[1]);

                  putDebugChar (buffer[1]);

                  return &buffer[3];

                  return &buffer[3];

                }

                }

              return &buffer[0];

              return &buffer[0];

            }

            }

        }

        }

    }

    }

}

}

/* send the packet in buffer. */

/* send the packet in buffer. */

static void

static void

putpacket (register char *buffer)

putpacket (register char *buffer)

{

{

  register  int checksum;

  register  int checksum;

  register  int count;

  register  int count;

  /*  $<packet info>#<checksum>. */

  /*  $<packet info>#<checksum>. */

  do

  do

    {

    {

      char *src = buffer;

      char *src = buffer;

      putDebugChar ('$');

      putDebugChar ('$');

      checksum = 0;

      checksum = 0;

      while (*src)

      while (*src)

        {

        {

          int runlen;

          int runlen;

          /* Do run length encoding */

          /* Do run length encoding */

          for (runlen = 0; runlen < 100; runlen ++)

          for (runlen = 0; runlen < 100; runlen ++)

            {

            {

              if (src[0] != src[runlen])

              if (src[0] != src[runlen])

                {

                {

                  if (runlen > 3)

                  if (runlen > 3)

                    {

                    {

                      int encode;

                      int encode;

                      /* Got a useful amount */

                      /* Got a useful amount */

                      putDebugChar (*src);

                      putDebugChar (*src);

                      checksum += *src;

                      checksum += *src;

                      putDebugChar ('*');

                      putDebugChar ('*');

                      checksum += '*';

                      checksum += '*';

                      checksum += (encode = runlen + ' ' - 4);

                      checksum += (encode = runlen + ' ' - 4);

                      putDebugChar (encode);

                      putDebugChar (encode);

                      src += runlen;

                      src += runlen;

                    }

                    }

                  else

                  else

                    {

                    {

                      putDebugChar (*src);

                      putDebugChar (*src);

                      checksum += *src;

                      checksum += *src;

                      src++;

                      src++;

                    }

                    }

                  break;

                  break;

                }

                }

            }

            }

        }

        }

      putDebugChar ('#');

      putDebugChar ('#');

      putDebugChar (highhex(checksum));

      putDebugChar (highhex(checksum));

      putDebugChar (lowhex(checksum));

      putDebugChar (lowhex(checksum));

    }

    }

  while  (getDebugChar() != '+');

  while  (getDebugChar() != '+');

}

}

/* a bus error has occurred, perform a longjmp

/* a bus error has occurred, perform a longjmp

   to return execution and allow handling of the error */

   to return execution and allow handling of the error */

void

void

handle_buserror (void)

handle_buserror (void)

{

{

  longjmp (remcomEnv, 1);

  longjmp (remcomEnv, 1);

}

}

/*

/*

 * this function takes the SH-1 exception number and attempts to

 * this function takes the SH-1 exception number and attempts to

 * translate this number into a unix compatible signal value

 * translate this number into a unix compatible signal value

 */

 */

static int

static int

computeSignal (int exceptionVector)

computeSignal (int exceptionVector)

{

{

  int sigval;

  int sigval;

  switch (exceptionVector)

  switch (exceptionVector)

    {

    {

    case INVALID_INSN_VEC:

    case INVALID_INSN_VEC:

      sigval = 4;

      sigval = 4;

      break;

      break;

    case INVALID_SLOT_VEC:

    case INVALID_SLOT_VEC:

      sigval = 4;

      sigval = 4;

      break;

      break;

    case CPU_BUS_ERROR_VEC:

    case CPU_BUS_ERROR_VEC:

      sigval = 10;

      sigval = 10;

      break;

      break;

    case DMA_BUS_ERROR_VEC:

    case DMA_BUS_ERROR_VEC:

      sigval = 10;

      sigval = 10;

      break;

      break;

    case NMI_VEC:

    case NMI_VEC:

      sigval = 2;

      sigval = 2;

      break;

      break;

    case TRAP_VEC:

    case TRAP_VEC:

    case USER_VEC:

    case USER_VEC:

      sigval = 5;

      sigval = 5;

      break;

      break;

    default:

    default:

      sigval = 7;               /* "software generated"*/

      sigval = 7;               /* "software generated"*/

      break;

      break;

    }

    }

  return (sigval);

  return (sigval);

}

}

void

void

doSStep (void)

doSStep (void)

{

{

  short *instrMem;

  short *instrMem;

  int displacement;

  int displacement;

  int reg;

  int reg;

  unsigned short opcode;

  unsigned short opcode;

  instrMem = (short *) registers[PC];

  instrMem = (short *) registers[PC];

  opcode = *instrMem;

  opcode = *instrMem;

  stepped = 1;

  stepped = 1;

  if ((opcode & COND_BR_MASK) == BT_INSTR)

  if ((opcode & COND_BR_MASK) == BT_INSTR)

    {

    {

      if (registers[SR] & T_BIT_MASK)

      if (registers[SR] & T_BIT_MASK)

        {

        {

          displacement = (opcode & COND_DISP) << 1;

          displacement = (opcode & COND_DISP) << 1;

          if (displacement & 0x80)

          if (displacement & 0x80)

            displacement |= 0xffffff00;

            displacement |= 0xffffff00;

          /*

          /*

                   * Remember PC points to second instr.

                   * Remember PC points to second instr.

                   * after PC of branch ... so add 4

                   * after PC of branch ... so add 4

                   */

                   */

          instrMem = (short *) (registers[PC] + displacement + 4);

          instrMem = (short *) (registers[PC] + displacement + 4);

        }

        }

      else

      else

        instrMem += 1;

        instrMem += 1;

    }

    }

  else if ((opcode & COND_BR_MASK) == BF_INSTR)

  else if ((opcode & COND_BR_MASK) == BF_INSTR)

    {

    {

      if (registers[SR] & T_BIT_MASK)

      if (registers[SR] & T_BIT_MASK)

        instrMem += 1;

        instrMem += 1;

      else

      else

        {

        {

          displacement = (opcode & COND_DISP) << 1;

          displacement = (opcode & COND_DISP) << 1;

          if (displacement & 0x80)

          if (displacement & 0x80)

            displacement |= 0xffffff00;

            displacement |= 0xffffff00;

          /*

          /*

                   * Remember PC points to second instr.

                   * Remember PC points to second instr.

                   * after PC of branch ... so add 4

                   * after PC of branch ... so add 4

                   */

                   */

          instrMem = (short *) (registers[PC] + displacement + 4);

          instrMem = (short *) (registers[PC] + displacement + 4);

        }

        }

    }

    }

  else if ((opcode & UCOND_DBR_MASK) == BRA_INSTR)

  else if ((opcode & UCOND_DBR_MASK) == BRA_INSTR)

    {

    {

      displacement = (opcode & UCOND_DISP) << 1;

      displacement = (opcode & UCOND_DISP) << 1;

      if (displacement & 0x0800)

      if (displacement & 0x0800)

        displacement |= 0xfffff000;

        displacement |= 0xfffff000;

      /*

      /*

           * Remember PC points to second instr.

           * Remember PC points to second instr.

           * after PC of branch ... so add 4

           * after PC of branch ... so add 4

           */

           */

      instrMem = (short *) (registers[PC] + displacement + 4);

      instrMem = (short *) (registers[PC] + displacement + 4);

    }

    }

  else if ((opcode & UCOND_RBR_MASK) == JSR_INSTR)

  else if ((opcode & UCOND_RBR_MASK) == JSR_INSTR)

    {

    {