1 /* Target-dependent code for the VAX.
3 Copyright (C) 1986-2017 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"
37 /* Return the name of register REGNUM. */
40 vax_register_name (struct gdbarch *gdbarch, int regnum)
42 static const char *register_names[] =
44 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
45 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
49 if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
50 return register_names[regnum];
55 /* Return the GDB type object for the "standard" data type of data in
59 vax_register_type (struct gdbarch *gdbarch, int regnum)
61 return builtin_type (gdbarch)->builtin_int;
64 /* Core file support. */
66 /* Supply register REGNUM from the buffer specified by GREGS and LEN
67 in the general-purpose register set REGSET to register cache
68 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
71 vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
72 int regnum, const void *gregs, size_t len)
74 const gdb_byte *regs = (const gdb_byte *) gregs;
77 for (i = 0; i < VAX_NUM_REGS; i++)
79 if (regnum == i || regnum == -1)
80 regcache_raw_supply (regcache, i, regs + i * 4);
84 /* VAX register set. */
86 static const struct regset vax_gregset =
92 /* Iterate over core file register note sections. */
95 vax_iterate_over_regset_sections (struct gdbarch *gdbarch,
96 iterate_over_regset_sections_cb *cb,
98 const struct regcache *regcache)
100 cb (".reg", VAX_NUM_REGS * 4, &vax_gregset, NULL, cb_data);
103 /* The VAX UNIX calling convention uses R1 to pass a structure return
104 value address instead of passing it as a first (hidden) argument as
105 the VMS calling convention suggests. */
108 vax_store_arguments (struct regcache *regcache, int nargs,
109 struct value **args, CORE_ADDR sp)
111 struct gdbarch *gdbarch = get_regcache_arch (regcache);
112 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
117 /* We create an argument list on the stack, and make the argument
120 /* Push arguments in reverse order. */
121 for (i = nargs - 1; i >= 0; i--)
123 int len = TYPE_LENGTH (value_enclosing_type (args[i]));
125 sp -= (len + 3) & ~3;
126 count += (len + 3) / 4;
127 write_memory (sp, value_contents_all (args[i]), len);
130 /* Push argument count. */
132 store_unsigned_integer (buf, 4, byte_order, count);
133 write_memory (sp, buf, 4);
135 /* Update the argument pointer. */
136 store_unsigned_integer (buf, 4, byte_order, sp);
137 regcache_cooked_write (regcache, VAX_AP_REGNUM, buf);
143 vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
144 struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
145 struct value **args, CORE_ADDR sp, int struct_return,
146 CORE_ADDR struct_addr)
148 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
152 /* Set up the function arguments. */
153 sp = vax_store_arguments (regcache, nargs, args, sp);
155 /* Store return value address. */
157 regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr);
159 /* Store return address in the PC slot. */
161 store_unsigned_integer (buf, 4, byte_order, bp_addr);
162 write_memory (sp, buf, 4);
164 /* Store the (fake) frame pointer in the FP slot. */
166 store_unsigned_integer (buf, 4, byte_order, fp);
167 write_memory (sp, buf, 4);
169 /* Skip the AP slot. */
172 /* Store register save mask and control bits. */
174 store_unsigned_integer (buf, 4, byte_order, 0);
175 write_memory (sp, buf, 4);
177 /* Store condition handler. */
179 store_unsigned_integer (buf, 4, byte_order, 0);
180 write_memory (sp, buf, 4);
182 /* Update the stack pointer and frame pointer. */
183 store_unsigned_integer (buf, 4, byte_order, sp);
184 regcache_cooked_write (regcache, VAX_SP_REGNUM, buf);
185 regcache_cooked_write (regcache, VAX_FP_REGNUM, buf);
187 /* Return the saved (fake) frame pointer. */
191 static struct frame_id
192 vax_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
196 fp = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
197 return frame_id_build (fp, get_frame_pc (this_frame));
201 static enum return_value_convention
202 vax_return_value (struct gdbarch *gdbarch, struct value *function,
203 struct type *type, struct regcache *regcache,
204 gdb_byte *readbuf, const gdb_byte *writebuf)
206 int len = TYPE_LENGTH (type);
209 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
210 || TYPE_CODE (type) == TYPE_CODE_UNION
211 || TYPE_CODE (type) == TYPE_CODE_ARRAY)
213 /* The default on VAX is to return structures in static memory.
214 Consequently a function must return the address where we can
215 find the return value. */
221 regcache_raw_read_unsigned (regcache, VAX_R0_REGNUM, &addr);
222 read_memory (addr, readbuf, len);
225 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
230 /* Read the contents of R0 and (if necessary) R1. */
231 regcache_cooked_read (regcache, VAX_R0_REGNUM, buf);
233 regcache_cooked_read (regcache, VAX_R1_REGNUM, buf + 4);
234 memcpy (readbuf, buf, len);
238 /* Read the contents to R0 and (if necessary) R1. */
239 memcpy (buf, writebuf, len);
240 regcache_cooked_write (regcache, VAX_R0_REGNUM, buf);
242 regcache_cooked_write (regcache, VAX_R1_REGNUM, buf + 4);
245 return RETURN_VALUE_REGISTER_CONVENTION;
249 /* Use the program counter to determine the contents and size of a
250 breakpoint instruction. Return a pointer to a string of bytes that
251 encode a breakpoint instruction, store the length of the string in
252 *LEN and optionally adjust *PC to point to the correct memory
253 location for inserting the breakpoint. */
255 constexpr gdb_byte vax_break_insn[] = { 3 };
257 typedef BP_MANIPULATION (vax_break_insn) vax_breakpoint;
259 /* Advance PC across any function entry prologue instructions
260 to reach some "real" code. */
263 vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
265 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
266 gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order);
269 pc += 2; /* skip brb */
271 pc += 3; /* skip brw */
273 && read_memory_unsigned_integer (pc + 2, 1, byte_order) == 0x5E)
274 pc += 3; /* skip subl2 */
276 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xAE
277 && read_memory_unsigned_integer (pc + 3, 1, byte_order) == 0x5E)
278 pc += 4; /* skip movab */
280 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xCE
281 && read_memory_unsigned_integer (pc + 4, 1, byte_order) == 0x5E)
282 pc += 5; /* skip movab */
284 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xEE
285 && read_memory_unsigned_integer (pc + 6, 1, byte_order) == 0x5E)
286 pc += 7; /* skip movab */
292 /* Unwinding the stack is relatively easy since the VAX has a
293 dedicated frame pointer, and frames are set up automatically as the
294 result of a function call. Most of the relevant information can be
295 inferred from the documentation of the Procedure Call Instructions
296 in the VAX MACRO and Instruction Set Reference Manual. */
298 struct vax_frame_cache
303 /* Table of saved registers. */
304 struct trad_frame_saved_reg *saved_regs;
307 static struct vax_frame_cache *
308 vax_frame_cache (struct frame_info *this_frame, void **this_cache)
310 struct vax_frame_cache *cache;
316 return (struct vax_frame_cache *) *this_cache;
318 /* Allocate a new cache. */
319 cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
320 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
322 /* The frame pointer is used as the base for the frame. */
323 cache->base = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
324 if (cache->base == 0)
327 /* The register save mask and control bits determine the layout of
329 mask = get_frame_memory_unsigned (this_frame, cache->base + 4, 4) >> 16;
331 /* These are always saved. */
332 cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16;
333 cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12;
334 cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8;
335 cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4;
337 /* Scan the register save mask and record the location of the saved
339 addr = cache->base + 20;
340 for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
342 if (mask & (1 << regnum))
344 cache->saved_regs[regnum].addr = addr;
349 /* The CALLS/CALLG flag determines whether this frame has a General
350 Argument List or a Stack Argument List. */
351 if (mask & (1 << 13))
355 /* This is a procedure with Stack Argument List. Adjust the
356 stack address for the arguments that were pushed onto the
357 stack. The return instruction will automatically pop the
358 arguments from the stack. */
359 numarg = get_frame_memory_unsigned (this_frame, addr, 1);
360 addr += 4 + numarg * 4;
363 /* Bits 1:0 of the stack pointer were saved in the control bits. */
364 trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14));
370 vax_frame_this_id (struct frame_info *this_frame, void **this_cache,
371 struct frame_id *this_id)
373 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
375 /* This marks the outermost frame. */
376 if (cache->base == 0)
379 (*this_id) = frame_id_build (cache->base, get_frame_func (this_frame));
382 static struct value *
383 vax_frame_prev_register (struct frame_info *this_frame,
384 void **this_cache, int regnum)
386 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
388 return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
391 static const struct frame_unwind vax_frame_unwind =
394 default_frame_unwind_stop_reason,
396 vax_frame_prev_register,
398 default_frame_sniffer
403 vax_frame_base_address (struct frame_info *this_frame, void **this_cache)
405 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
411 vax_frame_args_address (struct frame_info *this_frame, void **this_cache)
413 return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM);
416 static const struct frame_base vax_frame_base =
419 vax_frame_base_address,
420 vax_frame_base_address,
421 vax_frame_args_address
424 /* Return number of arguments for FRAME. */
427 vax_frame_num_args (struct frame_info *frame)
431 /* Assume that the argument pointer for the outermost frame is
432 hosed, as is the case on NetBSD/vax ELF. */
433 if (get_frame_base_address (frame) == 0)
436 args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
437 return get_frame_memory_unsigned (frame, args, 1);
441 vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
443 return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM);
447 /* Initialize the current architecture based on INFO. If possible, re-use an
448 architecture from ARCHES, which is a list of architectures already created
449 during this debugging session.
451 Called e.g. at program startup, when reading a core file, and when reading
454 static struct gdbarch *
455 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
457 struct gdbarch *gdbarch;
459 /* If there is already a candidate, use it. */
460 arches = gdbarch_list_lookup_by_info (arches, &info);
462 return arches->gdbarch;
464 gdbarch = gdbarch_alloc (&info, NULL);
466 set_gdbarch_float_format (gdbarch, floatformats_vax_f);
467 set_gdbarch_double_format (gdbarch, floatformats_vax_d);
468 set_gdbarch_long_double_format (gdbarch, floatformats_vax_d);
469 set_gdbarch_long_double_bit (gdbarch, 64);
472 set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
473 set_gdbarch_register_name (gdbarch, vax_register_name);
474 set_gdbarch_register_type (gdbarch, vax_register_type);
475 set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
476 set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
477 set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
479 set_gdbarch_iterate_over_regset_sections
480 (gdbarch, vax_iterate_over_regset_sections);
482 /* Frame and stack info */
483 set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
484 set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
485 set_gdbarch_frame_args_skip (gdbarch, 4);
487 /* Stack grows downward. */
488 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
490 /* Return value info */
491 set_gdbarch_return_value (gdbarch, vax_return_value);
493 /* Call dummy code. */
494 set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
495 set_gdbarch_dummy_id (gdbarch, vax_dummy_id);
497 /* Breakpoint info */
498 set_gdbarch_breakpoint_kind_from_pc (gdbarch, vax_breakpoint::kind_from_pc);
499 set_gdbarch_sw_breakpoint_from_kind (gdbarch, vax_breakpoint::bp_from_kind);
502 set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
503 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
505 set_gdbarch_print_insn (gdbarch, print_insn_vax);
507 set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
509 frame_base_set_default (gdbarch, &vax_frame_base);
511 /* Hook in ABI-specific overrides, if they have been registered. */
512 gdbarch_init_osabi (info, gdbarch);
514 frame_unwind_append_unwinder (gdbarch, &vax_frame_unwind);
519 /* Provide a prototype to silence -Wmissing-prototypes. */
520 void _initialize_vax_tdep (void);
523 _initialize_vax_tdep (void)
525 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);