1 /* Target-dependent code for the VAX.
3 Copyright (C) 1986-2013 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 3 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, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
23 #include "floatformat.h"
25 #include "frame-base.h"
26 #include "frame-unwind.h"
32 #include "trad-frame.h"
39 /* Return the name of register REGNUM. */
42 vax_register_name (struct gdbarch *gdbarch, int regnum)
44 static char *register_names[] =
46 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
47 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
51 if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
52 return register_names[regnum];
57 /* Return the GDB type object for the "standard" data type of data in
61 vax_register_type (struct gdbarch *gdbarch, int regnum)
63 return builtin_type (gdbarch)->builtin_int;
66 /* Core file support. */
68 /* Supply register REGNUM from the buffer specified by GREGS and LEN
69 in the general-purpose register set REGSET to register cache
70 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
73 vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
74 int regnum, const void *gregs, size_t len)
76 const gdb_byte *regs = gregs;
79 for (i = 0; i < VAX_NUM_REGS; i++)
81 if (regnum == i || regnum == -1)
82 regcache_raw_supply (regcache, i, regs + i * 4);
86 /* VAX register set. */
88 static struct regset vax_gregset =
94 /* Return the appropriate register set for the core section identified
95 by SECT_NAME and SECT_SIZE. */
97 static const struct regset *
98 vax_regset_from_core_section (struct gdbarch *gdbarch,
99 const char *sect_name, size_t sect_size)
101 if (strcmp (sect_name, ".reg") == 0 && sect_size >= VAX_NUM_REGS * 4)
107 /* The VAX UNIX calling convention uses R1 to pass a structure return
108 value address instead of passing it as a first (hidden) argument as
109 the VMS calling convention suggests. */
112 vax_store_arguments (struct regcache *regcache, int nargs,
113 struct value **args, CORE_ADDR sp)
115 struct gdbarch *gdbarch = get_regcache_arch (regcache);
116 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
121 /* We create an argument list on the stack, and make the argument
124 /* Push arguments in reverse order. */
125 for (i = nargs - 1; i >= 0; i--)
127 int len = TYPE_LENGTH (value_enclosing_type (args[i]));
129 sp -= (len + 3) & ~3;
130 count += (len + 3) / 4;
131 write_memory (sp, value_contents_all (args[i]), len);
134 /* Push argument count. */
136 store_unsigned_integer (buf, 4, byte_order, count);
137 write_memory (sp, buf, 4);
139 /* Update the argument pointer. */
140 store_unsigned_integer (buf, 4, byte_order, sp);
141 regcache_cooked_write (regcache, VAX_AP_REGNUM, buf);
147 vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
148 struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
149 struct value **args, CORE_ADDR sp, int struct_return,
150 CORE_ADDR struct_addr)
152 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
156 /* Set up the function arguments. */
157 sp = vax_store_arguments (regcache, nargs, args, sp);
159 /* Store return value address. */
161 regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr);
163 /* Store return address in the PC slot. */
165 store_unsigned_integer (buf, 4, byte_order, bp_addr);
166 write_memory (sp, buf, 4);
168 /* Store the (fake) frame pointer in the FP slot. */
170 store_unsigned_integer (buf, 4, byte_order, fp);
171 write_memory (sp, buf, 4);
173 /* Skip the AP slot. */
176 /* Store register save mask and control bits. */
178 store_unsigned_integer (buf, 4, byte_order, 0);
179 write_memory (sp, buf, 4);
181 /* Store condition handler. */
183 store_unsigned_integer (buf, 4, byte_order, 0);
184 write_memory (sp, buf, 4);
186 /* Update the stack pointer and frame pointer. */
187 store_unsigned_integer (buf, 4, byte_order, sp);
188 regcache_cooked_write (regcache, VAX_SP_REGNUM, buf);
189 regcache_cooked_write (regcache, VAX_FP_REGNUM, buf);
191 /* Return the saved (fake) frame pointer. */
195 static struct frame_id
196 vax_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
200 fp = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
201 return frame_id_build (fp, get_frame_pc (this_frame));
205 static enum return_value_convention
206 vax_return_value (struct gdbarch *gdbarch, struct value *function,
207 struct type *type, struct regcache *regcache,
208 gdb_byte *readbuf, const gdb_byte *writebuf)
210 int len = TYPE_LENGTH (type);
213 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
214 || TYPE_CODE (type) == TYPE_CODE_UNION
215 || TYPE_CODE (type) == TYPE_CODE_ARRAY)
217 /* The default on VAX is to return structures in static memory.
218 Consequently a function must return the address where we can
219 find the return value. */
225 regcache_raw_read_unsigned (regcache, VAX_R0_REGNUM, &addr);
226 read_memory (addr, readbuf, len);
229 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
234 /* Read the contents of R0 and (if necessary) R1. */
235 regcache_cooked_read (regcache, VAX_R0_REGNUM, buf);
237 regcache_cooked_read (regcache, VAX_R1_REGNUM, buf + 4);
238 memcpy (readbuf, buf, len);
242 /* Read the contents to R0 and (if necessary) R1. */
243 memcpy (buf, writebuf, len);
244 regcache_cooked_write (regcache, VAX_R0_REGNUM, buf);
246 regcache_cooked_write (regcache, VAX_R1_REGNUM, buf + 4);
249 return RETURN_VALUE_REGISTER_CONVENTION;
253 /* Use the program counter to determine the contents and size of a
254 breakpoint instruction. Return a pointer to a string of bytes that
255 encode a breakpoint instruction, store the length of the string in
256 *LEN and optionally adjust *PC to point to the correct memory
257 location for inserting the breakpoint. */
259 static const gdb_byte *
260 vax_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
262 static gdb_byte break_insn[] = { 3 };
264 *len = sizeof (break_insn);
268 /* Advance PC across any function entry prologue instructions
269 to reach some "real" code. */
272 vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
274 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
275 gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order);
278 pc += 2; /* skip brb */
280 pc += 3; /* skip brw */
282 && read_memory_unsigned_integer (pc + 2, 1, byte_order) == 0x5E)
283 pc += 3; /* skip subl2 */
285 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xAE
286 && read_memory_unsigned_integer (pc + 3, 1, byte_order) == 0x5E)
287 pc += 4; /* skip movab */
289 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xCE
290 && read_memory_unsigned_integer (pc + 4, 1, byte_order) == 0x5E)
291 pc += 5; /* skip movab */
293 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xEE
294 && read_memory_unsigned_integer (pc + 6, 1, byte_order) == 0x5E)
295 pc += 7; /* skip movab */
301 /* Unwinding the stack is relatively easy since the VAX has a
302 dedicated frame pointer, and frames are set up automatically as the
303 result of a function call. Most of the relevant information can be
304 inferred from the documentation of the Procedure Call Instructions
305 in the VAX MACRO and Instruction Set Reference Manual. */
307 struct vax_frame_cache
312 /* Table of saved registers. */
313 struct trad_frame_saved_reg *saved_regs;
316 static struct vax_frame_cache *
317 vax_frame_cache (struct frame_info *this_frame, void **this_cache)
319 struct vax_frame_cache *cache;
327 /* Allocate a new cache. */
328 cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
329 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
331 /* The frame pointer is used as the base for the frame. */
332 cache->base = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
333 if (cache->base == 0)
336 /* The register save mask and control bits determine the layout of
338 mask = get_frame_memory_unsigned (this_frame, cache->base + 4, 4) >> 16;
340 /* These are always saved. */
341 cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16;
342 cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12;
343 cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8;
344 cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4;
346 /* Scan the register save mask and record the location of the saved
348 addr = cache->base + 20;
349 for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
351 if (mask & (1 << regnum))
353 cache->saved_regs[regnum].addr = addr;
358 /* The CALLS/CALLG flag determines whether this frame has a General
359 Argument List or a Stack Argument List. */
360 if (mask & (1 << 13))
364 /* This is a procedure with Stack Argument List. Adjust the
365 stack address for the arguments that were pushed onto the
366 stack. The return instruction will automatically pop the
367 arguments from the stack. */
368 numarg = get_frame_memory_unsigned (this_frame, addr, 1);
369 addr += 4 + numarg * 4;
372 /* Bits 1:0 of the stack pointer were saved in the control bits. */
373 trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14));
379 vax_frame_this_id (struct frame_info *this_frame, void **this_cache,
380 struct frame_id *this_id)
382 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
384 /* This marks the outermost frame. */
385 if (cache->base == 0)
388 (*this_id) = frame_id_build (cache->base, get_frame_func (this_frame));
391 static struct value *
392 vax_frame_prev_register (struct frame_info *this_frame,
393 void **this_cache, int regnum)
395 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
397 return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
400 static const struct frame_unwind vax_frame_unwind =
403 default_frame_unwind_stop_reason,
405 vax_frame_prev_register,
407 default_frame_sniffer
412 vax_frame_base_address (struct frame_info *this_frame, void **this_cache)
414 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
420 vax_frame_args_address (struct frame_info *this_frame, void **this_cache)
422 return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM);
425 static const struct frame_base vax_frame_base =
428 vax_frame_base_address,
429 vax_frame_base_address,
430 vax_frame_args_address
433 /* Return number of arguments for FRAME. */
436 vax_frame_num_args (struct frame_info *frame)
440 /* Assume that the argument pointer for the outermost frame is
441 hosed, as is the case on NetBSD/vax ELF. */
442 if (get_frame_base_address (frame) == 0)
445 args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
446 return get_frame_memory_unsigned (frame, args, 1);
450 vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
452 return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM);
456 /* Initialize the current architecture based on INFO. If possible, re-use an
457 architecture from ARCHES, which is a list of architectures already created
458 during this debugging session.
460 Called e.g. at program startup, when reading a core file, and when reading
463 static struct gdbarch *
464 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
466 struct gdbarch *gdbarch;
468 /* If there is already a candidate, use it. */
469 arches = gdbarch_list_lookup_by_info (arches, &info);
471 return arches->gdbarch;
473 gdbarch = gdbarch_alloc (&info, NULL);
475 set_gdbarch_float_format (gdbarch, floatformats_vax_f);
476 set_gdbarch_double_format (gdbarch, floatformats_vax_d);
477 set_gdbarch_long_double_format (gdbarch, floatformats_vax_d);
478 set_gdbarch_long_double_bit (gdbarch, 64);
481 set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
482 set_gdbarch_register_name (gdbarch, vax_register_name);
483 set_gdbarch_register_type (gdbarch, vax_register_type);
484 set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
485 set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
486 set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
488 set_gdbarch_regset_from_core_section
489 (gdbarch, vax_regset_from_core_section);
491 /* Frame and stack info */
492 set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
493 set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
494 set_gdbarch_frame_args_skip (gdbarch, 4);
496 /* Stack grows downward. */
497 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
499 /* Return value info */
500 set_gdbarch_return_value (gdbarch, vax_return_value);
502 /* Call dummy code. */
503 set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
504 set_gdbarch_dummy_id (gdbarch, vax_dummy_id);
506 /* Breakpoint info */
507 set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
510 set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
511 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
513 set_gdbarch_print_insn (gdbarch, print_insn_vax);
515 set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
517 frame_base_set_default (gdbarch, &vax_frame_base);
519 /* Hook in ABI-specific overrides, if they have been registered. */
520 gdbarch_init_osabi (info, gdbarch);
522 frame_unwind_append_unwinder (gdbarch, &vax_frame_unwind);
527 /* Provide a prototype to silence -Wmissing-prototypes. */
528 void _initialize_vax_tdep (void);
531 _initialize_vax_tdep (void)
533 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);