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"
34 static gdbarch_register_name_ftype vax_register_name;
35 static gdbarch_register_byte_ftype vax_register_byte;
36 static gdbarch_register_raw_size_ftype vax_register_raw_size;
37 static gdbarch_register_virtual_size_ftype vax_register_virtual_size;
38 static gdbarch_register_virtual_type_ftype vax_register_virtual_type;
40 static gdbarch_skip_prologue_ftype vax_skip_prologue;
41 static gdbarch_saved_pc_after_call_ftype vax_saved_pc_after_call;
42 static gdbarch_frame_num_args_ftype vax_frame_num_args;
43 static gdbarch_frame_chain_ftype vax_frame_chain;
44 static gdbarch_frame_saved_pc_ftype vax_frame_saved_pc;
45 static gdbarch_frame_args_address_ftype vax_frame_args_address;
46 static gdbarch_frame_locals_address_ftype vax_frame_locals_address;
47 static gdbarch_frame_init_saved_regs_ftype vax_frame_init_saved_regs;
48 static gdbarch_get_saved_register_ftype vax_get_saved_register;
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_store_return_value_ftype vax_store_return_value;
53 static gdbarch_deprecated_extract_struct_value_address_ftype
54 vax_extract_struct_value_address;
56 static gdbarch_push_dummy_frame_ftype vax_push_dummy_frame;
57 static gdbarch_pop_frame_ftype vax_pop_frame;
58 static gdbarch_fix_call_dummy_ftype vax_fix_call_dummy;
60 /* Return 1 if P points to an invalid floating point value.
61 LEN is the length in bytes -- not relevant on the Vax. */
63 /* FIXME: cagney/2002-01-19: The macro below was originally defined in
64 tm-vax.h and used in values.c. Two problems. Firstly this is a
65 very non-portable and secondly it is wrong. The VAX should be
66 using floatformat and associated methods to identify and handle
67 invalid floating-point values. Adding to the poor target's woes
68 there is no floatformat_vax_{f,d} and no TARGET_FLOAT_FORMAT
71 /* FIXME: cagney/2002-01-19: It turns out that the only thing that
72 uses this macro is the vax disassembler code (so how old is this
73 target?). This target should instead be using the opcodes
74 disassembler. That allowing the macro to be eliminated. */
76 #define INVALID_FLOAT(p, len) ((*(short *) p & 0xff80) == 0x8000)
78 /* Vax instructions are never longer than this. */
81 /* Number of elements in the opcode table. */
82 #define NOPCODES (sizeof votstrs / sizeof votstrs[0])
84 static unsigned char *print_insn_arg ();
87 vax_register_name (int regno)
89 static char *register_names[] =
91 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
92 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
98 if (regno >= (sizeof(register_names) / sizeof(*register_names)))
100 return (register_names[regno]);
104 vax_register_byte (int regno)
110 vax_register_raw_size (int regno)
116 vax_register_virtual_size (int regno)
122 vax_register_virtual_type (int regno)
124 return (builtin_type_int);
128 vax_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
129 struct frame_info *frame, int regnum,
130 enum lval_type *lval)
134 if (!target_has_registers)
135 error ("No registers.");
137 /* Normal systems don't optimize out things with register numbers. */
138 if (optimized != NULL)
140 addr = find_saved_register (frame, regnum);
145 if (regnum == SP_REGNUM)
147 if (raw_buffer != NULL)
149 /* Put it back in target format. */
150 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
157 if (raw_buffer != NULL)
158 target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
163 *lval = lval_register;
164 addr = REGISTER_BYTE (regnum);
165 if (raw_buffer != NULL)
166 read_register_gen (regnum, raw_buffer);
173 vax_frame_init_saved_regs (struct frame_info *frame)
178 if (frame->saved_regs)
181 frame_saved_regs_zalloc (frame);
183 regmask = read_memory_integer (frame->frame + 4, 4) >> 16;
185 next_addr = frame->frame + 16;
187 /* regmask's low bit is for register 0, which is the first one
188 what would be pushed. */
189 for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
191 if (regmask & (1 << regnum))
192 frame->saved_regs[regnum] = next_addr += 4;
195 frame->saved_regs[SP_REGNUM] = next_addr + 4;
196 if (regmask & (1 << FP_REGNUM))
197 frame->saved_regs[SP_REGNUM] +=
198 4 + (4 * read_memory_integer (next_addr + 4, 4));
200 frame->saved_regs[PC_REGNUM] = frame->frame + 16;
201 frame->saved_regs[FP_REGNUM] = frame->frame + 12;
202 frame->saved_regs[VAX_AP_REGNUM] = frame->frame + 8;
203 frame->saved_regs[PS_REGNUM] = frame->frame + 4;
207 vax_frame_saved_pc (struct frame_info *frame)
209 if (frame->signal_handler_caller)
210 return (sigtramp_saved_pc (frame)); /* XXXJRT */
212 return (read_memory_integer (frame->frame + 16, 4));
216 vax_frame_args_address_correct (struct frame_info *frame)
218 /* Cannot find the AP register value directly from the FP value. Must
219 find it saved in the frame called by this one, or in the AP register
220 for the innermost frame. However, there is no way to tell the
221 difference between the innermost frame and a frame for which we
222 just don't know the frame that it called (e.g. "info frame 0x7ffec789").
223 For the sake of argument, suppose that the stack is somewhat trashed
224 (which is one reason that "info frame" exists). So, return 0 (indicating
225 we don't know the address of the arglist) if we don't know what frame
228 return (read_memory_integer (frame->next->frame + 8, 4));
234 vax_frame_args_address (struct frame_info *frame)
236 /* In most of GDB, getting the args address is too important to
237 just say "I don't know". This is sometimes wrong for functions
238 that aren't on top of the stack, but c'est la vie. */
240 return (read_memory_integer (frame->next->frame + 8, 4));
242 return (read_register (VAX_AP_REGNUM));
246 vax_frame_locals_address (struct frame_info *frame)
248 return (frame->frame);
252 vax_frame_num_args (struct frame_info *fi)
254 return (0xff & read_memory_integer (FRAME_ARGS_ADDRESS (fi), 1));
258 vax_frame_chain (struct frame_info *frame)
260 /* In the case of the VAX, the frame's nominal address is the FP value,
261 and 12 bytes later comes the saved previous FP value as a 4-byte word. */
262 if (inside_entry_file (frame->pc))
265 return (read_memory_integer (frame->frame + 12, 4));
269 vax_push_dummy_frame (void)
271 CORE_ADDR sp = read_register (SP_REGNUM);
274 sp = push_word (sp, 0); /* arglist */
275 for (regnum = 11; regnum >= 0; regnum--)
276 sp = push_word (sp, read_register (regnum));
277 sp = push_word (sp, read_register (PC_REGNUM));
278 sp = push_word (sp, read_register (FP_REGNUM));
279 sp = push_word (sp, read_register (VAX_AP_REGNUM));
280 sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef) + 0x2fff0000);
281 sp = push_word (sp, 0);
282 write_register (SP_REGNUM, sp);
283 write_register (FP_REGNUM, sp);
284 write_register (VAX_AP_REGNUM, sp + (17 * 4));
290 CORE_ADDR fp = read_register (FP_REGNUM);
292 int regmask = read_memory_integer (fp + 4, 4);
294 write_register (PS_REGNUM,
296 | (read_register (PS_REGNUM) & 0xffff0000));
297 write_register (PC_REGNUM, read_memory_integer (fp + 16, 4));
298 write_register (FP_REGNUM, read_memory_integer (fp + 12, 4));
299 write_register (VAX_AP_REGNUM, read_memory_integer (fp + 8, 4));
301 for (regnum = 0; regnum < 12; regnum++)
302 if (regmask & (0x10000 << regnum))
303 write_register (regnum, read_memory_integer (fp += 4, 4));
304 fp = fp + 4 + ((regmask >> 30) & 3);
305 if (regmask & 0x20000000)
307 regnum = read_memory_integer (fp, 4);
308 fp += (regnum + 1) * 4;
310 write_register (SP_REGNUM, fp);
311 flush_cached_frames ();
314 /* The VAX call dummy sequence:
316 calls #69, @#32323232
319 It is 8 bytes long. The address and argc are patched by
320 vax_fix_call_dummy(). */
321 static LONGEST vax_call_dummy_words[] = { 0x329f69fb, 0x03323232 };
322 static int sizeof_vax_call_dummy_words = sizeof(vax_call_dummy_words);
325 vax_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
326 struct value **args, struct type *type, int gcc_p)
329 store_unsigned_integer (dummy + 3, 4, fun);
333 vax_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
335 write_register (1, addr);
339 vax_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
341 memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (valtype));
345 vax_store_return_value (struct type *valtype, char *valbuf)
347 write_register_bytes (0, valbuf, TYPE_LENGTH (valtype));
351 vax_extract_struct_value_address (char *regbuf)
353 return (extract_address (regbuf + REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
356 static const unsigned char *
357 vax_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
359 static const unsigned char vax_breakpoint[] = { 3 };
361 *lenptr = sizeof(vax_breakpoint);
362 return (vax_breakpoint);
365 /* Advance PC across any function entry prologue instructions
366 to reach some "real" code. */
369 vax_skip_prologue (CORE_ADDR pc)
371 register int op = (unsigned char) read_memory_integer (pc, 1);
373 pc += 2; /* skip brb */
375 pc += 3; /* skip brw */
377 && ((unsigned char) read_memory_integer (pc + 2, 1)) == 0x5E)
378 pc += 3; /* skip subl2 */
380 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xAE
381 && ((unsigned char) read_memory_integer (pc + 3, 1)) == 0x5E)
382 pc += 4; /* skip movab */
384 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xCE
385 && ((unsigned char) read_memory_integer (pc + 4, 1)) == 0x5E)
386 pc += 5; /* skip movab */
388 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xEE
389 && ((unsigned char) read_memory_integer (pc + 6, 1)) == 0x5E)
390 pc += 7; /* skip movab */
395 vax_saved_pc_after_call (struct frame_info *frame)
397 return (FRAME_SAVED_PC(frame));
400 /* Print the vax instruction at address MEMADDR in debugged memory,
401 from disassembler info INFO.
402 Returns length of the instruction, in bytes. */
405 vax_print_insn (CORE_ADDR memaddr, disassemble_info *info)
407 unsigned char buffer[MAXLEN];
409 register unsigned char *p;
412 int status = (*info->read_memory_func) (memaddr, buffer, MAXLEN, info);
415 (*info->memory_error_func) (status, memaddr, info);
419 for (i = 0; i < NOPCODES; i++)
420 if (votstrs[i].detail.code == buffer[0]
421 || votstrs[i].detail.code == *(unsigned short *) buffer)
424 /* Handle undefined instructions. */
427 (*info->fprintf_func) (info->stream, "0%o", buffer[0]);
431 (*info->fprintf_func) (info->stream, "%s", votstrs[i].name);
433 /* Point at first byte of argument data,
434 and at descriptor for first argument. */
435 p = buffer + 1 + (votstrs[i].detail.code >= 0x100);
436 d = votstrs[i].detail.args;
439 (*info->fprintf_func) (info->stream, " ");
443 p = print_insn_arg (d, p, memaddr + (p - buffer), info);
446 (*info->fprintf_func) (info->stream, ",");
451 static unsigned char *
452 print_insn_arg (char *d, register char *p, CORE_ADDR addr,
453 disassemble_info *info)
455 register int regnum = *p & 0xf;
461 (*info->fprintf_func) (info->stream, "0x%x", addr + *p++ + 1);
464 (*info->fprintf_func) (info->stream, "0x%x", addr + *(short *) p + 2);
469 switch ((*p++ >> 4) & 0xf)
474 case 3: /* Literal mode */
475 if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h')
477 *(int *) &floatlitbuf = 0x4000 + ((p[-1] & 0x3f) << 4);
478 (*info->fprintf_func) (info->stream, "$%f", floatlitbuf);
481 (*info->fprintf_func) (info->stream, "$%d", p[-1] & 0x3f);
484 case 4: /* Indexed */
485 p = (char *) print_insn_arg (d, p, addr + 1, info);
486 (*info->fprintf_func) (info->stream, "[%s]", REGISTER_NAME (regnum));
489 case 5: /* Register */
490 (*info->fprintf_func) (info->stream, REGISTER_NAME (regnum));
493 case 7: /* Autodecrement */
494 (*info->fprintf_func) (info->stream, "-");
495 case 6: /* Register deferred */
496 (*info->fprintf_func) (info->stream, "(%s)", REGISTER_NAME (regnum));
499 case 9: /* Autoincrement deferred */
500 (*info->fprintf_func) (info->stream, "@");
501 if (regnum == PC_REGNUM)
503 (*info->fprintf_func) (info->stream, "#");
504 info->target = *(long *) p;
505 (*info->print_address_func) (info->target, info);
509 case 8: /* Autoincrement */
510 if (regnum == PC_REGNUM)
512 (*info->fprintf_func) (info->stream, "#");
516 (*info->fprintf_func) (info->stream, "%d", *p++);
520 (*info->fprintf_func) (info->stream, "%d", *(short *) p);
525 (*info->fprintf_func) (info->stream, "%d", *(long *) p);
530 (*info->fprintf_func) (info->stream, "0x%x%08x",
531 ((long *) p)[1], ((long *) p)[0]);
536 (*info->fprintf_func) (info->stream, "0x%x%08x%08x%08x",
537 ((long *) p)[3], ((long *) p)[2],
538 ((long *) p)[1], ((long *) p)[0]);
543 if (INVALID_FLOAT (p, 4))
544 (*info->fprintf_func) (info->stream,
545 "<<invalid float 0x%x>>",
548 (*info->fprintf_func) (info->stream, "%f", *(float *) p);
553 if (INVALID_FLOAT (p, 8))
554 (*info->fprintf_func) (info->stream,
555 "<<invalid float 0x%x%08x>>",
556 ((long *) p)[1], ((long *) p)[0]);
558 (*info->fprintf_func) (info->stream, "%f", *(double *) p);
563 (*info->fprintf_func) (info->stream, "g-float");
568 (*info->fprintf_func) (info->stream, "h-float");
575 (*info->fprintf_func) (info->stream, "(%s)+", REGISTER_NAME (regnum));
578 case 11: /* Byte displacement deferred */
579 (*info->fprintf_func) (info->stream, "@");
580 case 10: /* Byte displacement */
581 if (regnum == PC_REGNUM)
583 info->target = addr + *p + 2;
584 (*info->print_address_func) (info->target, info);
587 (*info->fprintf_func) (info->stream, "%d(%s)", *p, REGISTER_NAME (regnum));
591 case 13: /* Word displacement deferred */
592 (*info->fprintf_func) (info->stream, "@");
593 case 12: /* Word displacement */
594 if (regnum == PC_REGNUM)
596 info->target = addr + *(short *) p + 3;
597 (*info->print_address_func) (info->target, info);
600 (*info->fprintf_func) (info->stream, "%d(%s)",
601 *(short *) p, REGISTER_NAME (regnum));
605 case 15: /* Long displacement deferred */
606 (*info->fprintf_func) (info->stream, "@");
607 case 14: /* Long displacement */
608 if (regnum == PC_REGNUM)
610 info->target = addr + *(short *) p + 5;
611 (*info->print_address_func) (info->target, info);
614 (*info->fprintf_func) (info->stream, "%d(%s)",
615 *(long *) p, REGISTER_NAME (regnum));
619 return (unsigned char *) p;
622 /* Initialize the current architecture based on INFO. If possible, re-use an
623 architecture from ARCHES, which is a list of architectures already created
624 during this debugging session.
626 Called e.g. at program startup, when reading a core file, and when reading
629 static struct gdbarch *
630 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
632 struct gdbarch_tdep *tdep;
633 struct gdbarch *gdbarch;
634 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
636 /* Try to determine the ABI of the object we are loading. */
638 if (info.abfd != NULL)
639 osabi = gdbarch_lookup_osabi (info.abfd);
641 /* Find a candidate among extant architectures. */
642 for (arches = gdbarch_list_lookup_by_info (arches, &info);
644 arches = gdbarch_list_lookup_by_info (arches->next, &info))
646 /* Make sure the ABI selection matches. */
647 tdep = gdbarch_tdep (arches->gdbarch);
648 if (tdep && tdep->osabi == osabi)
649 return arches->gdbarch;
652 tdep = xmalloc (sizeof (struct gdbarch_tdep));
653 gdbarch = gdbarch_alloc (&info, tdep);
658 set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
659 set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
660 set_gdbarch_fp_regnum (gdbarch, VAX_FP_REGNUM);
661 set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
662 set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
664 set_gdbarch_register_name (gdbarch, vax_register_name);
665 set_gdbarch_register_size (gdbarch, VAX_REGISTER_SIZE);
666 set_gdbarch_register_bytes (gdbarch, VAX_REGISTER_BYTES);
667 set_gdbarch_register_byte (gdbarch, vax_register_byte);
668 set_gdbarch_register_raw_size (gdbarch, vax_register_raw_size);
669 set_gdbarch_max_register_raw_size (gdbarch, VAX_MAX_REGISTER_RAW_SIZE);
670 set_gdbarch_register_virtual_size (gdbarch, vax_register_virtual_size);
671 set_gdbarch_max_register_virtual_size (gdbarch,
672 VAX_MAX_REGISTER_VIRTUAL_SIZE);
673 set_gdbarch_register_virtual_type (gdbarch, vax_register_virtual_type);
675 /* Frame and stack info */
676 set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
677 set_gdbarch_saved_pc_after_call (gdbarch, vax_saved_pc_after_call);
679 set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
680 set_gdbarch_frameless_function_invocation (gdbarch,
681 generic_frameless_function_invocation_not);
683 set_gdbarch_frame_chain (gdbarch, vax_frame_chain);
684 set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
685 set_gdbarch_frame_saved_pc (gdbarch, vax_frame_saved_pc);
687 set_gdbarch_frame_args_address (gdbarch, vax_frame_args_address);
688 set_gdbarch_frame_locals_address (gdbarch, vax_frame_locals_address);
690 set_gdbarch_frame_init_saved_regs (gdbarch, vax_frame_init_saved_regs);
692 set_gdbarch_frame_args_skip (gdbarch, 4);
694 set_gdbarch_get_saved_register (gdbarch, vax_get_saved_register);
696 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
698 /* Return value info */
699 set_gdbarch_store_struct_return (gdbarch, vax_store_struct_return);
700 set_gdbarch_deprecated_extract_return_value (gdbarch, vax_extract_return_value);
701 set_gdbarch_store_return_value (gdbarch, vax_store_return_value);
702 set_gdbarch_deprecated_extract_struct_value_address (gdbarch, vax_extract_struct_value_address);
704 /* Call dummy info */
705 set_gdbarch_push_dummy_frame (gdbarch, vax_push_dummy_frame);
706 set_gdbarch_pop_frame (gdbarch, vax_pop_frame);
707 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
708 set_gdbarch_call_dummy_p (gdbarch, 1);
709 set_gdbarch_call_dummy_words (gdbarch, vax_call_dummy_words);
710 set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
711 set_gdbarch_fix_call_dummy (gdbarch, vax_fix_call_dummy);
712 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
713 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
714 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 7);
715 set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
716 set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_on_stack);
717 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
719 /* Breakpoint info */
720 set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
721 set_gdbarch_decr_pc_after_break (gdbarch, 0);
724 set_gdbarch_function_start_offset (gdbarch, 2);
725 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
727 /* Hook in ABI-specific overrides, if they have been registered. */
728 gdbarch_init_osabi (info, gdbarch, osabi);
734 vax_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
736 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
741 fprintf_unfiltered (file, "vax_dump_tdep: OS ABI = %s\n",
742 gdbarch_osabi_name (tdep->osabi));
746 _initialize_vax_tdep (void)
748 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, vax_dump_tdep);
750 tm_print_insn = vax_print_insn;