1 /* Print VAX instructions for GDB, the GNU debugger.
2 Copyright 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000, 2002, 2003
3 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. */
24 #include "opcode/vax.h"
30 #include "arch-utils.h"
31 #include "gdb_string.h"
36 static gdbarch_register_name_ftype vax_register_name;
37 static gdbarch_register_byte_ftype vax_register_byte;
38 static gdbarch_register_raw_size_ftype vax_register_raw_size;
39 static gdbarch_register_virtual_size_ftype vax_register_virtual_size;
40 static gdbarch_register_virtual_type_ftype vax_register_virtual_type;
42 static gdbarch_skip_prologue_ftype vax_skip_prologue;
43 static gdbarch_frame_num_args_ftype vax_frame_num_args;
44 static gdbarch_deprecated_frame_chain_ftype vax_frame_chain;
45 static gdbarch_frame_args_address_ftype vax_frame_args_address;
46 static gdbarch_frame_locals_address_ftype vax_frame_locals_address;
48 static gdbarch_deprecated_extract_return_value_ftype vax_extract_return_value;
49 static gdbarch_deprecated_extract_struct_value_address_ftype
50 vax_extract_struct_value_address;
52 static gdbarch_deprecated_push_dummy_frame_ftype vax_push_dummy_frame;
53 static gdbarch_fix_call_dummy_ftype vax_fix_call_dummy;
55 /* Return 1 if P points to an invalid floating point value.
56 LEN is the length in bytes -- not relevant on the Vax. */
58 /* FIXME: cagney/2002-01-19: The macro below was originally defined in
59 tm-vax.h and used in values.c. Two problems. Firstly this is a
60 very non-portable and secondly it is wrong. The VAX should be
61 using floatformat and associated methods to identify and handle
62 invalid floating-point values. Adding to the poor target's woes
63 there is no floatformat_vax_{f,d} and no TARGET_FLOAT_FORMAT
66 /* FIXME: cagney/2002-01-19: It turns out that the only thing that
67 uses this macro is the vax disassembler code (so how old is this
68 target?). This target should instead be using the opcodes
69 disassembler. That allowing the macro to be eliminated. */
71 #define INVALID_FLOAT(p, len) ((*(short *) p & 0xff80) == 0x8000)
73 /* Vax instructions are never longer than this. */
76 /* Number of elements in the opcode table. */
77 #define NOPCODES (sizeof votstrs / sizeof votstrs[0])
79 static unsigned char *print_insn_arg ();
82 vax_register_name (int regno)
84 static char *register_names[] =
86 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
87 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
93 if (regno >= (sizeof(register_names) / sizeof(*register_names)))
95 return (register_names[regno]);
99 vax_register_byte (int regno)
105 vax_register_raw_size (int regno)
111 vax_register_virtual_size (int regno)
117 vax_register_virtual_type (int regno)
119 return (builtin_type_int);
123 vax_frame_init_saved_regs (struct frame_info *frame)
128 if (get_frame_saved_regs (frame))
131 frame_saved_regs_zalloc (frame);
133 regmask = read_memory_integer (get_frame_base (frame) + 4, 4) >> 16;
135 next_addr = get_frame_base (frame) + 16;
137 /* regmask's low bit is for register 0, which is the first one
138 what would be pushed. */
139 for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
141 if (regmask & (1 << regnum))
142 get_frame_saved_regs (frame)[regnum] = next_addr += 4;
145 get_frame_saved_regs (frame)[SP_REGNUM] = next_addr + 4;
146 if (regmask & (1 << FP_REGNUM))
147 get_frame_saved_regs (frame)[SP_REGNUM] +=
148 4 + (4 * read_memory_integer (next_addr + 4, 4));
150 get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 16;
151 get_frame_saved_regs (frame)[FP_REGNUM] = get_frame_base (frame) + 12;
152 get_frame_saved_regs (frame)[VAX_AP_REGNUM] = get_frame_base (frame) + 8;
153 get_frame_saved_regs (frame)[PS_REGNUM] = get_frame_base (frame) + 4;
156 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */
159 vax_sigtramp_saved_pc (struct frame_info *frame)
161 CORE_ADDR sigcontext_addr;
163 int ptrbytes = TYPE_LENGTH (builtin_type_void_func_ptr);
164 int sigcontext_offs = (2 * TARGET_INT_BIT) / TARGET_CHAR_BIT;
166 buf = alloca (ptrbytes);
167 /* Get sigcontext address, it is the third parameter on the stack. */
168 if (get_next_frame (frame))
169 sigcontext_addr = read_memory_typed_address
170 (FRAME_ARGS_ADDRESS (get_next_frame (frame))
171 + FRAME_ARGS_SKIP + sigcontext_offs,
172 builtin_type_void_data_ptr);
174 sigcontext_addr = read_memory_typed_address
175 (read_register (SP_REGNUM) + sigcontext_offs, builtin_type_void_data_ptr);
177 /* Don't cause a memory_error when accessing sigcontext in case the stack
178 layout has changed or the stack is corrupt. */
179 target_read_memory (sigcontext_addr + SIGCONTEXT_PC_OFFSET, buf, ptrbytes);
180 return extract_typed_address (buf, builtin_type_void_func_ptr);
184 vax_frame_saved_pc (struct frame_info *frame)
186 if ((get_frame_type (frame) == SIGTRAMP_FRAME))
187 return (vax_sigtramp_saved_pc (frame)); /* XXXJRT */
189 return (read_memory_integer (get_frame_base (frame) + 16, 4));
193 vax_frame_args_address_correct (struct frame_info *frame)
195 /* Cannot find the AP register value directly from the FP value. Must
196 find it saved in the frame called by this one, or in the AP register
197 for the innermost frame. However, there is no way to tell the
198 difference between the innermost frame and a frame for which we
199 just don't know the frame that it called (e.g. "info frame 0x7ffec789").
200 For the sake of argument, suppose that the stack is somewhat trashed
201 (which is one reason that "info frame" exists). So, return 0 (indicating
202 we don't know the address of the arglist) if we don't know what frame
204 if (get_next_frame (frame))
205 return (read_memory_integer (get_frame_base (get_next_frame (frame)) + 8, 4));
211 vax_frame_args_address (struct frame_info *frame)
213 /* In most of GDB, getting the args address is too important to
214 just say "I don't know". This is sometimes wrong for functions
215 that aren't on top of the stack, but c'est la vie. */
216 if (get_next_frame (frame))
217 return (read_memory_integer (get_frame_base (get_next_frame (frame)) + 8, 4));
219 return (read_register (VAX_AP_REGNUM));
223 vax_frame_locals_address (struct frame_info *frame)
225 return (get_frame_base (frame));
229 vax_frame_num_args (struct frame_info *fi)
231 return (0xff & read_memory_integer (FRAME_ARGS_ADDRESS (fi), 1));
235 vax_frame_chain (struct frame_info *frame)
237 /* In the case of the VAX, the frame's nominal address is the FP value,
238 and 12 bytes later comes the saved previous FP value as a 4-byte word. */
239 if (inside_entry_file (get_frame_pc (frame)))
242 return (read_memory_integer (get_frame_base (frame) + 12, 4));
246 vax_push_dummy_frame (void)
248 CORE_ADDR sp = read_register (SP_REGNUM);
251 sp = push_word (sp, 0); /* arglist */
252 for (regnum = 11; regnum >= 0; regnum--)
253 sp = push_word (sp, read_register (regnum));
254 sp = push_word (sp, read_register (PC_REGNUM));
255 sp = push_word (sp, read_register (FP_REGNUM));
256 sp = push_word (sp, read_register (VAX_AP_REGNUM));
257 sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef) + 0x2fff0000);
258 sp = push_word (sp, 0);
259 write_register (SP_REGNUM, sp);
260 write_register (FP_REGNUM, sp);
261 write_register (VAX_AP_REGNUM, sp + (17 * 4));
267 CORE_ADDR fp = read_register (FP_REGNUM);
269 int regmask = read_memory_integer (fp + 4, 4);
271 write_register (PS_REGNUM,
273 | (read_register (PS_REGNUM) & 0xffff0000));
274 write_register (PC_REGNUM, read_memory_integer (fp + 16, 4));
275 write_register (FP_REGNUM, read_memory_integer (fp + 12, 4));
276 write_register (VAX_AP_REGNUM, read_memory_integer (fp + 8, 4));
278 for (regnum = 0; regnum < 12; regnum++)
279 if (regmask & (0x10000 << regnum))
280 write_register (regnum, read_memory_integer (fp += 4, 4));
281 fp = fp + 4 + ((regmask >> 30) & 3);
282 if (regmask & 0x20000000)
284 regnum = read_memory_integer (fp, 4);
285 fp += (regnum + 1) * 4;
287 write_register (SP_REGNUM, fp);
288 flush_cached_frames ();
291 /* The VAX call dummy sequence:
293 calls #69, @#32323232
296 It is 8 bytes long. The address and argc are patched by
297 vax_fix_call_dummy(). */
298 static LONGEST vax_call_dummy_words[] = { 0x329f69fb, 0x03323232 };
299 static int sizeof_vax_call_dummy_words = sizeof(vax_call_dummy_words);
302 vax_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
303 struct value **args, struct type *type, int gcc_p)
306 store_unsigned_integer (dummy + 3, 4, fun);
310 vax_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
312 write_register (1, addr);
316 vax_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
318 memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (valtype));
322 vax_store_return_value (struct type *valtype, char *valbuf)
324 deprecated_write_register_bytes (0, valbuf, TYPE_LENGTH (valtype));
328 vax_extract_struct_value_address (char *regbuf)
330 return (extract_address (regbuf + REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
333 static const unsigned char *
334 vax_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
336 static const unsigned char vax_breakpoint[] = { 3 };
338 *lenptr = sizeof(vax_breakpoint);
339 return (vax_breakpoint);
342 /* Advance PC across any function entry prologue instructions
343 to reach some "real" code. */
346 vax_skip_prologue (CORE_ADDR pc)
348 register int op = (unsigned char) read_memory_integer (pc, 1);
350 pc += 2; /* skip brb */
352 pc += 3; /* skip brw */
354 && ((unsigned char) read_memory_integer (pc + 2, 1)) == 0x5E)
355 pc += 3; /* skip subl2 */
357 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xAE
358 && ((unsigned char) read_memory_integer (pc + 3, 1)) == 0x5E)
359 pc += 4; /* skip movab */
361 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xCE
362 && ((unsigned char) read_memory_integer (pc + 4, 1)) == 0x5E)
363 pc += 5; /* skip movab */
365 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xEE
366 && ((unsigned char) read_memory_integer (pc + 6, 1)) == 0x5E)
367 pc += 7; /* skip movab */
372 vax_saved_pc_after_call (struct frame_info *frame)
374 return (DEPRECATED_FRAME_SAVED_PC(frame));
377 /* Print the vax instruction at address MEMADDR in debugged memory,
378 from disassembler info INFO.
379 Returns length of the instruction, in bytes. */
382 vax_print_insn (CORE_ADDR memaddr, disassemble_info *info)
384 unsigned char buffer[MAXLEN];
386 register unsigned char *p;
389 int status = (*info->read_memory_func) (memaddr, buffer, MAXLEN, info);
392 (*info->memory_error_func) (status, memaddr, info);
396 for (i = 0; i < NOPCODES; i++)
397 if (votstrs[i].detail.code == buffer[0]
398 || votstrs[i].detail.code == *(unsigned short *) buffer)
401 /* Handle undefined instructions. */
404 (*info->fprintf_func) (info->stream, "0%o", buffer[0]);
408 (*info->fprintf_func) (info->stream, "%s", votstrs[i].name);
410 /* Point at first byte of argument data,
411 and at descriptor for first argument. */
412 p = buffer + 1 + (votstrs[i].detail.code >= 0x100);
413 d = votstrs[i].detail.args;
416 (*info->fprintf_func) (info->stream, " ");
420 p = print_insn_arg (d, p, memaddr + (p - buffer), info);
423 (*info->fprintf_func) (info->stream, ",");
428 static unsigned char *
429 print_insn_arg (char *d, register char *p, CORE_ADDR addr,
430 disassemble_info *info)
432 register int regnum = *p & 0xf;
438 (*info->fprintf_func) (info->stream, "0x%x", addr + *p++ + 1);
441 (*info->fprintf_func) (info->stream, "0x%x", addr + *(short *) p + 2);
446 switch ((*p++ >> 4) & 0xf)
451 case 3: /* Literal mode */
452 if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h')
454 *(int *) &floatlitbuf = 0x4000 + ((p[-1] & 0x3f) << 4);
455 (*info->fprintf_func) (info->stream, "$%f", floatlitbuf);
458 (*info->fprintf_func) (info->stream, "$%d", p[-1] & 0x3f);
461 case 4: /* Indexed */
462 p = (char *) print_insn_arg (d, p, addr + 1, info);
463 (*info->fprintf_func) (info->stream, "[%s]", REGISTER_NAME (regnum));
466 case 5: /* Register */
467 (*info->fprintf_func) (info->stream, REGISTER_NAME (regnum));
470 case 7: /* Autodecrement */
471 (*info->fprintf_func) (info->stream, "-");
472 case 6: /* Register deferred */
473 (*info->fprintf_func) (info->stream, "(%s)", REGISTER_NAME (regnum));
476 case 9: /* Autoincrement deferred */
477 (*info->fprintf_func) (info->stream, "@");
478 if (regnum == PC_REGNUM)
480 (*info->fprintf_func) (info->stream, "#");
481 info->target = *(long *) p;
482 (*info->print_address_func) (info->target, info);
486 case 8: /* Autoincrement */
487 if (regnum == PC_REGNUM)
489 (*info->fprintf_func) (info->stream, "#");
493 (*info->fprintf_func) (info->stream, "%d", *p++);
497 (*info->fprintf_func) (info->stream, "%d", *(short *) p);
502 (*info->fprintf_func) (info->stream, "%d", *(long *) p);
507 (*info->fprintf_func) (info->stream, "0x%x%08x",
508 ((long *) p)[1], ((long *) p)[0]);
513 (*info->fprintf_func) (info->stream, "0x%x%08x%08x%08x",
514 ((long *) p)[3], ((long *) p)[2],
515 ((long *) p)[1], ((long *) p)[0]);
520 if (INVALID_FLOAT (p, 4))
521 (*info->fprintf_func) (info->stream,
522 "<<invalid float 0x%x>>",
525 (*info->fprintf_func) (info->stream, "%f", *(float *) p);
530 if (INVALID_FLOAT (p, 8))
531 (*info->fprintf_func) (info->stream,
532 "<<invalid float 0x%x%08x>>",
533 ((long *) p)[1], ((long *) p)[0]);
535 (*info->fprintf_func) (info->stream, "%f", *(double *) p);
540 (*info->fprintf_func) (info->stream, "g-float");
545 (*info->fprintf_func) (info->stream, "h-float");
552 (*info->fprintf_func) (info->stream, "(%s)+", REGISTER_NAME (regnum));
555 case 11: /* Byte displacement deferred */
556 (*info->fprintf_func) (info->stream, "@");
557 case 10: /* Byte displacement */
558 if (regnum == PC_REGNUM)
560 info->target = addr + *p + 2;
561 (*info->print_address_func) (info->target, info);
564 (*info->fprintf_func) (info->stream, "%d(%s)", *p, REGISTER_NAME (regnum));
568 case 13: /* Word displacement deferred */
569 (*info->fprintf_func) (info->stream, "@");
570 case 12: /* Word displacement */
571 if (regnum == PC_REGNUM)
573 info->target = addr + *(short *) p + 3;
574 (*info->print_address_func) (info->target, info);
577 (*info->fprintf_func) (info->stream, "%d(%s)",
578 *(short *) p, REGISTER_NAME (regnum));
582 case 15: /* Long displacement deferred */
583 (*info->fprintf_func) (info->stream, "@");
584 case 14: /* Long displacement */
585 if (regnum == PC_REGNUM)
587 info->target = addr + *(short *) p + 5;
588 (*info->print_address_func) (info->target, info);
591 (*info->fprintf_func) (info->stream, "%d(%s)",
592 *(long *) p, REGISTER_NAME (regnum));
596 return (unsigned char *) p;
599 /* Initialize the current architecture based on INFO. If possible, re-use an
600 architecture from ARCHES, which is a list of architectures already created
601 during this debugging session.
603 Called e.g. at program startup, when reading a core file, and when reading
606 static struct gdbarch *
607 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
609 struct gdbarch *gdbarch;
611 /* If there is already a candidate, use it. */
612 arches = gdbarch_list_lookup_by_info (arches, &info);
614 return arches->gdbarch;
616 gdbarch = gdbarch_alloc (&info, NULL);
618 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
619 ready to unwind the PC first (see frame.c:get_prev_frame()). */
620 set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
623 set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
624 set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
625 set_gdbarch_fp_regnum (gdbarch, VAX_FP_REGNUM);
626 set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
627 set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
629 set_gdbarch_register_name (gdbarch, vax_register_name);
630 set_gdbarch_register_size (gdbarch, VAX_REGISTER_SIZE);
631 set_gdbarch_register_bytes (gdbarch, VAX_REGISTER_BYTES);
632 set_gdbarch_register_byte (gdbarch, vax_register_byte);
633 set_gdbarch_register_raw_size (gdbarch, vax_register_raw_size);
634 set_gdbarch_deprecated_max_register_raw_size (gdbarch, VAX_MAX_REGISTER_RAW_SIZE);
635 set_gdbarch_register_virtual_size (gdbarch, vax_register_virtual_size);
636 set_gdbarch_deprecated_max_register_virtual_size (gdbarch,
637 VAX_MAX_REGISTER_VIRTUAL_SIZE);
638 set_gdbarch_register_virtual_type (gdbarch, vax_register_virtual_type);
640 /* Frame and stack info */
641 set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
642 set_gdbarch_deprecated_saved_pc_after_call (gdbarch, vax_saved_pc_after_call);
644 set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
645 set_gdbarch_frameless_function_invocation (gdbarch,
646 generic_frameless_function_invocation_not);
648 set_gdbarch_deprecated_frame_chain (gdbarch, vax_frame_chain);
649 set_gdbarch_deprecated_frame_saved_pc (gdbarch, vax_frame_saved_pc);
651 set_gdbarch_frame_args_address (gdbarch, vax_frame_args_address);
652 set_gdbarch_frame_locals_address (gdbarch, vax_frame_locals_address);
654 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, vax_frame_init_saved_regs);
656 set_gdbarch_frame_args_skip (gdbarch, 4);
658 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
660 /* Return value info */
661 set_gdbarch_deprecated_store_struct_return (gdbarch, vax_store_struct_return);
662 set_gdbarch_deprecated_extract_return_value (gdbarch, vax_extract_return_value);
663 set_gdbarch_deprecated_store_return_value (gdbarch, vax_store_return_value);
664 set_gdbarch_deprecated_extract_struct_value_address (gdbarch, vax_extract_struct_value_address);
666 /* Call dummy info */
667 set_gdbarch_deprecated_push_dummy_frame (gdbarch, vax_push_dummy_frame);
668 set_gdbarch_deprecated_pop_frame (gdbarch, vax_pop_frame);
669 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
670 set_gdbarch_call_dummy_words (gdbarch, vax_call_dummy_words);
671 set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
672 set_gdbarch_fix_call_dummy (gdbarch, vax_fix_call_dummy);
673 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 7);
674 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
675 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
677 /* Breakpoint info */
678 set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
679 set_gdbarch_decr_pc_after_break (gdbarch, 0);
682 set_gdbarch_function_start_offset (gdbarch, 2);
683 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
685 /* Should be using push_dummy_call. */
686 set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
688 /* Hook in ABI-specific overrides, if they have been registered. */
689 gdbarch_init_osabi (info, gdbarch);
695 _initialize_vax_tdep (void)
697 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
699 tm_print_insn = vax_print_insn;