[deliverable/binutils-gdb.git] / gdb / nlm / ppc.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <errno.h>

#include <nwtypes.h>
#include <nwdfs.h>
#include <nwconio.h>
#include <nwadv.h>
#include <nwdbgapi.h>
#include <nwthread.h>
#include "ppc.h"

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 int computeSignal (int exceptionVector);

void
flush_i_cache (void)
{
}

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

void
frame_to_registers (frame, regs)
     struct StackFrame *frame;
     char *regs;
{
  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->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.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.CsavedXER, &regs[XER_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.  */

void
registers_to_frame (regs, frame)
     char *regs;
     struct StackFrame *frame;
{
  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[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[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[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);
}

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

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

extern volatile int mem_err;

int
get_char (addr)
     char *addr;
{
  char c;

  if (!ReadByteAltDebugger (addr, &c))
    mem_err = 1;

  return c;
}

void
set_char (addr, val)
     char *addr;
     int val;
{
  if (!WriteByteAltDebugger (addr, val))
    mem_err = 1;
}

int
mem_write (dst, src, len)
     char *dst, *src;
     int len;
{
  while (len-- && !mem_err)
    set_char (dst++, *src++);

  return mem_err;
}

union inst
{
  LONG l;

  struct
    {
      union
	{
	  struct		/* Unconditional branch */
	    {
	      unsigned opcode : 6; /* 18 */
	      signed li : 24;
	      unsigned aa : 1;
	      unsigned lk : 1;
	    } b;
	  struct		/* Conditional branch */
	    {
	      unsigned opcode : 6; /* 16 */
	      unsigned bo : 5;
	      unsigned bi : 5;
	      signed bd : 14;
	      unsigned aa : 1;
	      unsigned lk : 1;
	    } bc;
	  struct		/* Conditional branch to ctr or lr reg */
	    {
	      unsigned opcode : 6; /* 19 */
	      unsigned bo : 5;
	      unsigned bi : 5;
	      unsigned type : 15; /* 528 = ctr, 16 = lr */
	      unsigned lk : 1;
	    } bclr;
	} variant;
    } inst;
};

static LONG saved_inst;
static LONG *saved_inst_pc = 0;
static LONG saved_target_inst;
static LONG *saved_target_inst_pc = 0;

void
set_step_traps (frame)
     struct StackFrame *frame;
{
  union inst inst;
  LONG *target;
  int opcode;
  int ra, rb;
  LONG *pc = (LONG *)frame->ExceptionPC;

  inst.l = *pc++;

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

  target = pc;

  switch (opcode)
    {
    case 18:			/* Unconditional branch */

      if (inst.inst.variant.b.aa) /* Absolute? */
	target = 0;
      target += inst.inst.variant.b.li;

      break;
    case 16:			/* Conditional branch */

      if (!inst.inst.variant.bc.aa) /* Absolute? */
	target = 0;
      target += inst.inst.variant.bc.bd;

      break;
    case 19:			/* Cond. branch via ctr or lr reg */
      switch (inst.inst.variant.bclr.type)
	{
	case 528:		/* ctr */
	  target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR;
	  break;
	case 16:		/* lr */
	  target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR;
	  break;
	}
      break;
    }

  saved_inst = *pc;
  mem_write (pc, breakpoint_insn, BREAKPOINT_SIZE);
  saved_inst_pc = pc;

  if (target != pc)
    {
      saved_target_inst = *target;
      mem_write (target, breakpoint_insn, BREAKPOINT_SIZE);
      saved_target_inst_pc = target;
    }
}

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

int
clear_step_traps (frame)
     struct StackFrame *frame;
{
  int retcode;
  LONG *pc = (LONG *)frame->ExceptionPC;

  if (saved_inst_pc == pc || saved_target_inst_pc == pc)
    retcode = 1;
  else
    retcode = 0;

  if (saved_inst_pc)
    {
      mem_write (saved_inst_pc, saved_inst, BREAKPOINT_SIZE);
      saved_inst_pc = 0;
    }

  if (saved_target_inst_pc)
    {
      mem_write (saved_target_inst_pc, saved_target_inst, BREAKPOINT_SIZE);
      saved_target_inst_pc = 0;
    }

  return retcode;
}

void
do_status (ptr, frame)
     char *ptr;
     struct StackFrame *frame;
{
  int sigval;

  sigval = computeSignal (frame->ExceptionNumber);

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

  sprintf (ptr, "%02x:", PC_REGNUM);
  ptr = mem2hex (&frame->ExceptionPC, ptr + 3, 4, 0);
  *ptr++ = ';';

  sprintf (ptr, "%02x:", SP_REGNUM);
  ptr = mem2hex (&frame->ExceptionState.CsavedRegs[SP_REGNUM], ptr + 3, 4, 0);
  *ptr++ = ';';

  sprintf (ptr, "%02x:", LR_REGNUM);
  ptr = mem2hex (&frame->ExceptionState.CsavedRegs[LR_REGNUM], ptr + 3, 4, 0);
  *ptr++ = ';';

  *ptr = '\000';
}

void
StopBell()
{
}
Commit	Line	Data
b7da2494 SG	1	#include <stdio.h>
	2	#include <string.h>
	3	#include <stdlib.h>
	4	#include <time.h>
9db29b17 C	5	#include <errno.h>
	6
	7	#include <nwtypes.h>
	8	#include <nwdfs.h>
b7da2494 SG	9	#include <nwconio.h>
	10	#include <nwadv.h>
	11	#include <nwdbgapi.h>
b7da2494 SG	12	#include <nwthread.h>
	13	#include "ppc.h"
	14
	15	extern char mem2hex (void mem, char *buf, int count, int may_fault);
	16	extern char hex2mem (char buf, void *mem, int count, int may_fault);
	17	extern int computeSignal (int exceptionVector);
	18
	19	void
	20	flush_i_cache (void)
	21	{
	22	}
	23
	24	/* Get the registers out of the frame information. */
	25
	26	void
	27	frame_to_registers (frame, regs)
	28	struct StackFrame *frame;
	29	char *regs;
	30	{
	31	mem2hex (&frame->ExceptionState.CsavedRegs, &regs[GP0_REGNUM * 4 * 2], 4 * 32, 0);
	32
	33	mem2hex (&frame->ExceptionState.CSavedFPRegs, &regs[FP0_REGNUM * 4 * 2], 4 * 32, 0);
	34
	35	mem2hex (&frame->ExceptionPC, &regs[PC_REGNUM * 4 * 2], 4 * 1, 0);
	36
	37	mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedSRR1, &regs[CR_REGNUM * 4 * 2], 4 * 1, 0);
	38	mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR, &regs[LR_REGNUM * 4 * 2], 4 * 1, 0);
	39	mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR, &regs[CTR_REGNUM * 4 * 2], 4 * 1, 0);
	40	mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedXER, &regs[XER_REGNUM * 4 * 2], 4 * 1, 0);
	41	mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedMQ, &regs[MQ_REGNUM * 4 * 2], 4 * 1, 0);
	42	}
	43
	44	/* Put the registers back into the frame information. */
	45
	46	void
	47	registers_to_frame (regs, frame)
	48	char *regs;
	49	struct StackFrame *frame;
	50	{
	51	hex2mem (&regs[GP0_REGNUM * 4 * 2], &frame->ExceptionState.CsavedRegs, 4 * 32, 0);
	52
	53	hex2mem (&regs[FP0_REGNUM * 4 * 2], &frame->ExceptionState.CSavedFPRegs, 4 * 32, 0);
	54
	55	hex2mem (&regs[PC_REGNUM * 4 * 2], &frame->ExceptionPC, 4 * 1, 0);
	56
	57	hex2mem (&regs[CR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedSRR1, 4 * 1, 0);
	58	hex2mem (&regs[LR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR, 4 * 1, 0);
	59	hex2mem (&regs[CTR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR, 4 * 1, 0);
	60	hex2mem (&regs[XER_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedXER, 4 * 1, 0);
	61	hex2mem (&regs[MQ_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedMQ, 4 * 1, 0);
	62	}
	63
	64	extern int ReadByteAltDebugger (char* addr, char *theByte);
	65
	66	extern int WriteByteAltDebugger (char* addr, char theByte);
	67
	68	extern volatile int mem_err;
	69
	70	int
	71	get_char (addr)
	72	char *addr;
	73	{
	74	char c;
	75
76	if (!ReadByteAltDebugger (addr, &c))
77	mem_err = 1;
78
79	return c;
80	}
81
82	void
83	set_char (addr, val)
84	char *addr;
85	int val;
86	{
87	if (!WriteByteAltDebugger (addr, val))
88	mem_err = 1;
89	}
90
91	int
92	mem_write (dst, src, len)
93	char dst, src;
94	int len;
95	{
96	while (len-- && !mem_err)
97	set_char (dst++, *src++);
98
99	return mem_err;
100	}
101
102	union inst
103	{
104	LONG l;
105
106	struct
107	{
108	union
109	{
110	struct /* Unconditional branch */
111	{
112	unsigned opcode : 6; /* 18 */
113	signed li : 24;
114	unsigned aa : 1;
115	unsigned lk : 1;
116	} b;
117	struct /* Conditional branch */
118	{
119	unsigned opcode : 6; /* 16 */
120	unsigned bo : 5;
121	unsigned bi : 5;
122	signed bd : 14;
123	unsigned aa : 1;
124	unsigned lk : 1;
125	} bc;
126	struct /* Conditional branch to ctr or lr reg */
127	{
128	unsigned opcode : 6; /* 19 */
129	unsigned bo : 5;
130	unsigned bi : 5;
131	unsigned type : 15; /* 528 = ctr, 16 = lr */
132	unsigned lk : 1;
133	} bclr;
134	} variant;
135	} inst;
136	};
137
138	static LONG saved_inst;
8edf0016	139	static LONG *saved_inst_pc = 0;
b7da2494	140	static LONG saved_target_inst;
8edf0016	141	static LONG *saved_target_inst_pc = 0;
b7da2494 SG	142
	143	void
	144	set_step_traps (frame)
	145	struct StackFrame *frame;
	146	{
	147	union inst inst;
8edf0016	148	LONG *target;
b7da2494 SG	149	int opcode;
b7da2494 SG	150	int ra, rb;
8edf0016	151	LONG pc = (LONG )frame->ExceptionPC;
b7da2494	152
8edf0016	153	inst.l = *pc++;
b7da2494 SG	154
	155	opcode = inst.inst.variant.b.opcode;
	156
8edf0016 SG	157	target = pc;
8edf0016 SG	158
b7da2494 SG	159	switch (opcode)
	160	{
	161	case 18: /* Unconditional branch */
b7da2494	162
8edf0016 SG	163	if (inst.inst.variant.b.aa) /* Absolute? */
	164	target = 0;
	165	target += inst.inst.variant.b.li;
b7da2494 SG	166
	167	break;
	168	case 16: /* Conditional branch */
b7da2494	169
8edf0016 SG	170	if (!inst.inst.variant.bc.aa) /* Absolute? */
	171	target = 0;
	172	target += inst.inst.variant.bc.bd;
b7da2494 SG	173
	174	break;
	175	case 19: /* Cond. branch via ctr or lr reg */
	176	switch (inst.inst.variant.bclr.type)
	177	{
	178	case 528: /* ctr */
8edf0016	179	target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR;
b7da2494 SG	180	break;
b7da2494 SG	181	case 16: /* lr */
8edf0016	182	target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR;
b7da2494	183	break;
b7da2494 SG	184	}
b7da2494 SG	185	break;
b7da2494 SG	186	}
b7da2494 SG	187
8edf0016	188	saved_inst = *pc;
b7da2494 SG	189	mem_write (pc, breakpoint_insn, BREAKPOINT_SIZE);
	190	saved_inst_pc = pc;
	191
	192	if (target != pc)
	193	{
8edf0016	194	saved_target_inst = *target;
b7da2494 SG	195	mem_write (target, breakpoint_insn, BREAKPOINT_SIZE);
	196	saved_target_inst_pc = target;
	197	}
	198	}
	199
	200	/* Remove step breakpoints. Returns non-zero if pc was at a step breakpoint,
	201	zero otherwise. This routine works even if there were no step breakpoints
	202	set. */
	203
	204	int
	205	clear_step_traps (frame)
	206	struct StackFrame *frame;
	207	{
	208	int retcode;
8edf0016	209	LONG pc = (LONG )frame->ExceptionPC;
b7da2494 SG	210
	211	if (saved_inst_pc == pc \|\| saved_target_inst_pc == pc)
	212	retcode = 1;
	213	else
	214	retcode = 0;
	215
	216	if (saved_inst_pc)
	217	{
	218	mem_write (saved_inst_pc, saved_inst, BREAKPOINT_SIZE);
	219	saved_inst_pc = 0;
	220	}
	221
	222	if (saved_target_inst_pc)
	223	{
	224	mem_write (saved_target_inst_pc, saved_target_inst, BREAKPOINT_SIZE);
	225	saved_target_inst_pc = 0;
	226	}
	227
	228	return retcode;
	229	}
	230
	231	void
	232	do_status (ptr, frame)
	233	char *ptr;
	234	struct StackFrame *frame;
	235	{
	236	int sigval;
	237
	238	sigval = computeSignal (frame->ExceptionNumber);
	239
	240	sprintf (ptr, "T%02x", sigval);
	241	ptr += 3;
	242
	243	sprintf (ptr, "%02x:", PC_REGNUM);
	244	ptr = mem2hex (&frame->ExceptionPC, ptr + 3, 4, 0);
	245	*ptr++ = ';';
	246
	247	sprintf (ptr, "%02x:", SP_REGNUM);
	248	ptr = mem2hex (&frame->ExceptionState.CsavedRegs[SP_REGNUM], ptr + 3, 4, 0);
	249	*ptr++ = ';';
	250
	251	sprintf (ptr, "%02x:", LR_REGNUM);
	252	ptr = mem2hex (&frame->ExceptionState.CsavedRegs[LR_REGNUM], ptr + 3, 4, 0);
	253	*ptr++ = ';';
	254
	255	*ptr = '\000';
	256	}
	257
b7da2494	258	void
9db29b17	259	StopBell()
b7da2494	260	{
b7da2494	261	}