Subversion Repositories or1k

#include <stdio.h>

#include <stdio.h>

#include <string.h>

#include <string.h>

#include <stdlib.h>

#include <stdlib.h>

#include <time.h>

#include <time.h>

#include <errno.h>

#include <errno.h>

#include <nwtypes.h>

#include <nwtypes.h>

#include <nwdfs.h>

#include <nwdfs.h>

#include <nwconio.h>

#include <nwconio.h>

#include <nwadv.h>

#include <nwadv.h>

#include <nwdbgapi.h>

#include <nwdbgapi.h>

#include <nwthread.h>

#include <nwthread.h>

#include "ppc.h"

#include "ppc.h"

extern char *mem2hex (void *mem, char *buf, int count, int may_fault);

extern char *mem2hex (void *mem, char *buf, int count, int may_fault);

extern char *hex2mem (char *buf, void *mem, int count, int may_fault);

extern char *hex2mem (char *buf, void *mem, int count, int may_fault);

extern int computeSignal (int exceptionVector);

extern int computeSignal (int exceptionVector);

void

void

flush_i_cache (void)

flush_i_cache (void)

{

{

}

}

/* Get the registers out of the frame information.  */

/* Get the registers out of the frame information.  */

void

void

frame_to_registers (frame, regs)

frame_to_registers (frame, regs)

     struct StackFrame *frame;

     struct StackFrame *frame;

     char *regs;

     char *regs;

{

{

  mem2hex (&frame->ExceptionState.CsavedRegs, &regs[GP0_REGNUM * 4 * 2], 4 * 32, 0);

  mem2hex (&frame->ExceptionState.CsavedRegs, &regs[GP0_REGNUM * 4 * 2], 4 * 32, 0);

  mem2hex (&frame->ExceptionState.CSavedFPRegs, &regs[FP0_REGNUM * 4 * 2], 4 * 32, 0);

  mem2hex (&frame->ExceptionState.CSavedFPRegs, &regs[FP0_REGNUM * 4 * 2], 4 * 32, 0);

  mem2hex (&frame->ExceptionPC, &regs[PC_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionPC, &regs[PC_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedSRR1, &regs[CR_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedSRR1, &regs[CR_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR, &regs[LR_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR, &regs[LR_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR, &regs[CTR_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR, &regs[CTR_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedXER, &regs[XER_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedXER, &regs[XER_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedMQ, &regs[MQ_REGNUM * 4 * 2], 4 * 1, 0);

  mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedMQ, &regs[MQ_REGNUM * 4 * 2], 4 * 1, 0);

}

}

/* Put the registers back into the frame information.  */

/* Put the registers back into the frame information.  */

void

void

registers_to_frame (regs, frame)

registers_to_frame (regs, frame)

     char *regs;

     char *regs;

     struct StackFrame *frame;

     struct StackFrame *frame;

{

{

  hex2mem (&regs[GP0_REGNUM * 4 * 2], &frame->ExceptionState.CsavedRegs, 4 * 32, 0);

  hex2mem (&regs[GP0_REGNUM * 4 * 2], &frame->ExceptionState.CsavedRegs, 4 * 32, 0);

  hex2mem (&regs[FP0_REGNUM * 4 * 2], &frame->ExceptionState.CSavedFPRegs, 4 * 32, 0);

  hex2mem (&regs[FP0_REGNUM * 4 * 2], &frame->ExceptionState.CSavedFPRegs, 4 * 32, 0);

  hex2mem (&regs[PC_REGNUM * 4 * 2], &frame->ExceptionPC, 4 * 1, 0);

  hex2mem (&regs[PC_REGNUM * 4 * 2], &frame->ExceptionPC, 4 * 1, 0);

  hex2mem (&regs[CR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedSRR1, 4 * 1, 0);

  hex2mem (&regs[CR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedSRR1, 4 * 1, 0);

  hex2mem (&regs[LR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR, 4 * 1, 0);

  hex2mem (&regs[LR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR, 4 * 1, 0);

  hex2mem (&regs[CTR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR, 4 * 1, 0);

  hex2mem (&regs[CTR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR, 4 * 1, 0);

  hex2mem (&regs[XER_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedXER, 4 * 1, 0);

  hex2mem (&regs[XER_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedXER, 4 * 1, 0);

  hex2mem (&regs[MQ_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedMQ, 4 * 1, 0);

  hex2mem (&regs[MQ_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedMQ, 4 * 1, 0);

}

}

extern volatile int mem_err;

extern volatile int mem_err;

#ifdef ALTERNATE_MEM_FUNCS

#ifdef ALTERNATE_MEM_FUNCS

extern int ReadByteAltDebugger (char* addr, char *theByte);

extern int ReadByteAltDebugger (char* addr, char *theByte);

extern int WriteByteAltDebugger (char* addr, char theByte);

extern int WriteByteAltDebugger (char* addr, char theByte);

int

int

get_char (addr)

get_char (addr)

     char *addr;

     char *addr;

{

{

  char c;

  char c;

  if (!ReadByteAltDebugger (addr, &c))

  if (!ReadByteAltDebugger (addr, &c))

    mem_err = 1;

    mem_err = 1;

  return c;

  return c;

}

}

void

void

set_char (addr, val)

set_char (addr, val)

     char *addr;

     char *addr;

     int val;

     int val;

{

{

  if (!WriteByteAltDebugger (addr, val))

  if (!WriteByteAltDebugger (addr, val))

    mem_err = 1;

    mem_err = 1;

}

}

#endif

#endif

int

int

mem_write (dst, src, len)

mem_write (dst, src, len)

     char *dst, *src;

     char *dst, *src;

     int len;

     int len;

{

{

  while (len-- && !mem_err)

  while (len-- && !mem_err)

    set_char (dst++, *src++);

    set_char (dst++, *src++);

  return mem_err;

  return mem_err;

}

}

union inst

union inst

{

{

  LONG l;

  LONG l;

  struct

  struct

    {

    {

      union

      union

        {

        {

          struct                /* Unconditional branch */

          struct                /* Unconditional branch */

            {

            {

              unsigned opcode : 6; /* 18 */

              unsigned opcode : 6; /* 18 */

              signed li : 24;

              signed li : 24;

              unsigned aa : 1;

              unsigned aa : 1;

              unsigned lk : 1;

              unsigned lk : 1;

            } b;

            } b;

          struct                /* Conditional branch */

          struct                /* Conditional branch */

            {

            {

              unsigned opcode : 6; /* 16 */

              unsigned opcode : 6; /* 16 */

              unsigned bo : 5;

              unsigned bo : 5;

              unsigned bi : 5;

              unsigned bi : 5;

              signed bd : 14;

              signed bd : 14;

              unsigned aa : 1;

              unsigned aa : 1;

              unsigned lk : 1;

              unsigned lk : 1;

            } bc;

            } bc;

          struct                /* Conditional branch to ctr or lr reg */

          struct                /* Conditional branch to ctr or lr reg */

            {

            {

              unsigned opcode : 6; /* 19 */

              unsigned opcode : 6; /* 19 */

              unsigned bo : 5;

              unsigned bo : 5;

              unsigned bi : 5;

              unsigned bi : 5;

              unsigned type : 15; /* 528 = ctr, 16 = lr */

              unsigned type : 15; /* 528 = ctr, 16 = lr */

              unsigned lk : 1;

              unsigned lk : 1;

            } bclr;

            } bclr;

        } variant;

        } variant;

    } inst;

    } inst;

};

};

static LONG saved_inst;

static LONG saved_inst;

static LONG *saved_inst_pc = 0;

static LONG *saved_inst_pc = 0;

static LONG saved_target_inst;

static LONG saved_target_inst;

static LONG *saved_target_inst_pc = 0;

static LONG *saved_target_inst_pc = 0;

void

void

set_step_traps (frame)

set_step_traps (frame)

     struct StackFrame *frame;

     struct StackFrame *frame;

{

{

  union inst inst;

  union inst inst;

  LONG *target;

  LONG *target;

  int opcode;

  int opcode;

  int ra, rb;

  int ra, rb;

  LONG *pc = (LONG *)frame->ExceptionPC;

  LONG *pc = (LONG *)frame->ExceptionPC;

  inst.l = *pc++;

  inst.l = *pc++;

  opcode = inst.inst.variant.b.opcode;

  opcode = inst.inst.variant.b.opcode;

  target = pc;

  target = pc;

  switch (opcode)

  switch (opcode)

    {

    {

    case 18:                    /* Unconditional branch */

    case 18:                    /* Unconditional branch */

      if (inst.inst.variant.b.aa) /* Absolute? */

      if (inst.inst.variant.b.aa) /* Absolute? */

        target = 0;

        target = 0;

      target += inst.inst.variant.b.li;

      target += inst.inst.variant.b.li;

      break;

      break;

    case 16:                    /* Conditional branch */

    case 16:                    /* Conditional branch */

      if (!inst.inst.variant.bc.aa) /* Absolute? */

      if (!inst.inst.variant.bc.aa) /* Absolute? */

        target = 0;

        target = 0;

      target += inst.inst.variant.bc.bd;

      target += inst.inst.variant.bc.bd;

      break;

      break;

    case 19:                    /* Cond. branch via ctr or lr reg */

    case 19:                    /* Cond. branch via ctr or lr reg */

      switch (inst.inst.variant.bclr.type)

      switch (inst.inst.variant.bclr.type)

        {

        {

        case 528:               /* ctr */

        case 528:               /* ctr */

          target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR;

          target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR;

          break;

          break;

        case 16:                /* lr */

        case 16:                /* lr */

          target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR;

          target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR;

          break;

          break;

        }

        }

      break;

      break;

    }

    }

  saved_inst = *pc;

  saved_inst = *pc;

  mem_write (pc, breakpoint_insn, BREAKPOINT_SIZE);

  mem_write (pc, breakpoint_insn, BREAKPOINT_SIZE);

  saved_inst_pc = pc;

  saved_inst_pc = pc;

  if (target != pc)

  if (target != pc)

    {

    {

      saved_target_inst = *target;

      saved_target_inst = *target;

      mem_write (target, breakpoint_insn, BREAKPOINT_SIZE);

      mem_write (target, breakpoint_insn, BREAKPOINT_SIZE);

      saved_target_inst_pc = target;

      saved_target_inst_pc = target;

    }

    }

}

}

/* Remove step breakpoints.  Returns non-zero if pc was at a step breakpoint,

/* Remove step breakpoints.  Returns non-zero if pc was at a step breakpoint,

   zero otherwise.  This routine works even if there were no step breakpoints

   zero otherwise.  This routine works even if there were no step breakpoints

   set.  */

   set.  */

int

int

clear_step_traps (frame)

clear_step_traps (frame)

     struct StackFrame *frame;

     struct StackFrame *frame;

{

{

  int retcode;

  int retcode;

  LONG *pc = (LONG *)frame->ExceptionPC;

  LONG *pc = (LONG *)frame->ExceptionPC;

  if (saved_inst_pc == pc || saved_target_inst_pc == pc)

  if (saved_inst_pc == pc || saved_target_inst_pc == pc)

    retcode = 1;

    retcode = 1;

  else

  else

    retcode = 0;

    retcode = 0;

  if (saved_inst_pc)

  if (saved_inst_pc)

    {

    {

      mem_write (saved_inst_pc, saved_inst, BREAKPOINT_SIZE);

      mem_write (saved_inst_pc, saved_inst, BREAKPOINT_SIZE);

      saved_inst_pc = 0;

      saved_inst_pc = 0;

    }

    }

  if (saved_target_inst_pc)

  if (saved_target_inst_pc)

    {

    {

      mem_write (saved_target_inst_pc, saved_target_inst, BREAKPOINT_SIZE);

      mem_write (saved_target_inst_pc, saved_target_inst, BREAKPOINT_SIZE);

      saved_target_inst_pc = 0;

      saved_target_inst_pc = 0;

    }

    }

  return retcode;

  return retcode;

}

}

void

void

do_status (ptr, frame)

do_status (ptr, frame)

     char *ptr;

     char *ptr;

     struct StackFrame *frame;

     struct StackFrame *frame;

{

{

  int sigval;

  int sigval;

  sigval = computeSignal (frame->ExceptionNumber);

  sigval = computeSignal (frame->ExceptionNumber);

  sprintf (ptr, "T%02x", sigval);

  sprintf (ptr, "T%02x", sigval);

  ptr += 3;

  ptr += 3;

  sprintf (ptr, "%02x:", PC_REGNUM);

  sprintf (ptr, "%02x:", PC_REGNUM);

  ptr = mem2hex (&frame->ExceptionPC, ptr + 3, 4, 0);

  ptr = mem2hex (&frame->ExceptionPC, ptr + 3, 4, 0);

  *ptr++ = ';';

  *ptr++ = ';';

  sprintf (ptr, "%02x:", SP_REGNUM);

  sprintf (ptr, "%02x:", SP_REGNUM);

  ptr = mem2hex (&frame->ExceptionState.CsavedRegs[SP_REGNUM], ptr + 3, 4, 0);

  ptr = mem2hex (&frame->ExceptionState.CsavedRegs[SP_REGNUM], ptr + 3, 4, 0);

  *ptr++ = ';';

  *ptr++ = ';';

  sprintf (ptr, "%02x:", LR_REGNUM);

  sprintf (ptr, "%02x:", LR_REGNUM);

  ptr = mem2hex (&frame->ExceptionState.CsavedRegs[LR_REGNUM], ptr + 3, 4, 0);

  ptr = mem2hex (&frame->ExceptionState.CsavedRegs[LR_REGNUM], ptr + 3, 4, 0);

  *ptr++ = ';';

  *ptr++ = ';';

  *ptr = '\000';

  *ptr = '\000';

}

}