1 /* 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.
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. */
30 #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 ((fi
)->pc
);
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;
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 (frame
->pc
))
314 return (read_memory_integer (frame
->frame
, 4));
318 ns32k_frame_saved_pc (struct frame_info
*frame
)
320 if (frame
->signal_handler_caller
)
321 return (sigtramp_saved_pc (frame
)); /* XXXJRT */
323 return (read_memory_integer (frame
->frame
+ 4, 4));
327 ns32k_frame_args_address (struct frame_info
*frame
)
329 if (ns32k_get_enter_addr (frame
->pc
) > 1)
330 return (frame
->frame
);
332 return (read_register (SP_REGNUM
) - 4);
336 ns32k_frame_locals_address (struct frame_info
*frame
)
338 return (frame
->frame
);
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. */
347 ns32k_frame_init_saved_regs (struct frame_info
*frame
)
351 CORE_ADDR enter_addr
, next_addr
;
353 if (frame
->saved_regs
)
356 frame_saved_regs_zalloc (frame
);
358 enter_addr
= ns32k_get_enter_addr (frame
->pc
);
361 regmask
= read_memory_integer (enter_addr
+ 1, 1) & 0xff;
362 localcount
= ns32k_localcount (enter_addr
);
363 next_addr
= frame
->frame
+ localcount
;
365 for (regnum
= 0; regnum
< 8; regnum
++)
367 if (regmask
& (1 << regnum
))
368 frame
->saved_regs
[regnum
] = next_addr
-= 4;
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);
375 else if (enter_addr
== 1)
377 CORE_ADDR sp
= read_register (SP_REGNUM
);
378 frame
->saved_regs
[PC_REGNUM
] = sp
;
379 frame
->saved_regs
[SP_REGNUM
] = sp
+ 4;
384 ns32k_push_dummy_frame (void)
386 CORE_ADDR sp
= read_register (SP_REGNUM
);
389 sp
= push_word (sp
, read_register (PC_REGNUM
));
390 sp
= push_word (sp
, read_register (FP_REGNUM
));
391 write_register (FP_REGNUM
, sp
);
393 for (regnum
= 0; regnum
< 8; regnum
++)
394 sp
= push_word (sp
, read_register (regnum
));
396 write_register (SP_REGNUM
, sp
);
400 ns32k_pop_frame (void)
402 struct frame_info
*frame
= get_current_frame ();
407 FRAME_INIT_SAVED_REGS (frame
);
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));
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 ();
420 /* The NS32000 call dummy sequence:
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
427 It is 16 bytes long. */
429 static LONGEST ns32k_call_dummy_words
[] =
436 static int sizeof_ns32k_call_dummy_words
= sizeof (ns32k_call_dummy_words
);
438 #define NS32K_CALL_DUMMY_ADDR 5
439 #define NS32K_CALL_DUMMY_NARGS 11
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
)
447 flipped
= fun
| 0xc0000000;
448 flip_bytes (&flipped
, 4);
449 store_unsigned_integer (dummy
+ NS32K_CALL_DUMMY_ADDR
, 4, flipped
);
451 flipped
= - nargs
* 4;
452 flip_bytes (&flipped
, 4);
453 store_unsigned_integer (dummy
+ NS32K_CALL_DUMMY_NARGS
, 4, flipped
);
457 ns32k_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
459 /* On this machine, this is a no-op (Encore Umax didn't use GCC). */
463 ns32k_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
466 regbuf
+ REGISTER_BYTE (TYPE_CODE (valtype
) == TYPE_CODE_FLT
?
467 FP0_REGNUM
: 0), TYPE_LENGTH (valtype
));
471 ns32k_store_return_value (struct type
*valtype
, char *valbuf
)
473 write_register_bytes (TYPE_CODE (valtype
) == TYPE_CODE_FLT
?
474 FP0_REGNUM
: 0, valbuf
, TYPE_LENGTH (valtype
));
478 ns32k_extract_struct_value_address (char *regbuf
)
480 return (extract_address (regbuf
+ REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
484 ns32k_gdbarch_init_32082 (struct gdbarch
*gdbarch
)
486 set_gdbarch_num_regs (gdbarch
, NS32K_NUM_REGS_32082
);
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
);
494 ns32k_gdbarch_init_32382 (struct gdbarch
*gdbarch
)
496 set_gdbarch_num_regs (gdbarch
, NS32K_NUM_REGS_32382
);
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
);
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.
507 Called e.g. at program startup, when reading a core file, and when reading
510 static struct gdbarch
*
511 ns32k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
513 struct gdbarch_tdep
*tdep
;
514 struct gdbarch
*gdbarch
;
515 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
517 /* Try to determine the OS ABI of the object we are loading. */
518 if (info
.abfd
!= NULL
)
520 osabi
= gdbarch_lookup_osabi (info
.abfd
);
523 /* Find a candidate among extant architectures. */
524 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
526 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
528 /* Make sure the OS ABI selection matches. */
529 tdep
= gdbarch_tdep (arches
->gdbarch
);
530 if (tdep
&& tdep
->osabi
== osabi
)
531 return arches
->gdbarch
;
534 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
535 gdbarch
= gdbarch_alloc (&info
, tdep
);
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
);
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
);
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
);
558 set_gdbarch_frame_num_args (gdbarch
, umax_frame_num_args
);
559 set_gdbarch_frameless_function_invocation (gdbarch
,
560 generic_frameless_function_invocation_not
);
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
);
566 set_gdbarch_frame_args_address (gdbarch
, ns32k_frame_args_address
);
567 set_gdbarch_frame_locals_address (gdbarch
, ns32k_frame_locals_address
);
569 set_gdbarch_frame_init_saved_regs (gdbarch
, ns32k_frame_init_saved_regs
);
571 set_gdbarch_frame_args_skip (gdbarch
, 8);
573 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
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
);
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);
596 /* Breakpoint info */
597 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
598 set_gdbarch_breakpoint_from_pc (gdbarch
, ns32k_breakpoint_from_pc
);
601 set_gdbarch_function_start_offset (gdbarch
, 0);
603 /* Hook in OS ABI-specific overrides, if they have been registered. */
604 gdbarch_init_osabi (info
, gdbarch
, osabi
);
610 ns32k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
612 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
617 fprintf_unfiltered (file
, "ns32k_dump_tdep: OS ABI = %s\n",
618 gdbarch_osabi_name (tdep
->osabi
));
622 _initialize_ns32k_tdep (void)
624 gdbarch_register (bfd_arch_ns32k
, ns32k_gdbarch_init
, ns32k_dump_tdep
);
626 tm_print_insn
= print_insn_ns32k
;