1 |
1181 |
sfurman |
/* Target dependent code for the NS32000, for GDB.
|
2 |
|
|
Copyright 1986, 1988, 1991, 1992, 1994, 1995, 1998, 1999, 2000, 2001,
|
3 |
|
|
2002 Free Software Foundation, Inc.
|
4 |
|
|
|
5 |
|
|
This file is part of GDB.
|
6 |
|
|
|
7 |
|
|
This program is free software; you can redistribute it and/or modify
|
8 |
|
|
it under the terms of the GNU General Public License as published by
|
9 |
|
|
the Free Software Foundation; either version 2 of the License, or
|
10 |
|
|
(at your option) any later version.
|
11 |
|
|
|
12 |
|
|
This program is distributed in the hope that it will be useful,
|
13 |
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
14 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
15 |
|
|
GNU General Public License for more details.
|
16 |
|
|
|
17 |
|
|
You should have received a copy of the GNU General Public License
|
18 |
|
|
along with this program; if not, write to the Free Software
|
19 |
|
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
20 |
|
|
Boston, MA 02111-1307, USA. */
|
21 |
|
|
|
22 |
|
|
#include "defs.h"
|
23 |
|
|
#include "frame.h"
|
24 |
|
|
#include "gdbtypes.h"
|
25 |
|
|
#include "gdbcore.h"
|
26 |
|
|
#include "inferior.h"
|
27 |
|
|
#include "regcache.h"
|
28 |
|
|
#include "target.h"
|
29 |
|
|
#include "gdb_string.h"
|
30 |
|
|
|
31 |
|
|
#include "arch-utils.h"
|
32 |
|
|
|
33 |
|
|
#include "ns32k-tdep.h"
|
34 |
|
|
|
35 |
|
|
static int sign_extend (int value, int bits);
|
36 |
|
|
static CORE_ADDR ns32k_get_enter_addr (CORE_ADDR);
|
37 |
|
|
static int ns32k_localcount (CORE_ADDR enter_pc);
|
38 |
|
|
static void flip_bytes (void *, int);
|
39 |
|
|
|
40 |
|
|
static const char *
|
41 |
|
|
ns32k_register_name_32082 (int regno)
|
42 |
|
|
{
|
43 |
|
|
static char *register_names[] =
|
44 |
|
|
{
|
45 |
|
|
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
|
46 |
|
|
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
|
47 |
|
|
"sp", "fp", "pc", "ps",
|
48 |
|
|
"l0", "l1", "l2", "l3", "xx",
|
49 |
|
|
};
|
50 |
|
|
|
51 |
|
|
if (regno < 0)
|
52 |
|
|
return NULL;
|
53 |
|
|
if (regno >= sizeof (register_names) / sizeof (*register_names))
|
54 |
|
|
return NULL;
|
55 |
|
|
|
56 |
|
|
return (register_names[regno]);
|
57 |
|
|
}
|
58 |
|
|
|
59 |
|
|
static const char *
|
60 |
|
|
ns32k_register_name_32382 (int regno)
|
61 |
|
|
{
|
62 |
|
|
static char *register_names[] =
|
63 |
|
|
{
|
64 |
|
|
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
|
65 |
|
|
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
|
66 |
|
|
"sp", "fp", "pc", "ps",
|
67 |
|
|
"fsr",
|
68 |
|
|
"l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7", "xx",
|
69 |
|
|
};
|
70 |
|
|
|
71 |
|
|
if (regno < 0)
|
72 |
|
|
return NULL;
|
73 |
|
|
if (regno >= sizeof (register_names) / sizeof (*register_names))
|
74 |
|
|
return NULL;
|
75 |
|
|
|
76 |
|
|
return (register_names[regno]);
|
77 |
|
|
}
|
78 |
|
|
|
79 |
|
|
static int
|
80 |
|
|
ns32k_register_byte_32082 (int regno)
|
81 |
|
|
{
|
82 |
|
|
if (regno >= NS32K_LP0_REGNUM)
|
83 |
|
|
return (NS32K_LP0_REGNUM * 4) + ((regno - NS32K_LP0_REGNUM) * 8);
|
84 |
|
|
|
85 |
|
|
return (regno * 4);
|
86 |
|
|
}
|
87 |
|
|
|
88 |
|
|
static int
|
89 |
|
|
ns32k_register_byte_32382 (int regno)
|
90 |
|
|
{
|
91 |
|
|
/* This is a bit yuk. The even numbered double precision floating
|
92 |
|
|
point long registers occupy the same space as the even:odd numbered
|
93 |
|
|
single precision floating point registers, but the extra 32381 FPU
|
94 |
|
|
registers are at the end. Doing it this way is compatible for both
|
95 |
|
|
32081 and 32381 equipped machines. */
|
96 |
|
|
|
97 |
|
|
return ((regno < NS32K_LP0_REGNUM ? regno
|
98 |
|
|
: (regno - NS32K_LP0_REGNUM) & 1 ? regno - 1
|
99 |
|
|
: (regno - NS32K_LP0_REGNUM + FP0_REGNUM)) * 4);
|
100 |
|
|
}
|
101 |
|
|
|
102 |
|
|
static int
|
103 |
|
|
ns32k_register_raw_size (int regno)
|
104 |
|
|
{
|
105 |
|
|
/* All registers are 4 bytes, except for the doubled floating
|
106 |
|
|
registers. */
|
107 |
|
|
|
108 |
|
|
return ((regno >= NS32K_LP0_REGNUM) ? 8 : 4);
|
109 |
|
|
}
|
110 |
|
|
|
111 |
|
|
static int
|
112 |
|
|
ns32k_register_virtual_size (int regno)
|
113 |
|
|
{
|
114 |
|
|
return ((regno >= NS32K_LP0_REGNUM) ? 8 : 4);
|
115 |
|
|
}
|
116 |
|
|
|
117 |
|
|
static struct type *
|
118 |
|
|
ns32k_register_virtual_type (int regno)
|
119 |
|
|
{
|
120 |
|
|
if (regno < FP0_REGNUM)
|
121 |
|
|
return (builtin_type_int);
|
122 |
|
|
|
123 |
|
|
if (regno < FP0_REGNUM + 8)
|
124 |
|
|
return (builtin_type_float);
|
125 |
|
|
|
126 |
|
|
if (regno < NS32K_LP0_REGNUM)
|
127 |
|
|
return (builtin_type_int);
|
128 |
|
|
|
129 |
|
|
return (builtin_type_double);
|
130 |
|
|
}
|
131 |
|
|
|
132 |
|
|
/* Immediately after a function call, return the saved PC. Can't
|
133 |
|
|
always go through the frames for this because on some systems,
|
134 |
|
|
the new frame is not set up until the new function executes some
|
135 |
|
|
instructions. */
|
136 |
|
|
|
137 |
|
|
static CORE_ADDR
|
138 |
|
|
ns32k_saved_pc_after_call (struct frame_info *frame)
|
139 |
|
|
{
|
140 |
|
|
return (read_memory_integer (read_register (SP_REGNUM), 4));
|
141 |
|
|
}
|
142 |
|
|
|
143 |
|
|
/* Advance PC across any function entry prologue instructions
|
144 |
|
|
to reach some "real" code. */
|
145 |
|
|
|
146 |
|
|
static CORE_ADDR
|
147 |
|
|
umax_skip_prologue (CORE_ADDR pc)
|
148 |
|
|
{
|
149 |
|
|
register unsigned char op = read_memory_integer (pc, 1);
|
150 |
|
|
if (op == 0x82)
|
151 |
|
|
{
|
152 |
|
|
op = read_memory_integer (pc + 2, 1);
|
153 |
|
|
if ((op & 0x80) == 0)
|
154 |
|
|
pc += 3;
|
155 |
|
|
else if ((op & 0xc0) == 0x80)
|
156 |
|
|
pc += 4;
|
157 |
|
|
else
|
158 |
|
|
pc += 6;
|
159 |
|
|
}
|
160 |
|
|
return pc;
|
161 |
|
|
}
|
162 |
|
|
|
163 |
|
|
static const unsigned char *
|
164 |
|
|
ns32k_breakpoint_from_pc (CORE_ADDR *pcp, int *lenp)
|
165 |
|
|
{
|
166 |
|
|
static const unsigned char breakpoint_insn[] = { 0xf2 };
|
167 |
|
|
|
168 |
|
|
*lenp = sizeof (breakpoint_insn);
|
169 |
|
|
return breakpoint_insn;
|
170 |
|
|
}
|
171 |
|
|
|
172 |
|
|
/* Return number of args passed to a frame.
|
173 |
|
|
Can return -1, meaning no way to tell.
|
174 |
|
|
Encore's C compiler often reuses same area on stack for args,
|
175 |
|
|
so this will often not work properly. If the arg names
|
176 |
|
|
are known, it's likely most of them will be printed. */
|
177 |
|
|
|
178 |
|
|
static int
|
179 |
|
|
umax_frame_num_args (struct frame_info *fi)
|
180 |
|
|
{
|
181 |
|
|
int numargs;
|
182 |
|
|
CORE_ADDR pc;
|
183 |
|
|
CORE_ADDR enter_addr;
|
184 |
|
|
unsigned int insn;
|
185 |
|
|
unsigned int addr_mode;
|
186 |
|
|
int width;
|
187 |
|
|
|
188 |
|
|
numargs = -1;
|
189 |
|
|
enter_addr = ns32k_get_enter_addr ((fi)->pc);
|
190 |
|
|
if (enter_addr > 0)
|
191 |
|
|
{
|
192 |
|
|
pc = ((enter_addr == 1)
|
193 |
|
|
? SAVED_PC_AFTER_CALL (fi)
|
194 |
|
|
: FRAME_SAVED_PC (fi));
|
195 |
|
|
insn = read_memory_integer (pc, 2);
|
196 |
|
|
addr_mode = (insn >> 11) & 0x1f;
|
197 |
|
|
insn = insn & 0x7ff;
|
198 |
|
|
if ((insn & 0x7fc) == 0x57c
|
199 |
|
|
&& addr_mode == 0x14) /* immediate */
|
200 |
|
|
{
|
201 |
|
|
if (insn == 0x57c) /* adjspb */
|
202 |
|
|
width = 1;
|
203 |
|
|
else if (insn == 0x57d) /* adjspw */
|
204 |
|
|
width = 2;
|
205 |
|
|
else if (insn == 0x57f) /* adjspd */
|
206 |
|
|
width = 4;
|
207 |
|
|
else
|
208 |
|
|
internal_error (__FILE__, __LINE__, "bad else");
|
209 |
|
|
numargs = read_memory_integer (pc + 2, width);
|
210 |
|
|
if (width > 1)
|
211 |
|
|
flip_bytes (&numargs, width);
|
212 |
|
|
numargs = -sign_extend (numargs, width * 8) / 4;
|
213 |
|
|
}
|
214 |
|
|
}
|
215 |
|
|
return numargs;
|
216 |
|
|
}
|
217 |
|
|
|
218 |
|
|
static int
|
219 |
|
|
sign_extend (int value, int bits)
|
220 |
|
|
{
|
221 |
|
|
value = value & ((1 << bits) - 1);
|
222 |
|
|
return (value & (1 << (bits - 1))
|
223 |
|
|
? value | (~((1 << bits) - 1))
|
224 |
|
|
: value);
|
225 |
|
|
}
|
226 |
|
|
|
227 |
|
|
static void
|
228 |
|
|
flip_bytes (void *p, int count)
|
229 |
|
|
{
|
230 |
|
|
char tmp;
|
231 |
|
|
char *ptr = 0;
|
232 |
|
|
|
233 |
|
|
while (count > 0)
|
234 |
|
|
{
|
235 |
|
|
tmp = *ptr;
|
236 |
|
|
ptr[0] = ptr[count - 1];
|
237 |
|
|
ptr[count - 1] = tmp;
|
238 |
|
|
ptr++;
|
239 |
|
|
count -= 2;
|
240 |
|
|
}
|
241 |
|
|
}
|
242 |
|
|
|
243 |
|
|
/* Return the number of locals in the current frame given a
|
244 |
|
|
pc pointing to the enter instruction. This is used by
|
245 |
|
|
ns32k_frame_init_saved_regs. */
|
246 |
|
|
|
247 |
|
|
static int
|
248 |
|
|
ns32k_localcount (CORE_ADDR enter_pc)
|
249 |
|
|
{
|
250 |
|
|
unsigned char localtype;
|
251 |
|
|
int localcount;
|
252 |
|
|
|
253 |
|
|
localtype = read_memory_integer (enter_pc + 2, 1);
|
254 |
|
|
if ((localtype & 0x80) == 0)
|
255 |
|
|
localcount = localtype;
|
256 |
|
|
else if ((localtype & 0xc0) == 0x80)
|
257 |
|
|
localcount = (((localtype & 0x3f) << 8)
|
258 |
|
|
| (read_memory_integer (enter_pc + 3, 1) & 0xff));
|
259 |
|
|
else
|
260 |
|
|
localcount = (((localtype & 0x3f) << 24)
|
261 |
|
|
| ((read_memory_integer (enter_pc + 3, 1) & 0xff) << 16)
|
262 |
|
|
| ((read_memory_integer (enter_pc + 4, 1) & 0xff) << 8)
|
263 |
|
|
| (read_memory_integer (enter_pc + 5, 1) & 0xff));
|
264 |
|
|
return localcount;
|
265 |
|
|
}
|
266 |
|
|
|
267 |
|
|
|
268 |
|
|
/* Nonzero if instruction at PC is a return instruction. */
|
269 |
|
|
|
270 |
|
|
static int
|
271 |
|
|
ns32k_about_to_return (CORE_ADDR pc)
|
272 |
|
|
{
|
273 |
|
|
return (read_memory_integer (pc, 1) == 0x12);
|
274 |
|
|
}
|
275 |
|
|
|
276 |
|
|
/* Get the address of the enter opcode for this function, if it is active.
|
277 |
|
|
Returns positive address > 1 if pc is between enter/exit,
|
278 |
|
|
1 if pc before enter or after exit, 0 otherwise. */
|
279 |
|
|
static CORE_ADDR
|
280 |
|
|
ns32k_get_enter_addr (CORE_ADDR pc)
|
281 |
|
|
{
|
282 |
|
|
CORE_ADDR enter_addr;
|
283 |
|
|
unsigned char op;
|
284 |
|
|
|
285 |
|
|
if (pc == 0)
|
286 |
|
|
return 0;
|
287 |
|
|
|
288 |
|
|
if (ns32k_about_to_return (pc))
|
289 |
|
|
return 1; /* after exit */
|
290 |
|
|
|
291 |
|
|
enter_addr = get_pc_function_start (pc);
|
292 |
|
|
|
293 |
|
|
if (pc == enter_addr)
|
294 |
|
|
return 1; /* before enter */
|
295 |
|
|
|
296 |
|
|
op = read_memory_integer (enter_addr, 1);
|
297 |
|
|
|
298 |
|
|
if (op != 0x82)
|
299 |
|
|
return 0; /* function has no enter/exit */
|
300 |
|
|
|
301 |
|
|
return enter_addr; /* pc is between enter and exit */
|
302 |
|
|
}
|
303 |
|
|
|
304 |
|
|
static CORE_ADDR
|
305 |
|
|
ns32k_frame_chain (struct frame_info *frame)
|
306 |
|
|
{
|
307 |
|
|
/* In the case of the NS32000 series, the frame's nominal address is the
|
308 |
|
|
FP value, and that address is saved at the previous FP value as a
|
309 |
|
|
4-byte word. */
|
310 |
|
|
|
311 |
|
|
if (inside_entry_file (frame->pc))
|
312 |
|
|
return 0;
|
313 |
|
|
|
314 |
|
|
return (read_memory_integer (frame->frame, 4));
|
315 |
|
|
}
|
316 |
|
|
|
317 |
|
|
static CORE_ADDR
|
318 |
|
|
ns32k_frame_saved_pc (struct frame_info *frame)
|
319 |
|
|
{
|
320 |
|
|
if (frame->signal_handler_caller)
|
321 |
|
|
return (sigtramp_saved_pc (frame)); /* XXXJRT */
|
322 |
|
|
|
323 |
|
|
return (read_memory_integer (frame->frame + 4, 4));
|
324 |
|
|
}
|
325 |
|
|
|
326 |
|
|
static CORE_ADDR
|
327 |
|
|
ns32k_frame_args_address (struct frame_info *frame)
|
328 |
|
|
{
|
329 |
|
|
if (ns32k_get_enter_addr (frame->pc) > 1)
|
330 |
|
|
return (frame->frame);
|
331 |
|
|
|
332 |
|
|
return (read_register (SP_REGNUM) - 4);
|
333 |
|
|
}
|
334 |
|
|
|
335 |
|
|
static CORE_ADDR
|
336 |
|
|
ns32k_frame_locals_address (struct frame_info *frame)
|
337 |
|
|
{
|
338 |
|
|
return (frame->frame);
|
339 |
|
|
}
|
340 |
|
|
|
341 |
|
|
/* Code to initialize the addresses of the saved registers of frame described
|
342 |
|
|
by FRAME_INFO. This includes special registers such as pc and fp saved in
|
343 |
|
|
special ways in the stack frame. sp is even more special: the address we
|
344 |
|
|
return for it IS the sp for the next frame. */
|
345 |
|
|
|
346 |
|
|
static void
|
347 |
|
|
ns32k_frame_init_saved_regs (struct frame_info *frame)
|
348 |
|
|
{
|
349 |
|
|
int regmask, regnum;
|
350 |
|
|
int localcount;
|
351 |
|
|
CORE_ADDR enter_addr, next_addr;
|
352 |
|
|
|
353 |
|
|
if (frame->saved_regs)
|
354 |
|
|
return;
|
355 |
|
|
|
356 |
|
|
frame_saved_regs_zalloc (frame);
|
357 |
|
|
|
358 |
|
|
enter_addr = ns32k_get_enter_addr (frame->pc);
|
359 |
|
|
if (enter_addr > 1)
|
360 |
|
|
{
|
361 |
|
|
regmask = read_memory_integer (enter_addr + 1, 1) & 0xff;
|
362 |
|
|
localcount = ns32k_localcount (enter_addr);
|
363 |
|
|
next_addr = frame->frame + localcount;
|
364 |
|
|
|
365 |
|
|
for (regnum = 0; regnum < 8; regnum++)
|
366 |
|
|
{
|
367 |
|
|
if (regmask & (1 << regnum))
|
368 |
|
|
frame->saved_regs[regnum] = next_addr -= 4;
|
369 |
|
|
}
|
370 |
|
|
|
371 |
|
|
frame->saved_regs[SP_REGNUM] = frame->frame + 4;
|
372 |
|
|
frame->saved_regs[PC_REGNUM] = frame->frame + 4;
|
373 |
|
|
frame->saved_regs[FP_REGNUM] = read_memory_integer (frame->frame, 4);
|
374 |
|
|
}
|
375 |
|
|
else if (enter_addr == 1)
|
376 |
|
|
{
|
377 |
|
|
CORE_ADDR sp = read_register (SP_REGNUM);
|
378 |
|
|
frame->saved_regs[PC_REGNUM] = sp;
|
379 |
|
|
frame->saved_regs[SP_REGNUM] = sp + 4;
|
380 |
|
|
}
|
381 |
|
|
}
|
382 |
|
|
|
383 |
|
|
static void
|
384 |
|
|
ns32k_push_dummy_frame (void)
|
385 |
|
|
{
|
386 |
|
|
CORE_ADDR sp = read_register (SP_REGNUM);
|
387 |
|
|
int regnum;
|
388 |
|
|
|
389 |
|
|
sp = push_word (sp, read_register (PC_REGNUM));
|
390 |
|
|
sp = push_word (sp, read_register (FP_REGNUM));
|
391 |
|
|
write_register (FP_REGNUM, sp);
|
392 |
|
|
|
393 |
|
|
for (regnum = 0; regnum < 8; regnum++)
|
394 |
|
|
sp = push_word (sp, read_register (regnum));
|
395 |
|
|
|
396 |
|
|
write_register (SP_REGNUM, sp);
|
397 |
|
|
}
|
398 |
|
|
|
399 |
|
|
static void
|
400 |
|
|
ns32k_pop_frame (void)
|
401 |
|
|
{
|
402 |
|
|
struct frame_info *frame = get_current_frame ();
|
403 |
|
|
CORE_ADDR fp;
|
404 |
|
|
int regnum;
|
405 |
|
|
|
406 |
|
|
fp = frame->frame;
|
407 |
|
|
FRAME_INIT_SAVED_REGS (frame);
|
408 |
|
|
|
409 |
|
|
for (regnum = 0; regnum < 8; regnum++)
|
410 |
|
|
if (frame->saved_regs[regnum])
|
411 |
|
|
write_register (regnum,
|
412 |
|
|
read_memory_integer (frame->saved_regs[regnum], 4));
|
413 |
|
|
|
414 |
|
|
write_register (FP_REGNUM, read_memory_integer (fp, 4));
|
415 |
|
|
write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
|
416 |
|
|
write_register (SP_REGNUM, fp + 8);
|
417 |
|
|
flush_cached_frames ();
|
418 |
|
|
}
|
419 |
|
|
|
420 |
|
|
/* The NS32000 call dummy sequence:
|
421 |
|
|
|
422 |
|
|
enter 0xff,0 82 ff 00
|
423 |
|
|
jsr @0x00010203 7f ae c0 01 02 03
|
424 |
|
|
adjspd 0x69696969 7f a5 01 02 03 04
|
425 |
|
|
bpt f2
|
426 |
|
|
|
427 |
|
|
It is 16 bytes long. */
|
428 |
|
|
|
429 |
|
|
static LONGEST ns32k_call_dummy_words[] =
|
430 |
|
|
{
|
431 |
|
|
0x7f00ff82,
|
432 |
|
|
0x0201c0ae,
|
433 |
|
|
0x01a57f03,
|
434 |
|
|
0xf2040302
|
435 |
|
|
};
|
436 |
|
|
static int sizeof_ns32k_call_dummy_words = sizeof (ns32k_call_dummy_words);
|
437 |
|
|
|
438 |
|
|
#define NS32K_CALL_DUMMY_ADDR 5
|
439 |
|
|
#define NS32K_CALL_DUMMY_NARGS 11
|
440 |
|
|
|
441 |
|
|
static void
|
442 |
|
|
ns32k_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
|
443 |
|
|
struct value **args, struct type *type, int gcc_p)
|
444 |
|
|
{
|
445 |
|
|
int flipped;
|
446 |
|
|
|
447 |
|
|
flipped = fun | 0xc0000000;
|
448 |
|
|
flip_bytes (&flipped, 4);
|
449 |
|
|
store_unsigned_integer (dummy + NS32K_CALL_DUMMY_ADDR, 4, flipped);
|
450 |
|
|
|
451 |
|
|
flipped = - nargs * 4;
|
452 |
|
|
flip_bytes (&flipped, 4);
|
453 |
|
|
store_unsigned_integer (dummy + NS32K_CALL_DUMMY_NARGS, 4, flipped);
|
454 |
|
|
}
|
455 |
|
|
|
456 |
|
|
static void
|
457 |
|
|
ns32k_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
|
458 |
|
|
{
|
459 |
|
|
/* On this machine, this is a no-op (Encore Umax didn't use GCC). */
|
460 |
|
|
}
|
461 |
|
|
|
462 |
|
|
static void
|
463 |
|
|
ns32k_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
|
464 |
|
|
{
|
465 |
|
|
memcpy (valbuf,
|
466 |
|
|
regbuf + REGISTER_BYTE (TYPE_CODE (valtype) == TYPE_CODE_FLT ?
|
467 |
|
|
FP0_REGNUM : 0), TYPE_LENGTH (valtype));
|
468 |
|
|
}
|
469 |
|
|
|
470 |
|
|
static void
|
471 |
|
|
ns32k_store_return_value (struct type *valtype, char *valbuf)
|
472 |
|
|
{
|
473 |
|
|
write_register_bytes (TYPE_CODE (valtype) == TYPE_CODE_FLT ?
|
474 |
|
|
FP0_REGNUM : 0, valbuf, TYPE_LENGTH (valtype));
|
475 |
|
|
}
|
476 |
|
|
|
477 |
|
|
static CORE_ADDR
|
478 |
|
|
ns32k_extract_struct_value_address (char *regbuf)
|
479 |
|
|
{
|
480 |
|
|
return (extract_address (regbuf + REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
|
481 |
|
|
}
|
482 |
|
|
|
483 |
|
|
void
|
484 |
|
|
ns32k_gdbarch_init_32082 (struct gdbarch *gdbarch)
|
485 |
|
|
{
|
486 |
|
|
set_gdbarch_num_regs (gdbarch, NS32K_NUM_REGS_32082);
|
487 |
|
|
|
488 |
|
|
set_gdbarch_register_name (gdbarch, ns32k_register_name_32082);
|
489 |
|
|
set_gdbarch_register_bytes (gdbarch, NS32K_REGISTER_BYTES_32082);
|
490 |
|
|
set_gdbarch_register_byte (gdbarch, ns32k_register_byte_32082);
|
491 |
|
|
}
|
492 |
|
|
|
493 |
|
|
void
|
494 |
|
|
ns32k_gdbarch_init_32382 (struct gdbarch *gdbarch)
|
495 |
|
|
{
|
496 |
|
|
set_gdbarch_num_regs (gdbarch, NS32K_NUM_REGS_32382);
|
497 |
|
|
|
498 |
|
|
set_gdbarch_register_name (gdbarch, ns32k_register_name_32382);
|
499 |
|
|
set_gdbarch_register_bytes (gdbarch, NS32K_REGISTER_BYTES_32382);
|
500 |
|
|
set_gdbarch_register_byte (gdbarch, ns32k_register_byte_32382);
|
501 |
|
|
}
|
502 |
|
|
|
503 |
|
|
/* Initialize the current architecture based on INFO. If possible, re-use an
|
504 |
|
|
architecture from ARCHES, which is a list of architectures already created
|
505 |
|
|
during this debugging session.
|
506 |
|
|
|
507 |
|
|
Called e.g. at program startup, when reading a core file, and when reading
|
508 |
|
|
a binary file. */
|
509 |
|
|
|
510 |
|
|
static struct gdbarch *
|
511 |
|
|
ns32k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
512 |
|
|
{
|
513 |
|
|
struct gdbarch_tdep *tdep;
|
514 |
|
|
struct gdbarch *gdbarch;
|
515 |
|
|
enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
|
516 |
|
|
|
517 |
|
|
/* Try to determine the OS ABI of the object we are loading. */
|
518 |
|
|
if (info.abfd != NULL)
|
519 |
|
|
{
|
520 |
|
|
osabi = gdbarch_lookup_osabi (info.abfd);
|
521 |
|
|
}
|
522 |
|
|
|
523 |
|
|
/* Find a candidate among extant architectures. */
|
524 |
|
|
for (arches = gdbarch_list_lookup_by_info (arches, &info);
|
525 |
|
|
arches != NULL;
|
526 |
|
|
arches = gdbarch_list_lookup_by_info (arches->next, &info))
|
527 |
|
|
{
|
528 |
|
|
/* Make sure the OS ABI selection matches. */
|
529 |
|
|
tdep = gdbarch_tdep (arches->gdbarch);
|
530 |
|
|
if (tdep && tdep->osabi == osabi)
|
531 |
|
|
return arches->gdbarch;
|
532 |
|
|
}
|
533 |
|
|
|
534 |
|
|
tdep = xmalloc (sizeof (struct gdbarch_tdep));
|
535 |
|
|
gdbarch = gdbarch_alloc (&info, tdep);
|
536 |
|
|
|
537 |
|
|
tdep->osabi = osabi;
|
538 |
|
|
|
539 |
|
|
/* Register info */
|
540 |
|
|
ns32k_gdbarch_init_32082 (gdbarch);
|
541 |
|
|
set_gdbarch_num_regs (gdbarch, NS32K_SP_REGNUM);
|
542 |
|
|
set_gdbarch_num_regs (gdbarch, NS32K_FP_REGNUM);
|
543 |
|
|
set_gdbarch_num_regs (gdbarch, NS32K_PC_REGNUM);
|
544 |
|
|
set_gdbarch_num_regs (gdbarch, NS32K_PS_REGNUM);
|
545 |
|
|
|
546 |
|
|
set_gdbarch_register_size (gdbarch, NS32K_REGISTER_SIZE);
|
547 |
|
|
set_gdbarch_register_raw_size (gdbarch, ns32k_register_raw_size);
|
548 |
|
|
set_gdbarch_max_register_raw_size (gdbarch, NS32K_MAX_REGISTER_RAW_SIZE);
|
549 |
|
|
set_gdbarch_register_virtual_size (gdbarch, ns32k_register_virtual_size);
|
550 |
|
|
set_gdbarch_max_register_virtual_size (gdbarch,
|
551 |
|
|
NS32K_MAX_REGISTER_VIRTUAL_SIZE);
|
552 |
|
|
set_gdbarch_register_virtual_type (gdbarch, ns32k_register_virtual_type);
|
553 |
|
|
|
554 |
|
|
/* Frame and stack info */
|
555 |
|
|
set_gdbarch_skip_prologue (gdbarch, umax_skip_prologue);
|
556 |
|
|
set_gdbarch_saved_pc_after_call (gdbarch, ns32k_saved_pc_after_call);
|
557 |
|
|
|
558 |
|
|
set_gdbarch_frame_num_args (gdbarch, umax_frame_num_args);
|
559 |
|
|
set_gdbarch_frameless_function_invocation (gdbarch,
|
560 |
|
|
generic_frameless_function_invocation_not);
|
561 |
|
|
|
562 |
|
|
set_gdbarch_frame_chain (gdbarch, ns32k_frame_chain);
|
563 |
|
|
set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
|
564 |
|
|
set_gdbarch_frame_saved_pc (gdbarch, ns32k_frame_saved_pc);
|
565 |
|
|
|
566 |
|
|
set_gdbarch_frame_args_address (gdbarch, ns32k_frame_args_address);
|
567 |
|
|
set_gdbarch_frame_locals_address (gdbarch, ns32k_frame_locals_address);
|
568 |
|
|
|
569 |
|
|
set_gdbarch_frame_init_saved_regs (gdbarch, ns32k_frame_init_saved_regs);
|
570 |
|
|
|
571 |
|
|
set_gdbarch_frame_args_skip (gdbarch, 8);
|
572 |
|
|
|
573 |
|
|
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
|
574 |
|
|
|
575 |
|
|
/* Return value info */
|
576 |
|
|
set_gdbarch_store_struct_return (gdbarch, ns32k_store_struct_return);
|
577 |
|
|
set_gdbarch_deprecated_extract_return_value (gdbarch, ns32k_extract_return_value);
|
578 |
|
|
set_gdbarch_deprecated_store_return_value (gdbarch, ns32k_store_return_value);
|
579 |
|
|
set_gdbarch_deprecated_extract_struct_value_address (gdbarch,
|
580 |
|
|
ns32k_extract_struct_value_address);
|
581 |
|
|
|
582 |
|
|
/* Call dummy info */
|
583 |
|
|
set_gdbarch_push_dummy_frame (gdbarch, ns32k_push_dummy_frame);
|
584 |
|
|
set_gdbarch_pop_frame (gdbarch, ns32k_pop_frame);
|
585 |
|
|
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
|
586 |
|
|
set_gdbarch_call_dummy_p (gdbarch, 1);
|
587 |
|
|
set_gdbarch_call_dummy_words (gdbarch, ns32k_call_dummy_words);
|
588 |
|
|
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_ns32k_call_dummy_words);
|
589 |
|
|
set_gdbarch_fix_call_dummy (gdbarch, ns32k_fix_call_dummy);
|
590 |
|
|
set_gdbarch_call_dummy_start_offset (gdbarch, 3);
|
591 |
|
|
set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 0);
|
592 |
|
|
set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
|
593 |
|
|
set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_on_stack);
|
594 |
|
|
set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
|
595 |
|
|
|
596 |
|
|
/* Breakpoint info */
|
597 |
|
|
set_gdbarch_decr_pc_after_break (gdbarch, 0);
|
598 |
|
|
set_gdbarch_breakpoint_from_pc (gdbarch, ns32k_breakpoint_from_pc);
|
599 |
|
|
|
600 |
|
|
/* Misc info */
|
601 |
|
|
set_gdbarch_function_start_offset (gdbarch, 0);
|
602 |
|
|
|
603 |
|
|
/* Hook in OS ABI-specific overrides, if they have been registered. */
|
604 |
|
|
gdbarch_init_osabi (info, gdbarch, osabi);
|
605 |
|
|
|
606 |
|
|
return (gdbarch);
|
607 |
|
|
}
|
608 |
|
|
|
609 |
|
|
static void
|
610 |
|
|
ns32k_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
|
611 |
|
|
{
|
612 |
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
613 |
|
|
|
614 |
|
|
if (tdep == NULL)
|
615 |
|
|
return;
|
616 |
|
|
|
617 |
|
|
fprintf_unfiltered (file, "ns32k_dump_tdep: OS ABI = %s\n",
|
618 |
|
|
gdbarch_osabi_name (tdep->osabi));
|
619 |
|
|
}
|
620 |
|
|
|
621 |
|
|
void
|
622 |
|
|
_initialize_ns32k_tdep (void)
|
623 |
|
|
{
|
624 |
|
|
gdbarch_register (bfd_arch_ns32k, ns32k_gdbarch_init, ns32k_dump_tdep);
|
625 |
|
|
|
626 |
|
|
tm_print_insn = print_insn_ns32k;
|
627 |
|
|
}
|