1 /* Print VAX instructions for GDB, the GNU debugger.
3 Copyright 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000,
4 2002, 2003, 2004 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "opcode/vax.h"
30 #include "frame-base.h"
31 #include "frame-unwind.h"
32 #include "trad-frame.h"
34 #include "arch-utils.h"
35 #include "gdb_string.h"
41 /* Return the name of register REGNUM. */
44 vax_register_name (int regnum)
46 static char *register_names[] =
48 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
49 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
53 if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
54 return register_names[regnum];
59 /* Return the GDB type object for the "standard" data type of data in
63 vax_register_type (struct gdbarch *gdbarch, int regnum)
65 return builtin_type_int;
70 vax_store_arguments (struct regcache *regcache, int nargs,
71 struct value **args, CORE_ADDR sp,
72 int struct_return, CORE_ADDR struct_addr)
78 /* We create an argument list on the stack, and make the argument
81 /* Push arguments in reverse order. */
82 for (i = nargs - 1; i >= 0; i--)
84 int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
87 count += (len + 3) / 4;
88 write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
91 /* Push value address. */
96 store_unsigned_integer (buf, 4, struct_addr);
97 write_memory (sp, buf, 4);
100 /* Push argument count. */
102 store_unsigned_integer (buf, 4, count);
103 write_memory (sp, buf, 4);
105 /* Update the argument pointer. */
106 store_unsigned_integer (buf, 4, sp);
107 regcache_cooked_write (regcache, VAX_AP_REGNUM, buf);
113 vax_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
114 struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
115 struct value **args, CORE_ADDR sp, int struct_return,
116 CORE_ADDR struct_addr)
121 /* Set up the function arguments. */
122 sp = vax_store_arguments (regcache, nargs, args, sp,
123 struct_return, struct_addr);
125 /* Store return address in the PC slot. */
127 store_unsigned_integer (buf, 4, bp_addr);
128 write_memory (sp, buf, 4);
130 /* Store the (fake) frame pointer in the FP slot. */
132 store_unsigned_integer (buf, 4, fp);
133 write_memory (sp, buf, 4);
135 /* Skip the AP slot. */
138 /* Store register save mask and control bits. */
140 store_unsigned_integer (buf, 4, 0);
141 write_memory (sp, buf, 4);
143 /* Store condition handler. */
145 store_unsigned_integer (buf, 4, 0);
146 write_memory (sp, buf, 4);
148 /* Update the stack pointer and frame pointer. */
149 store_unsigned_integer (buf, 4, sp);
150 regcache_cooked_write (regcache, VAX_SP_REGNUM, buf);
151 regcache_cooked_write (regcache, VAX_FP_REGNUM, buf);
153 /* Return the saved (fake) frame pointer. */
157 static struct frame_id
158 vax_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
162 fp = frame_unwind_register_unsigned (next_frame, VAX_FP_REGNUM);
163 return frame_id_build (fp, frame_pc_unwind (next_frame));
168 vax_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
170 write_register (1, addr);
174 vax_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
176 memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (0), TYPE_LENGTH (valtype));
180 vax_store_return_value (struct type *valtype, char *valbuf)
182 deprecated_write_register_bytes (0, valbuf, TYPE_LENGTH (valtype));
186 /* Use the program counter to determine the contents and size of a
187 breakpoint instruction. Return a pointer to a string of bytes that
188 encode a breakpoint instruction, store the length of the string in
189 *LEN and optionally adjust *PC to point to the correct memory
190 location for inserting the breakpoint. */
192 static const unsigned char *
193 vax_breakpoint_from_pc (CORE_ADDR *pc, int *len)
195 static unsigned char break_insn[] = { 3 };
197 *len = sizeof (break_insn);
201 /* Advance PC across any function entry prologue instructions
202 to reach some "real" code. */
205 vax_skip_prologue (CORE_ADDR pc)
207 int op = (unsigned char) read_memory_integer (pc, 1);
209 pc += 2; /* skip brb */
211 pc += 3; /* skip brw */
213 && ((unsigned char) read_memory_integer (pc + 2, 1)) == 0x5E)
214 pc += 3; /* skip subl2 */
216 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xAE
217 && ((unsigned char) read_memory_integer (pc + 3, 1)) == 0x5E)
218 pc += 4; /* skip movab */
220 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xCE
221 && ((unsigned char) read_memory_integer (pc + 4, 1)) == 0x5E)
222 pc += 5; /* skip movab */
224 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xEE
225 && ((unsigned char) read_memory_integer (pc + 6, 1)) == 0x5E)
226 pc += 7; /* skip movab */
231 /* Unwinding the stack is relatively easy since the VAX has a
232 dedicated frame pointer, and frames are set up automatically as the
233 result of a function call. Most of the relevant information can be
234 inferred from the documentation of the Procedure Call Instructions
235 in the VAX MACRO and Instruction Set Reference Manual. */
237 struct vax_frame_cache
242 /* Table of saved registers. */
243 struct trad_frame_saved_reg *saved_regs;
246 struct vax_frame_cache *
247 vax_frame_cache (struct frame_info *next_frame, void **this_cache)
249 struct vax_frame_cache *cache;
257 /* Allocate a new cache. */
258 cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
259 cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
261 /* The frame pointer is used as the base for the frame. */
262 cache->base = frame_unwind_register_unsigned (next_frame, VAX_FP_REGNUM);
263 if (cache->base == 0)
266 /* The register save mask and control bits determine the layout of
268 mask = get_frame_memory_unsigned (next_frame, cache->base + 4, 4) >> 16;
270 /* These are always saved. */
271 cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16;
272 cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12;
273 cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8;
274 cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4;
276 /* Scan the register save mask and record the location of the saved
278 addr = cache->base + 20;
279 for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
281 if (mask & (1 << regnum))
283 cache->saved_regs[regnum].addr = addr;
288 /* The CALLS/CALLG flag determines whether this frame has a General
289 Argument List or a Stack Argument List. */
290 if (mask & (1 << 13))
294 /* This is a procedure with Stack Argument List. Adjust the
295 stack address for the arguments thet were pushed onto the
296 stack. The return instruction will automatically pop the
297 arguments from the stack. */
298 numarg = get_frame_memory_unsigned (next_frame, addr, 1);
299 addr += 4 + numarg * 4;
302 /* Bits 1:0 of the stack pointer were saved in the control bits. */
303 trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14));
309 vax_frame_this_id (struct frame_info *next_frame, void **this_cache,
310 struct frame_id *this_id)
312 struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache);
314 /* This marks the outermost frame. */
315 if (cache->base == 0)
318 (*this_id) = frame_id_build (cache->base, frame_pc_unwind (next_frame));
322 vax_frame_prev_register (struct frame_info *next_frame, void **this_cache,
323 int regnum, int *optimizedp,
324 enum lval_type *lvalp, CORE_ADDR *addrp,
325 int *realnump, void *valuep)
327 struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache);
329 trad_frame_prev_register (next_frame, cache->saved_regs, regnum,
330 optimizedp, lvalp, addrp, realnump, valuep);
333 static const struct frame_unwind vax_frame_unwind =
337 vax_frame_prev_register
340 static const struct frame_unwind *
341 vax_frame_sniffer (struct frame_info *next_frame)
343 return &vax_frame_unwind;
348 vax_frame_base_address (struct frame_info *next_frame, void **this_cache)
350 struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache);
356 vax_frame_args_address (struct frame_info *next_frame, void **this_cache)
358 return frame_unwind_register_unsigned (next_frame, VAX_AP_REGNUM);
361 static const struct frame_base vax_frame_base =
364 vax_frame_base_address,
365 vax_frame_base_address,
366 vax_frame_args_address
369 /* Return number of arguments for FRAME. */
372 vax_frame_num_args (struct frame_info *frame)
376 /* Assume that the argument pointer for the outermost frame is
377 hosed, as is the case on NetBSD/vax ELF. */
378 if (get_frame_base (frame) == 0)
381 args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
382 return get_frame_memory_unsigned (frame, args, 1);
386 vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
388 return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM);
392 /* Initialize the current architecture based on INFO. If possible, re-use an
393 architecture from ARCHES, which is a list of architectures already created
394 during this debugging session.
396 Called e.g. at program startup, when reading a core file, and when reading
399 static struct gdbarch *
400 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
402 struct gdbarch *gdbarch;
404 /* If there is already a candidate, use it. */
405 arches = gdbarch_list_lookup_by_info (arches, &info);
407 return arches->gdbarch;
409 gdbarch = gdbarch_alloc (&info, NULL);
412 set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
413 set_gdbarch_register_name (gdbarch, vax_register_name);
414 set_gdbarch_register_type (gdbarch, vax_register_type);
415 set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
416 set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
417 set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
419 /* Frame and stack info */
420 set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
421 set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
423 set_gdbarch_frame_args_skip (gdbarch, 4);
425 /* Stack grows downward. */
426 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
428 /* Return value info */
429 set_gdbarch_deprecated_store_struct_return (gdbarch, vax_store_struct_return);
430 set_gdbarch_deprecated_extract_return_value (gdbarch, vax_extract_return_value);
431 set_gdbarch_deprecated_store_return_value (gdbarch, vax_store_return_value);
433 /* Call dummy code. */
434 set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
435 set_gdbarch_unwind_dummy_id (gdbarch, vax_unwind_dummy_id);
437 /* Breakpoint info */
438 set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
441 set_gdbarch_function_start_offset (gdbarch, 2);
442 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
444 set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
446 frame_base_set_default (gdbarch, &vax_frame_base);
448 /* Hook in ABI-specific overrides, if they have been registered. */
449 gdbarch_init_osabi (info, gdbarch);
451 frame_unwind_append_sniffer (gdbarch, vax_frame_sniffer);
453 set_gdbarch_print_insn (gdbarch, print_insn_vax);
458 extern initialize_file_ftype _initialize_vax_tdep; /* -Wmissing-prototypes */
461 _initialize_vax_tdep (void)
463 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);