1 /* Print VAX instructions for GDB, the GNU debugger.
2 Copyright 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000, 2002
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"
35 static gdbarch_register_name_ftype vax_register_name;
36 static gdbarch_register_byte_ftype vax_register_byte;
37 static gdbarch_register_raw_size_ftype vax_register_raw_size;
38 static gdbarch_register_virtual_size_ftype vax_register_virtual_size;
39 static gdbarch_register_virtual_type_ftype vax_register_virtual_type;
41 static gdbarch_skip_prologue_ftype vax_skip_prologue;
42 static gdbarch_saved_pc_after_call_ftype vax_saved_pc_after_call;
43 static gdbarch_frame_num_args_ftype vax_frame_num_args;
44 static gdbarch_frame_chain_ftype vax_frame_chain;
45 static gdbarch_frame_saved_pc_ftype vax_frame_saved_pc;
46 static gdbarch_frame_args_address_ftype vax_frame_args_address;
47 static gdbarch_frame_locals_address_ftype vax_frame_locals_address;
48 static gdbarch_frame_init_saved_regs_ftype vax_frame_init_saved_regs;
50 static gdbarch_store_struct_return_ftype vax_store_struct_return;
51 static gdbarch_deprecated_extract_return_value_ftype vax_extract_return_value;
52 static gdbarch_deprecated_extract_struct_value_address_ftype
53 vax_extract_struct_value_address;
55 static gdbarch_push_dummy_frame_ftype vax_push_dummy_frame;
56 static gdbarch_pop_frame_ftype vax_pop_frame;
57 static gdbarch_fix_call_dummy_ftype vax_fix_call_dummy;
59 /* Return 1 if P points to an invalid floating point value.
60 LEN is the length in bytes -- not relevant on the Vax. */
62 /* FIXME: cagney/2002-01-19: The macro below was originally defined in
63 tm-vax.h and used in values.c. Two problems. Firstly this is a
64 very non-portable and secondly it is wrong. The VAX should be
65 using floatformat and associated methods to identify and handle
66 invalid floating-point values. Adding to the poor target's woes
67 there is no floatformat_vax_{f,d} and no TARGET_FLOAT_FORMAT
70 /* FIXME: cagney/2002-01-19: It turns out that the only thing that
71 uses this macro is the vax disassembler code (so how old is this
72 target?). This target should instead be using the opcodes
73 disassembler. That allowing the macro to be eliminated. */
75 #define INVALID_FLOAT(p, len) ((*(short *) p & 0xff80) == 0x8000)
77 /* Vax instructions are never longer than this. */
80 /* Number of elements in the opcode table. */
81 #define NOPCODES (sizeof votstrs / sizeof votstrs[0])
83 static unsigned char *print_insn_arg ();
86 vax_register_name (int regno)
88 static char *register_names[] =
90 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
91 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
97 if (regno >= (sizeof(register_names) / sizeof(*register_names)))
99 return (register_names[regno]);
103 vax_register_byte (int regno)
109 vax_register_raw_size (int regno)
115 vax_register_virtual_size (int regno)
121 vax_register_virtual_type (int regno)
123 return (builtin_type_int);
127 vax_frame_init_saved_regs (struct frame_info *frame)
132 if (get_frame_saved_regs (frame))
135 frame_saved_regs_zalloc (frame);
137 regmask = read_memory_integer (frame->frame + 4, 4) >> 16;
139 next_addr = frame->frame + 16;
141 /* regmask's low bit is for register 0, which is the first one
142 what would be pushed. */
143 for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
145 if (regmask & (1 << regnum))
146 get_frame_saved_regs (frame)[regnum] = next_addr += 4;
149 get_frame_saved_regs (frame)[SP_REGNUM] = next_addr + 4;
150 if (regmask & (1 << FP_REGNUM))
151 get_frame_saved_regs (frame)[SP_REGNUM] +=
152 4 + (4 * read_memory_integer (next_addr + 4, 4));
154 get_frame_saved_regs (frame)[PC_REGNUM] = frame->frame + 16;
155 get_frame_saved_regs (frame)[FP_REGNUM] = frame->frame + 12;
156 get_frame_saved_regs (frame)[VAX_AP_REGNUM] = frame->frame + 8;
157 get_frame_saved_regs (frame)[PS_REGNUM] = frame->frame + 4;
160 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */
163 vax_sigtramp_saved_pc (struct frame_info *frame)
165 CORE_ADDR sigcontext_addr;
167 int ptrbytes = TYPE_LENGTH (builtin_type_void_func_ptr);
168 int sigcontext_offs = (2 * TARGET_INT_BIT) / TARGET_CHAR_BIT;
170 buf = alloca (ptrbytes);
171 /* Get sigcontext address, it is the third parameter on the stack. */
173 sigcontext_addr = read_memory_typed_address
174 (FRAME_ARGS_ADDRESS (frame->next) + FRAME_ARGS_SKIP + sigcontext_offs,
175 builtin_type_void_data_ptr);
177 sigcontext_addr = read_memory_typed_address
178 (read_register (SP_REGNUM) + sigcontext_offs, builtin_type_void_data_ptr);
180 /* Don't cause a memory_error when accessing sigcontext in case the stack
181 layout has changed or the stack is corrupt. */
182 target_read_memory (sigcontext_addr + SIGCONTEXT_PC_OFFSET, buf, ptrbytes);
183 return extract_typed_address (buf, builtin_type_void_func_ptr);
187 vax_frame_saved_pc (struct frame_info *frame)
189 if ((get_frame_type (frame) == SIGTRAMP_FRAME))
190 return (vax_sigtramp_saved_pc (frame)); /* XXXJRT */
192 return (read_memory_integer (frame->frame + 16, 4));
196 vax_frame_args_address_correct (struct frame_info *frame)
198 /* Cannot find the AP register value directly from the FP value. Must
199 find it saved in the frame called by this one, or in the AP register
200 for the innermost frame. However, there is no way to tell the
201 difference between the innermost frame and a frame for which we
202 just don't know the frame that it called (e.g. "info frame 0x7ffec789").
203 For the sake of argument, suppose that the stack is somewhat trashed
204 (which is one reason that "info frame" exists). So, return 0 (indicating
205 we don't know the address of the arglist) if we don't know what frame
208 return (read_memory_integer (frame->next->frame + 8, 4));
214 vax_frame_args_address (struct frame_info *frame)
216 /* In most of GDB, getting the args address is too important to
217 just say "I don't know". This is sometimes wrong for functions
218 that aren't on top of the stack, but c'est la vie. */
220 return (read_memory_integer (frame->next->frame + 8, 4));
222 return (read_register (VAX_AP_REGNUM));
226 vax_frame_locals_address (struct frame_info *frame)
228 return (frame->frame);
232 vax_frame_num_args (struct frame_info *fi)
234 return (0xff & read_memory_integer (FRAME_ARGS_ADDRESS (fi), 1));
238 vax_frame_chain (struct frame_info *frame)
240 /* In the case of the VAX, the frame's nominal address is the FP value,
241 and 12 bytes later comes the saved previous FP value as a 4-byte word. */
242 if (inside_entry_file (get_frame_pc (frame)))
245 return (read_memory_integer (frame->frame + 12, 4));
249 vax_push_dummy_frame (void)
251 CORE_ADDR sp = read_register (SP_REGNUM);
254 sp = push_word (sp, 0); /* arglist */
255 for (regnum = 11; regnum >= 0; regnum--)
256 sp = push_word (sp, read_register (regnum));
257 sp = push_word (sp, read_register (PC_REGNUM));
258 sp = push_word (sp, read_register (FP_REGNUM));
259 sp = push_word (sp, read_register (VAX_AP_REGNUM));
260 sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef) + 0x2fff0000);
261 sp = push_word (sp, 0);
262 write_register (SP_REGNUM, sp);
263 write_register (FP_REGNUM, sp);
264 write_register (VAX_AP_REGNUM, sp + (17 * 4));
270 CORE_ADDR fp = read_register (FP_REGNUM);
272 int regmask = read_memory_integer (fp + 4, 4);
274 write_register (PS_REGNUM,
276 | (read_register (PS_REGNUM) & 0xffff0000));
277 write_register (PC_REGNUM, read_memory_integer (fp + 16, 4));
278 write_register (FP_REGNUM, read_memory_integer (fp + 12, 4));
279 write_register (VAX_AP_REGNUM, read_memory_integer (fp + 8, 4));
281 for (regnum = 0; regnum < 12; regnum++)
282 if (regmask & (0x10000 << regnum))
283 write_register (regnum, read_memory_integer (fp += 4, 4));
284 fp = fp + 4 + ((regmask >> 30) & 3);
285 if (regmask & 0x20000000)
287 regnum = read_memory_integer (fp, 4);
288 fp += (regnum + 1) * 4;
290 write_register (SP_REGNUM, fp);
291 flush_cached_frames ();
294 /* The VAX call dummy sequence:
296 calls #69, @#32323232
299 It is 8 bytes long. The address and argc are patched by
300 vax_fix_call_dummy(). */
301 static LONGEST vax_call_dummy_words[] = { 0x329f69fb, 0x03323232 };
302 static int sizeof_vax_call_dummy_words = sizeof(vax_call_dummy_words);
305 vax_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
306 struct value **args, struct type *type, int gcc_p)
309 store_unsigned_integer (dummy + 3, 4, fun);
313 vax_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
315 write_register (1, addr);
319 vax_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
321 memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (valtype));
325 vax_store_return_value (struct type *valtype, char *valbuf)
327 deprecated_write_register_bytes (0, valbuf, TYPE_LENGTH (valtype));
331 vax_extract_struct_value_address (char *regbuf)
333 return (extract_address (regbuf + REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
336 static const unsigned char *
337 vax_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
339 static const unsigned char vax_breakpoint[] = { 3 };
341 *lenptr = sizeof(vax_breakpoint);
342 return (vax_breakpoint);
345 /* Advance PC across any function entry prologue instructions
346 to reach some "real" code. */
349 vax_skip_prologue (CORE_ADDR pc)
351 register int op = (unsigned char) read_memory_integer (pc, 1);
353 pc += 2; /* skip brb */
355 pc += 3; /* skip brw */
357 && ((unsigned char) read_memory_integer (pc + 2, 1)) == 0x5E)
358 pc += 3; /* skip subl2 */
360 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xAE
361 && ((unsigned char) read_memory_integer (pc + 3, 1)) == 0x5E)
362 pc += 4; /* skip movab */
364 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xCE
365 && ((unsigned char) read_memory_integer (pc + 4, 1)) == 0x5E)
366 pc += 5; /* skip movab */
368 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xEE
369 && ((unsigned char) read_memory_integer (pc + 6, 1)) == 0x5E)
370 pc += 7; /* skip movab */
375 vax_saved_pc_after_call (struct frame_info *frame)
377 return (FRAME_SAVED_PC(frame));
380 /* Print the vax instruction at address MEMADDR in debugged memory,
381 from disassembler info INFO.
382 Returns length of the instruction, in bytes. */
385 vax_print_insn (CORE_ADDR memaddr, disassemble_info *info)
387 unsigned char buffer[MAXLEN];
389 register unsigned char *p;
392 int status = (*info->read_memory_func) (memaddr, buffer, MAXLEN, info);
395 (*info->memory_error_func) (status, memaddr, info);
399 for (i = 0; i < NOPCODES; i++)
400 if (votstrs[i].detail.code == buffer[0]
401 || votstrs[i].detail.code == *(unsigned short *) buffer)
404 /* Handle undefined instructions. */
407 (*info->fprintf_func) (info->stream, "0%o", buffer[0]);
411 (*info->fprintf_func) (info->stream, "%s", votstrs[i].name);
413 /* Point at first byte of argument data,
414 and at descriptor for first argument. */
415 p = buffer + 1 + (votstrs[i].detail.code >= 0x100);
416 d = votstrs[i].detail.args;
419 (*info->fprintf_func) (info->stream, " ");
423 p = print_insn_arg (d, p, memaddr + (p - buffer), info);
426 (*info->fprintf_func) (info->stream, ",");
431 static unsigned char *
432 print_insn_arg (char *d, register char *p, CORE_ADDR addr,
433 disassemble_info *info)
435 register int regnum = *p & 0xf;
441 (*info->fprintf_func) (info->stream, "0x%x", addr + *p++ + 1);
444 (*info->fprintf_func) (info->stream, "0x%x", addr + *(short *) p + 2);
449 switch ((*p++ >> 4) & 0xf)
454 case 3: /* Literal mode */
455 if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h')
457 *(int *) &floatlitbuf = 0x4000 + ((p[-1] & 0x3f) << 4);
458 (*info->fprintf_func) (info->stream, "$%f", floatlitbuf);
461 (*info->fprintf_func) (info->stream, "$%d", p[-1] & 0x3f);
464 case 4: /* Indexed */
465 p = (char *) print_insn_arg (d, p, addr + 1, info);
466 (*info->fprintf_func) (info->stream, "[%s]", REGISTER_NAME (regnum));
469 case 5: /* Register */
470 (*info->fprintf_func) (info->stream, REGISTER_NAME (regnum));
473 case 7: /* Autodecrement */
474 (*info->fprintf_func) (info->stream, "-");
475 case 6: /* Register deferred */
476 (*info->fprintf_func) (info->stream, "(%s)", REGISTER_NAME (regnum));
479 case 9: /* Autoincrement deferred */
480 (*info->fprintf_func) (info->stream, "@");
481 if (regnum == PC_REGNUM)
483 (*info->fprintf_func) (info->stream, "#");
484 info->target = *(long *) p;
485 (*info->print_address_func) (info->target, info);
489 case 8: /* Autoincrement */
490 if (regnum == PC_REGNUM)
492 (*info->fprintf_func) (info->stream, "#");
496 (*info->fprintf_func) (info->stream, "%d", *p++);
500 (*info->fprintf_func) (info->stream, "%d", *(short *) p);
505 (*info->fprintf_func) (info->stream, "%d", *(long *) p);
510 (*info->fprintf_func) (info->stream, "0x%x%08x",
511 ((long *) p)[1], ((long *) p)[0]);
516 (*info->fprintf_func) (info->stream, "0x%x%08x%08x%08x",
517 ((long *) p)[3], ((long *) p)[2],
518 ((long *) p)[1], ((long *) p)[0]);
523 if (INVALID_FLOAT (p, 4))
524 (*info->fprintf_func) (info->stream,
525 "<<invalid float 0x%x>>",
528 (*info->fprintf_func) (info->stream, "%f", *(float *) p);
533 if (INVALID_FLOAT (p, 8))
534 (*info->fprintf_func) (info->stream,
535 "<<invalid float 0x%x%08x>>",
536 ((long *) p)[1], ((long *) p)[0]);
538 (*info->fprintf_func) (info->stream, "%f", *(double *) p);
543 (*info->fprintf_func) (info->stream, "g-float");
548 (*info->fprintf_func) (info->stream, "h-float");
555 (*info->fprintf_func) (info->stream, "(%s)+", REGISTER_NAME (regnum));
558 case 11: /* Byte displacement deferred */
559 (*info->fprintf_func) (info->stream, "@");
560 case 10: /* Byte displacement */
561 if (regnum == PC_REGNUM)
563 info->target = addr + *p + 2;
564 (*info->print_address_func) (info->target, info);
567 (*info->fprintf_func) (info->stream, "%d(%s)", *p, REGISTER_NAME (regnum));
571 case 13: /* Word displacement deferred */
572 (*info->fprintf_func) (info->stream, "@");
573 case 12: /* Word displacement */
574 if (regnum == PC_REGNUM)
576 info->target = addr + *(short *) p + 3;
577 (*info->print_address_func) (info->target, info);
580 (*info->fprintf_func) (info->stream, "%d(%s)",
581 *(short *) p, REGISTER_NAME (regnum));
585 case 15: /* Long displacement deferred */
586 (*info->fprintf_func) (info->stream, "@");
587 case 14: /* Long displacement */
588 if (regnum == PC_REGNUM)
590 info->target = addr + *(short *) p + 5;
591 (*info->print_address_func) (info->target, info);
594 (*info->fprintf_func) (info->stream, "%d(%s)",
595 *(long *) p, REGISTER_NAME (regnum));
599 return (unsigned char *) p;
602 /* Initialize the current architecture based on INFO. If possible, re-use an
603 architecture from ARCHES, which is a list of architectures already created
604 during this debugging session.
606 Called e.g. at program startup, when reading a core file, and when reading
609 static struct gdbarch *
610 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
612 struct gdbarch_tdep *tdep;
613 struct gdbarch *gdbarch;
614 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
616 /* Try to determine the ABI of the object we are loading. */
618 if (info.abfd != NULL)
619 osabi = gdbarch_lookup_osabi (info.abfd);
621 /* Find a candidate among extant architectures. */
622 for (arches = gdbarch_list_lookup_by_info (arches, &info);
624 arches = gdbarch_list_lookup_by_info (arches->next, &info))
626 /* Make sure the ABI selection matches. */
627 tdep = gdbarch_tdep (arches->gdbarch);
628 if (tdep && tdep->osabi == osabi)
629 return arches->gdbarch;
632 tdep = xmalloc (sizeof (struct gdbarch_tdep));
633 gdbarch = gdbarch_alloc (&info, tdep);
635 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
636 ready to unwind the PC first (see frame.c:get_prev_frame()). */
637 set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
642 set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
643 set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
644 set_gdbarch_fp_regnum (gdbarch, VAX_FP_REGNUM);
645 set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
646 set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
648 set_gdbarch_register_name (gdbarch, vax_register_name);
649 set_gdbarch_register_size (gdbarch, VAX_REGISTER_SIZE);
650 set_gdbarch_register_bytes (gdbarch, VAX_REGISTER_BYTES);
651 set_gdbarch_register_byte (gdbarch, vax_register_byte);
652 set_gdbarch_register_raw_size (gdbarch, vax_register_raw_size);
653 set_gdbarch_max_register_raw_size (gdbarch, VAX_MAX_REGISTER_RAW_SIZE);
654 set_gdbarch_register_virtual_size (gdbarch, vax_register_virtual_size);
655 set_gdbarch_max_register_virtual_size (gdbarch,
656 VAX_MAX_REGISTER_VIRTUAL_SIZE);
657 set_gdbarch_register_virtual_type (gdbarch, vax_register_virtual_type);
659 /* Frame and stack info */
660 set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
661 set_gdbarch_saved_pc_after_call (gdbarch, vax_saved_pc_after_call);
663 set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
664 set_gdbarch_frameless_function_invocation (gdbarch,
665 generic_frameless_function_invocation_not);
667 set_gdbarch_frame_chain (gdbarch, vax_frame_chain);
668 set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
669 set_gdbarch_frame_saved_pc (gdbarch, vax_frame_saved_pc);
671 set_gdbarch_frame_args_address (gdbarch, vax_frame_args_address);
672 set_gdbarch_frame_locals_address (gdbarch, vax_frame_locals_address);
674 set_gdbarch_frame_init_saved_regs (gdbarch, vax_frame_init_saved_regs);
676 set_gdbarch_frame_args_skip (gdbarch, 4);
678 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
680 /* Return value info */
681 set_gdbarch_store_struct_return (gdbarch, vax_store_struct_return);
682 set_gdbarch_deprecated_extract_return_value (gdbarch, vax_extract_return_value);
683 set_gdbarch_deprecated_store_return_value (gdbarch, vax_store_return_value);
684 set_gdbarch_deprecated_extract_struct_value_address (gdbarch, vax_extract_struct_value_address);
686 /* Call dummy info */
687 set_gdbarch_push_dummy_frame (gdbarch, vax_push_dummy_frame);
688 set_gdbarch_pop_frame (gdbarch, vax_pop_frame);
689 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
690 set_gdbarch_call_dummy_p (gdbarch, 1);
691 set_gdbarch_call_dummy_words (gdbarch, vax_call_dummy_words);
692 set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
693 set_gdbarch_fix_call_dummy (gdbarch, vax_fix_call_dummy);
694 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
695 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
696 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 7);
697 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
698 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
699 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
701 /* Breakpoint info */
702 set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
703 set_gdbarch_decr_pc_after_break (gdbarch, 0);
706 set_gdbarch_function_start_offset (gdbarch, 2);
707 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
709 /* Hook in ABI-specific overrides, if they have been registered. */
710 gdbarch_init_osabi (info, gdbarch, osabi);
716 vax_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
718 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
723 fprintf_unfiltered (file, "vax_dump_tdep: OS ABI = %s\n",
724 gdbarch_osabi_name (tdep->osabi));
728 _initialize_vax_tdep (void)
730 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, vax_dump_tdep);
732 tm_print_insn = vax_print_insn;