1 /* Target-dependent code for the VAX.
3 Copyright (C) 1986-2018 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"
24 #include "frame-base.h"
25 #include "frame-unwind.h"
31 #include "trad-frame.h"
36 /* Return the name of register REGNUM. */
39 vax_register_name (struct gdbarch *gdbarch, int regnum)
41 static const char *register_names[] =
43 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
44 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
48 if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
49 return register_names[regnum];
54 /* Return the GDB type object for the "standard" data type of data in
58 vax_register_type (struct gdbarch *gdbarch, int regnum)
60 return builtin_type (gdbarch)->builtin_int;
63 /* Core file support. */
65 /* Supply register REGNUM from the buffer specified by GREGS and LEN
66 in the general-purpose register set REGSET to register cache
67 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
70 vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
71 int regnum, const void *gregs, size_t len)
73 const gdb_byte *regs = (const gdb_byte *) gregs;
76 for (i = 0; i < VAX_NUM_REGS; i++)
78 if (regnum == i || regnum == -1)
79 regcache_raw_supply (regcache, i, regs + i * 4);
83 /* VAX register set. */
85 static const struct regset vax_gregset =
91 /* Iterate over core file register note sections. */
94 vax_iterate_over_regset_sections (struct gdbarch *gdbarch,
95 iterate_over_regset_sections_cb *cb,
97 const struct regcache *regcache)
99 cb (".reg", VAX_NUM_REGS * 4, &vax_gregset, NULL, cb_data);
102 /* The VAX UNIX calling convention uses R1 to pass a structure return
103 value address instead of passing it as a first (hidden) argument as
104 the VMS calling convention suggests. */
107 vax_store_arguments (struct regcache *regcache, int nargs,
108 struct value **args, CORE_ADDR sp)
110 struct gdbarch *gdbarch = regcache->arch ();
111 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
116 /* We create an argument list on the stack, and make the argument
119 /* Push arguments in reverse order. */
120 for (i = nargs - 1; i >= 0; i--)
122 int len = TYPE_LENGTH (value_enclosing_type (args[i]));
124 sp -= (len + 3) & ~3;
125 count += (len + 3) / 4;
126 write_memory (sp, value_contents_all (args[i]), len);
129 /* Push argument count. */
131 store_unsigned_integer (buf, 4, byte_order, count);
132 write_memory (sp, buf, 4);
134 /* Update the argument pointer. */
135 store_unsigned_integer (buf, 4, byte_order, sp);
136 regcache->cooked_write (VAX_AP_REGNUM, buf);
142 vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
143 struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
144 struct value **args, CORE_ADDR sp, int struct_return,
145 CORE_ADDR struct_addr)
147 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
151 /* Set up the function arguments. */
152 sp = vax_store_arguments (regcache, nargs, args, sp);
154 /* Store return value address. */
156 regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr);
158 /* Store return address in the PC slot. */
160 store_unsigned_integer (buf, 4, byte_order, bp_addr);
161 write_memory (sp, buf, 4);
163 /* Store the (fake) frame pointer in the FP slot. */
165 store_unsigned_integer (buf, 4, byte_order, fp);
166 write_memory (sp, buf, 4);
168 /* Skip the AP slot. */
171 /* Store register save mask and control bits. */
173 store_unsigned_integer (buf, 4, byte_order, 0);
174 write_memory (sp, buf, 4);
176 /* Store condition handler. */
178 store_unsigned_integer (buf, 4, byte_order, 0);
179 write_memory (sp, buf, 4);
181 /* Update the stack pointer and frame pointer. */
182 store_unsigned_integer (buf, 4, byte_order, sp);
183 regcache->cooked_write (VAX_SP_REGNUM, buf);
184 regcache->cooked_write (VAX_FP_REGNUM, buf);
186 /* Return the saved (fake) frame pointer. */
190 static struct frame_id
191 vax_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
195 fp = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
196 return frame_id_build (fp, get_frame_pc (this_frame));
200 static enum return_value_convention
201 vax_return_value (struct gdbarch *gdbarch, struct value *function,
202 struct type *type, struct regcache *regcache,
203 gdb_byte *readbuf, const gdb_byte *writebuf)
205 int len = TYPE_LENGTH (type);
208 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
209 || TYPE_CODE (type) == TYPE_CODE_UNION
210 || TYPE_CODE (type) == TYPE_CODE_ARRAY)
212 /* The default on VAX is to return structures in static memory.
213 Consequently a function must return the address where we can
214 find the return value. */
220 regcache_raw_read_unsigned (regcache, VAX_R0_REGNUM, &addr);
221 read_memory (addr, readbuf, len);
224 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
229 /* Read the contents of R0 and (if necessary) R1. */
230 regcache->cooked_read (VAX_R0_REGNUM, buf);
232 regcache->cooked_read (VAX_R1_REGNUM, buf + 4);
233 memcpy (readbuf, buf, len);
237 /* Read the contents to R0 and (if necessary) R1. */
238 memcpy (buf, writebuf, len);
239 regcache->cooked_write (VAX_R0_REGNUM, buf);
241 regcache->cooked_write (VAX_R1_REGNUM, buf + 4);
244 return RETURN_VALUE_REGISTER_CONVENTION;
248 /* Use the program counter to determine the contents and size of a
249 breakpoint instruction. Return a pointer to a string of bytes that
250 encode a breakpoint instruction, store the length of the string in
251 *LEN and optionally adjust *PC to point to the correct memory
252 location for inserting the breakpoint. */
254 constexpr gdb_byte vax_break_insn[] = { 3 };
256 typedef BP_MANIPULATION (vax_break_insn) vax_breakpoint;
258 /* Advance PC across any function entry prologue instructions
259 to reach some "real" code. */
262 vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
264 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
265 gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order);
268 pc += 2; /* skip brb */
270 pc += 3; /* skip brw */
272 && read_memory_unsigned_integer (pc + 2, 1, byte_order) == 0x5E)
273 pc += 3; /* skip subl2 */
275 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xAE
276 && read_memory_unsigned_integer (pc + 3, 1, byte_order) == 0x5E)
277 pc += 4; /* skip movab */
279 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xCE
280 && read_memory_unsigned_integer (pc + 4, 1, byte_order) == 0x5E)
281 pc += 5; /* skip movab */
283 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xEE
284 && read_memory_unsigned_integer (pc + 6, 1, byte_order) == 0x5E)
285 pc += 7; /* skip movab */
291 /* Unwinding the stack is relatively easy since the VAX has a
292 dedicated frame pointer, and frames are set up automatically as the
293 result of a function call. Most of the relevant information can be
294 inferred from the documentation of the Procedure Call Instructions
295 in the VAX MACRO and Instruction Set Reference Manual. */
297 struct vax_frame_cache
302 /* Table of saved registers. */
303 struct trad_frame_saved_reg *saved_regs;
306 static struct vax_frame_cache *
307 vax_frame_cache (struct frame_info *this_frame, void **this_cache)
309 struct vax_frame_cache *cache;
315 return (struct vax_frame_cache *) *this_cache;
317 /* Allocate a new cache. */
318 cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
319 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
321 /* The frame pointer is used as the base for the frame. */
322 cache->base = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
323 if (cache->base == 0)
326 /* The register save mask and control bits determine the layout of
328 mask = get_frame_memory_unsigned (this_frame, cache->base + 4, 4) >> 16;
330 /* These are always saved. */
331 cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16;
332 cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12;
333 cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8;
334 cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4;
336 /* Scan the register save mask and record the location of the saved
338 addr = cache->base + 20;
339 for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
341 if (mask & (1 << regnum))
343 cache->saved_regs[regnum].addr = addr;
348 /* The CALLS/CALLG flag determines whether this frame has a General
349 Argument List or a Stack Argument List. */
350 if (mask & (1 << 13))
354 /* This is a procedure with Stack Argument List. Adjust the
355 stack address for the arguments that were pushed onto the
356 stack. The return instruction will automatically pop the
357 arguments from the stack. */
358 numarg = get_frame_memory_unsigned (this_frame, addr, 1);
359 addr += 4 + numarg * 4;
362 /* Bits 1:0 of the stack pointer were saved in the control bits. */
363 trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14));
369 vax_frame_this_id (struct frame_info *this_frame, void **this_cache,
370 struct frame_id *this_id)
372 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
374 /* This marks the outermost frame. */
375 if (cache->base == 0)
378 (*this_id) = frame_id_build (cache->base, get_frame_func (this_frame));
381 static struct value *
382 vax_frame_prev_register (struct frame_info *this_frame,
383 void **this_cache, int regnum)
385 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
387 return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
390 static const struct frame_unwind vax_frame_unwind =
393 default_frame_unwind_stop_reason,
395 vax_frame_prev_register,
397 default_frame_sniffer
402 vax_frame_base_address (struct frame_info *this_frame, void **this_cache)
404 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
410 vax_frame_args_address (struct frame_info *this_frame, void **this_cache)
412 return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM);
415 static const struct frame_base vax_frame_base =
418 vax_frame_base_address,
419 vax_frame_base_address,
420 vax_frame_args_address
423 /* Return number of arguments for FRAME. */
426 vax_frame_num_args (struct frame_info *frame)
430 /* Assume that the argument pointer for the outermost frame is
431 hosed, as is the case on NetBSD/vax ELF. */
432 if (get_frame_base_address (frame) == 0)
435 args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
436 return get_frame_memory_unsigned (frame, args, 1);
440 vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
442 return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM);
446 /* Initialize the current architecture based on INFO. If possible, re-use an
447 architecture from ARCHES, which is a list of architectures already created
448 during this debugging session.
450 Called e.g. at program startup, when reading a core file, and when reading
453 static struct gdbarch *
454 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
456 struct gdbarch *gdbarch;
458 /* If there is already a candidate, use it. */
459 arches = gdbarch_list_lookup_by_info (arches, &info);
461 return arches->gdbarch;
463 gdbarch = gdbarch_alloc (&info, NULL);
465 set_gdbarch_float_format (gdbarch, floatformats_vax_f);
466 set_gdbarch_double_format (gdbarch, floatformats_vax_d);
467 set_gdbarch_long_double_format (gdbarch, floatformats_vax_d);
468 set_gdbarch_long_double_bit (gdbarch, 64);
471 set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
472 set_gdbarch_register_name (gdbarch, vax_register_name);
473 set_gdbarch_register_type (gdbarch, vax_register_type);
474 set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
475 set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
476 set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
478 set_gdbarch_iterate_over_regset_sections
479 (gdbarch, vax_iterate_over_regset_sections);
481 /* Frame and stack info */
482 set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
483 set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
484 set_gdbarch_frame_args_skip (gdbarch, 4);
486 /* Stack grows downward. */
487 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
489 /* Return value info */
490 set_gdbarch_return_value (gdbarch, vax_return_value);
492 /* Call dummy code. */
493 set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
494 set_gdbarch_dummy_id (gdbarch, vax_dummy_id);
496 /* Breakpoint info */
497 set_gdbarch_breakpoint_kind_from_pc (gdbarch, vax_breakpoint::kind_from_pc);
498 set_gdbarch_sw_breakpoint_from_kind (gdbarch, vax_breakpoint::bp_from_kind);
501 set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
502 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
504 set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
506 frame_base_set_default (gdbarch, &vax_frame_base);
508 /* Hook in ABI-specific overrides, if they have been registered. */
509 gdbarch_init_osabi (info, gdbarch);
511 frame_unwind_append_unwinder (gdbarch, &vax_frame_unwind);
517 _initialize_vax_tdep (void)
519 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);