OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [nlm/] [ppc.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom 
#include <stdio.h>
2 
#include <string.h>
3 
#include <stdlib.h>
4 
#include <time.h>
5 
#include <errno.h>
6 
 
7 
#include <nwtypes.h>
8 
#include <nwdfs.h>
9 
#include <nwconio.h>
10 
#include <nwadv.h>
11 
#include <nwdbgapi.h>
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 
 
65 
extern volatile int mem_err;
66 
 
67 
#ifdef ALTERNATE_MEM_FUNCS
68 
extern int ReadByteAltDebugger (char* addr, char *theByte);
69 
extern int WriteByteAltDebugger (char* addr, char theByte);
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 
#endif
91 
 
92 
int
93 
mem_write (dst, src, len)
94 
     char *dst, *src;
95 
     int len;
96 
{
97 
  while (len-- && !mem_err)
98 
    set_char (dst++, *src++);
99 
 
100 
  return mem_err;
101 
}
102 
 
103 
union inst
104 
{
105 
  LONG l;
106 
 
107 
  struct
108 
    {
109 
      union
110 
        {
111 
          struct                /* Unconditional branch */
112 
            {
113 
              unsigned opcode : 6; /* 18 */
114 
              signed li : 24;
115 
              unsigned aa : 1;
116 
              unsigned lk : 1;
117 
            } b;
118 
          struct                /* Conditional branch */
119 
            {
120 
              unsigned opcode : 6; /* 16 */
121 
              unsigned bo : 5;
122 
              unsigned bi : 5;
123 
              signed bd : 14;
124 
              unsigned aa : 1;
125 
              unsigned lk : 1;
126 
            } bc;
127 
          struct                /* Conditional branch to ctr or lr reg */
128 
            {
129 
              unsigned opcode : 6; /* 19 */
130 
              unsigned bo : 5;
131 
              unsigned bi : 5;
132 
              unsigned type : 15; /* 528 = ctr, 16 = lr */
133 
              unsigned lk : 1;
134 
            } bclr;
135 
        } variant;
136 
    } inst;
137 
};
138 
 
139 
static LONG saved_inst;
140 
static LONG *saved_inst_pc = 0;
141 
static LONG saved_target_inst;
142 
static LONG *saved_target_inst_pc = 0;
143 
 
144 
void
145 
set_step_traps (frame)
146 
     struct StackFrame *frame;
147 
{
148 
  union inst inst;
149 
  LONG *target;
150 
  int opcode;
151 
  int ra, rb;
152 
  LONG *pc = (LONG *)frame->ExceptionPC;
153 
 
154 
  inst.l = *pc++;
155 
 
156 
  opcode = inst.inst.variant.b.opcode;
157 
 
158 
  target = pc;
159 
 
160 
  switch (opcode)
161 
    {
162 
    case 18:                    /* Unconditional branch */
163 
 
164 
      if (inst.inst.variant.b.aa) /* Absolute? */
165 
        target = 0;
166 
      target += inst.inst.variant.b.li;
167 
 
168 
      break;
169 
    case 16:                    /* Conditional branch */
170 
 
171 
      if (!inst.inst.variant.bc.aa) /* Absolute? */
172 
        target = 0;
173 
      target += inst.inst.variant.bc.bd;
174 
 
175 
      break;
176 
    case 19:                    /* Cond. branch via ctr or lr reg */
177 
      switch (inst.inst.variant.bclr.type)
178 
        {
179 
        case 528:               /* ctr */
180 
          target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR;
181 
          break;
182 
        case 16:                /* lr */
183 
          target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR;
184 
          break;
185 
        }
186 
      break;
187 
    }
188 
 
189 
  saved_inst = *pc;
190 
  mem_write (pc, breakpoint_insn, BREAKPOINT_SIZE);
191 
  saved_inst_pc = pc;
192 
 
193 
  if (target != pc)
194 
    {
195 
      saved_target_inst = *target;
196 
      mem_write (target, breakpoint_insn, BREAKPOINT_SIZE);
197 
      saved_target_inst_pc = target;
198 
    }
199 
}
200 
 
201 
/* Remove step breakpoints.  Returns non-zero if pc was at a step breakpoint,
202 
   zero otherwise.  This routine works even if there were no step breakpoints
203 
   set.  */
204 
 
205 
int
206 
clear_step_traps (frame)
207 
     struct StackFrame *frame;
208 
{
209 
  int retcode;
210 
  LONG *pc = (LONG *)frame->ExceptionPC;
211 
 
212 
  if (saved_inst_pc == pc || saved_target_inst_pc == pc)
213 
    retcode = 1;
214 
  else
215 
    retcode = 0;
216 
 
217 
  if (saved_inst_pc)
218 
    {
219 
      mem_write (saved_inst_pc, saved_inst, BREAKPOINT_SIZE);
220 
      saved_inst_pc = 0;
221 
    }
222 
 
223 
  if (saved_target_inst_pc)
224 
    {
225 
      mem_write (saved_target_inst_pc, saved_target_inst, BREAKPOINT_SIZE);
226 
      saved_target_inst_pc = 0;
227 
    }
228 
 
229 
  return retcode;
230 
}
231 
 
232 
void
233 
do_status (ptr, frame)
234 
     char *ptr;
235 
     struct StackFrame *frame;
236 
{
237 
  int sigval;
238 
 
239 
  sigval = computeSignal (frame->ExceptionNumber);
240 
 
241 
  sprintf (ptr, "T%02x", sigval);
242 
  ptr += 3;
243 
 
244 
  sprintf (ptr, "%02x:", PC_REGNUM);
245 
  ptr = mem2hex (&frame->ExceptionPC, ptr + 3, 4, 0);
246 
  *ptr++ = ';';
247 
 
248 
  sprintf (ptr, "%02x:", SP_REGNUM);
249 
  ptr = mem2hex (&frame->ExceptionState.CsavedRegs[SP_REGNUM], ptr + 3, 4, 0);
250 
  *ptr++ = ';';
251 
 
252 
  sprintf (ptr, "%02x:", LR_REGNUM);
253 
  ptr = mem2hex (&frame->ExceptionState.CsavedRegs[LR_REGNUM], ptr + 3, 4, 0);
254 
  *ptr++ = ';';
255 
 
256 
  *ptr = '\000';
257 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.