1 /* Target dependent code for the NS32000, for GDB.
2 Copyright 1986, 1988, 1991, 1992, 1994, 1995, 1998, 1999, 2000, 2001,
3 2002, 2003 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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. */
29 #include "arch-utils.h"
32 #include "ns32k-tdep.h"
33 #include "gdb_string.h"
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);
41 ns32k_register_name_32082 (int regno
)
43 static char *register_names
[] =
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",
53 if (regno
>= sizeof (register_names
) / sizeof (*register_names
))
56 return (register_names
[regno
]);
60 ns32k_register_name_32382 (int regno
)
62 static char *register_names
[] =
64 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
65 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
66 "sp", "fp", "pc", "ps",
68 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7", "xx",
73 if (regno
>= sizeof (register_names
) / sizeof (*register_names
))
76 return (register_names
[regno
]);
80 ns32k_register_byte_32082 (int regno
)
82 if (regno
>= NS32K_LP0_REGNUM
)
83 return (NS32K_LP0_REGNUM
* 4) + ((regno
- NS32K_LP0_REGNUM
) * 8);
89 ns32k_register_byte_32382 (int regno
)
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. */
97 return ((regno
< NS32K_LP0_REGNUM
? regno
98 : (regno
- NS32K_LP0_REGNUM
) & 1 ? regno
- 1
99 : (regno
- NS32K_LP0_REGNUM
+ FP0_REGNUM
)) * 4);
103 ns32k_register_raw_size (int regno
)
105 /* All registers are 4 bytes, except for the doubled floating
108 return ((regno
>= NS32K_LP0_REGNUM
) ? 8 : 4);
112 ns32k_register_virtual_size (int regno
)
114 return ((regno
>= NS32K_LP0_REGNUM
) ? 8 : 4);
118 ns32k_register_virtual_type (int regno
)
120 if (regno
< FP0_REGNUM
)
121 return (builtin_type_int
);
123 if (regno
< FP0_REGNUM
+ 8)
124 return (builtin_type_float
);
126 if (regno
< NS32K_LP0_REGNUM
)
127 return (builtin_type_int
);
129 return (builtin_type_double
);
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
138 ns32k_saved_pc_after_call (struct frame_info
*frame
)
140 return (read_memory_integer (read_register (SP_REGNUM
), 4));
143 /* Advance PC across any function entry prologue instructions
144 to reach some "real" code. */
147 umax_skip_prologue (CORE_ADDR pc
)
149 register unsigned char op
= read_memory_integer (pc
, 1);
152 op
= read_memory_integer (pc
+ 2, 1);
153 if ((op
& 0x80) == 0)
155 else if ((op
& 0xc0) == 0x80)
163 static const unsigned char *
164 ns32k_breakpoint_from_pc (CORE_ADDR
*pcp
, int *lenp
)
166 static const unsigned char breakpoint_insn
[] = { 0xf2 };
168 *lenp
= sizeof (breakpoint_insn
);
169 return breakpoint_insn
;
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. */
179 umax_frame_num_args (struct frame_info
*fi
)
183 CORE_ADDR enter_addr
;
185 unsigned int addr_mode
;
189 enter_addr
= ns32k_get_enter_addr (get_frame_pc (fi
));
192 pc
= ((enter_addr
== 1)
193 ? DEPRECATED_SAVED_PC_AFTER_CALL (fi
)
194 : DEPRECATED_FRAME_SAVED_PC (fi
));
195 insn
= read_memory_integer (pc
, 2);
196 addr_mode
= (insn
>> 11) & 0x1f;
198 if ((insn
& 0x7fc) == 0x57c
199 && addr_mode
== 0x14) /* immediate */
201 if (insn
== 0x57c) /* adjspb */
203 else if (insn
== 0x57d) /* adjspw */
205 else if (insn
== 0x57f) /* adjspd */
208 internal_error (__FILE__
, __LINE__
, "bad else");
209 numargs
= read_memory_integer (pc
+ 2, width
);
211 flip_bytes (&numargs
, width
);
212 numargs
= -sign_extend (numargs
, width
* 8) / 4;
219 sign_extend (int value
, int bits
)
221 value
= value
& ((1 << bits
) - 1);
222 return (value
& (1 << (bits
- 1))
223 ? value
| (~((1 << bits
) - 1))
228 flip_bytes (void *p
, int count
)
236 ptr
[0] = ptr
[count
- 1];
237 ptr
[count
- 1] = tmp
;
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. */
248 ns32k_localcount (CORE_ADDR enter_pc
)
250 unsigned char localtype
;
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));
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));
268 /* Nonzero if instruction at PC is a return instruction. */
271 ns32k_about_to_return (CORE_ADDR pc
)
273 return (read_memory_integer (pc
, 1) == 0x12);
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. */
280 ns32k_get_enter_addr (CORE_ADDR pc
)
282 CORE_ADDR enter_addr
;
288 if (ns32k_about_to_return (pc
))
289 return 1; /* after exit */
291 enter_addr
= get_pc_function_start (pc
);
293 if (pc
== enter_addr
)
294 return 1; /* before enter */
296 op
= read_memory_integer (enter_addr
, 1);
299 return 0; /* function has no enter/exit */
301 return enter_addr
; /* pc is between enter and exit */
305 ns32k_frame_chain (struct frame_info
*frame
)
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
311 if (inside_entry_file (get_frame_pc (frame
)))
314 return (read_memory_integer (get_frame_base (frame
), 4));
319 ns32k_sigtramp_saved_pc (struct frame_info
*frame
)
321 CORE_ADDR sigcontext_addr
;
323 int ptrbytes
= TYPE_LENGTH (builtin_type_void_func_ptr
);
324 int sigcontext_offs
= (2 * TARGET_INT_BIT
) / TARGET_CHAR_BIT
;
326 buf
= alloca (ptrbytes
);
327 /* Get sigcontext address, it is the third parameter on the stack. */
328 if (get_next_frame (frame
))
329 sigcontext_addr
= read_memory_typed_address
330 (FRAME_ARGS_ADDRESS (get_next_frame (frame
)) + FRAME_ARGS_SKIP
+ sigcontext_offs
,
331 builtin_type_void_data_ptr
);
333 sigcontext_addr
= read_memory_typed_address
334 (read_register (SP_REGNUM
) + sigcontext_offs
, builtin_type_void_data_ptr
);
336 /* Don't cause a memory_error when accessing sigcontext in case the stack
337 layout has changed or the stack is corrupt. */
338 target_read_memory (sigcontext_addr
+ SIGCONTEXT_PC_OFFSET
, buf
, ptrbytes
);
339 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
343 ns32k_frame_saved_pc (struct frame_info
*frame
)
345 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
346 return (ns32k_sigtramp_saved_pc (frame
)); /* XXXJRT */
348 return (read_memory_integer (get_frame_base (frame
) + 4, 4));
352 ns32k_frame_args_address (struct frame_info
*frame
)
354 if (ns32k_get_enter_addr (get_frame_pc (frame
)) > 1)
355 return (get_frame_base (frame
));
357 return (read_register (SP_REGNUM
) - 4);
360 /* Code to initialize the addresses of the saved registers of frame described
361 by FRAME_INFO. This includes special registers such as pc and fp saved in
362 special ways in the stack frame. sp is even more special: the address we
363 return for it IS the sp for the next frame. */
366 ns32k_frame_init_saved_regs (struct frame_info
*frame
)
370 CORE_ADDR enter_addr
, next_addr
;
372 if (get_frame_saved_regs (frame
))
375 frame_saved_regs_zalloc (frame
);
377 enter_addr
= ns32k_get_enter_addr (get_frame_pc (frame
));
380 regmask
= read_memory_integer (enter_addr
+ 1, 1) & 0xff;
381 localcount
= ns32k_localcount (enter_addr
);
382 next_addr
= get_frame_base (frame
) + localcount
;
384 for (regnum
= 0; regnum
< 8; regnum
++)
386 if (regmask
& (1 << regnum
))
387 get_frame_saved_regs (frame
)[regnum
] = next_addr
-= 4;
390 get_frame_saved_regs (frame
)[SP_REGNUM
] = get_frame_base (frame
) + 4;
391 get_frame_saved_regs (frame
)[PC_REGNUM
] = get_frame_base (frame
) + 4;
392 get_frame_saved_regs (frame
)[DEPRECATED_FP_REGNUM
] = read_memory_integer (get_frame_base (frame
), 4);
394 else if (enter_addr
== 1)
396 CORE_ADDR sp
= read_register (SP_REGNUM
);
397 get_frame_saved_regs (frame
)[PC_REGNUM
] = sp
;
398 get_frame_saved_regs (frame
)[SP_REGNUM
] = sp
+ 4;
403 ns32k_push_dummy_frame (void)
405 CORE_ADDR sp
= read_register (SP_REGNUM
);
408 sp
= push_word (sp
, read_register (PC_REGNUM
));
409 sp
= push_word (sp
, read_register (DEPRECATED_FP_REGNUM
));
410 write_register (DEPRECATED_FP_REGNUM
, sp
);
412 for (regnum
= 0; regnum
< 8; regnum
++)
413 sp
= push_word (sp
, read_register (regnum
));
415 write_register (SP_REGNUM
, sp
);
419 ns32k_pop_frame (void)
421 struct frame_info
*frame
= get_current_frame ();
425 fp
= get_frame_base (frame
);
426 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
428 for (regnum
= 0; regnum
< 8; regnum
++)
429 if (get_frame_saved_regs (frame
)[regnum
])
430 write_register (regnum
,
431 read_memory_integer (get_frame_saved_regs (frame
)[regnum
], 4));
433 write_register (DEPRECATED_FP_REGNUM
, read_memory_integer (fp
, 4));
434 write_register (PC_REGNUM
, read_memory_integer (fp
+ 4, 4));
435 write_register (SP_REGNUM
, fp
+ 8);
436 flush_cached_frames ();
439 /* The NS32000 call dummy sequence:
441 enter 0xff,0 82 ff 00
442 jsr @0x00010203 7f ae c0 01 02 03
443 adjspd 0x69696969 7f a5 01 02 03 04
446 It is 16 bytes long. */
448 static LONGEST ns32k_call_dummy_words
[] =
455 static int sizeof_ns32k_call_dummy_words
= sizeof (ns32k_call_dummy_words
);
457 #define NS32K_CALL_DUMMY_ADDR 5
458 #define NS32K_CALL_DUMMY_NARGS 11
461 ns32k_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
462 struct value
**args
, struct type
*type
, int gcc_p
)
466 flipped
= fun
| 0xc0000000;
467 flip_bytes (&flipped
, 4);
468 store_unsigned_integer (dummy
+ NS32K_CALL_DUMMY_ADDR
, 4, flipped
);
470 flipped
= - nargs
* 4;
471 flip_bytes (&flipped
, 4);
472 store_unsigned_integer (dummy
+ NS32K_CALL_DUMMY_NARGS
, 4, flipped
);
476 ns32k_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
478 /* On this machine, this is a no-op (Encore Umax didn't use GCC). */
482 ns32k_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
485 regbuf
+ REGISTER_BYTE (TYPE_CODE (valtype
) == TYPE_CODE_FLT
?
486 FP0_REGNUM
: 0), TYPE_LENGTH (valtype
));
490 ns32k_store_return_value (struct type
*valtype
, char *valbuf
)
492 deprecated_write_register_bytes (TYPE_CODE (valtype
) == TYPE_CODE_FLT
493 ? FP0_REGNUM
: 0, valbuf
,
494 TYPE_LENGTH (valtype
));
498 ns32k_extract_struct_value_address (char *regbuf
)
500 return (extract_unsigned_integer (regbuf
+ REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
504 ns32k_gdbarch_init_32082 (struct gdbarch
*gdbarch
)
506 set_gdbarch_num_regs (gdbarch
, NS32K_NUM_REGS_32082
);
508 set_gdbarch_register_name (gdbarch
, ns32k_register_name_32082
);
509 set_gdbarch_deprecated_register_bytes (gdbarch
, NS32K_REGISTER_BYTES_32082
);
510 set_gdbarch_deprecated_register_byte (gdbarch
, ns32k_register_byte_32082
);
514 ns32k_gdbarch_init_32382 (struct gdbarch
*gdbarch
)
516 set_gdbarch_num_regs (gdbarch
, NS32K_NUM_REGS_32382
);
518 set_gdbarch_register_name (gdbarch
, ns32k_register_name_32382
);
519 set_gdbarch_deprecated_register_bytes (gdbarch
, NS32K_REGISTER_BYTES_32382
);
520 set_gdbarch_deprecated_register_byte (gdbarch
, ns32k_register_byte_32382
);
523 /* Initialize the current architecture based on INFO. If possible, re-use an
524 architecture from ARCHES, which is a list of architectures already created
525 during this debugging session.
527 Called e.g. at program startup, when reading a core file, and when reading
530 static struct gdbarch
*
531 ns32k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
533 struct gdbarch
*gdbarch
;
535 /* If there is already a candidate, use it. */
536 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
538 return arches
->gdbarch
;
540 gdbarch
= gdbarch_alloc (&info
, NULL
);
542 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
543 ready to unwind the PC first (see frame.c:get_prev_frame()). */
544 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
547 ns32k_gdbarch_init_32082 (gdbarch
);
548 set_gdbarch_num_regs (gdbarch
, NS32K_SP_REGNUM
);
549 set_gdbarch_num_regs (gdbarch
, NS32K_FP_REGNUM
);
550 set_gdbarch_num_regs (gdbarch
, NS32K_PC_REGNUM
);
551 set_gdbarch_num_regs (gdbarch
, NS32K_PS_REGNUM
);
553 set_gdbarch_deprecated_register_size (gdbarch
, NS32K_REGISTER_SIZE
);
554 set_gdbarch_deprecated_register_raw_size (gdbarch
, ns32k_register_raw_size
);
555 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, NS32K_MAX_REGISTER_RAW_SIZE
);
556 set_gdbarch_deprecated_register_virtual_size (gdbarch
, ns32k_register_virtual_size
);
557 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
,
558 NS32K_MAX_REGISTER_VIRTUAL_SIZE
);
559 set_gdbarch_deprecated_register_virtual_type (gdbarch
, ns32k_register_virtual_type
);
561 /* Frame and stack info */
562 set_gdbarch_skip_prologue (gdbarch
, umax_skip_prologue
);
563 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, ns32k_saved_pc_after_call
);
565 set_gdbarch_frame_num_args (gdbarch
, umax_frame_num_args
);
566 set_gdbarch_frameless_function_invocation (gdbarch
,
567 generic_frameless_function_invocation_not
);
569 set_gdbarch_deprecated_frame_chain (gdbarch
, ns32k_frame_chain
);
570 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, ns32k_frame_saved_pc
);
572 set_gdbarch_frame_args_address (gdbarch
, ns32k_frame_args_address
);
574 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, ns32k_frame_init_saved_regs
);
576 set_gdbarch_frame_args_skip (gdbarch
, 8);
578 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
580 /* Return value info */
581 set_gdbarch_deprecated_store_struct_return (gdbarch
, ns32k_store_struct_return
);
582 set_gdbarch_deprecated_extract_return_value (gdbarch
, ns32k_extract_return_value
);
583 set_gdbarch_deprecated_store_return_value (gdbarch
, ns32k_store_return_value
);
584 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
585 ns32k_extract_struct_value_address
);
587 /* Call dummy info */
588 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, ns32k_push_dummy_frame
);
589 set_gdbarch_deprecated_pop_frame (gdbarch
, ns32k_pop_frame
);
590 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
591 set_gdbarch_deprecated_call_dummy_words (gdbarch
, ns32k_call_dummy_words
);
592 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof_ns32k_call_dummy_words
);
593 set_gdbarch_deprecated_fix_call_dummy (gdbarch
, ns32k_fix_call_dummy
);
594 set_gdbarch_deprecated_call_dummy_start_offset (gdbarch
, 3);
595 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch
, 15);
596 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
597 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_on_stack
);
599 /* Breakpoint info */
600 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
601 set_gdbarch_breakpoint_from_pc (gdbarch
, ns32k_breakpoint_from_pc
);
604 set_gdbarch_function_start_offset (gdbarch
, 0);
606 /* Should be using push_dummy_call. */
607 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, deprecated_write_sp
);
609 /* Hook in OS ABI-specific overrides, if they have been registered. */
610 gdbarch_init_osabi (info
, gdbarch
);
615 extern initialize_file_ftype _initialize_ns32k_tdep
; /* -Wmissing-prototypes */
618 _initialize_ns32k_tdep (void)
620 gdbarch_register (bfd_arch_ns32k
, ns32k_gdbarch_init
, NULL
);
622 deprecated_tm_print_insn
= print_insn_ns32k
;