GDB (xrefs)
Loading...
Searching...
No Matches
vax-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for the VAX.
2
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "arch-utils.h"
22#include "dis-asm.h"
23#include "frame.h"
24#include "frame-base.h"
25#include "frame-unwind.h"
26#include "gdbcore.h"
27#include "gdbtypes.h"
28#include "osabi.h"
29#include "regcache.h"
30#include "regset.h"
31#include "trad-frame.h"
32#include "value.h"
33
34#include "vax-tdep.h"
35
36/* Return the name of register REGNUM. */
37
38static const char *
40{
41 static const char *register_names[] =
42 {
43 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
44 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
45 "ps",
46 };
47
48 gdb_static_assert (VAX_NUM_REGS == ARRAY_SIZE (register_names));
49 return register_names[regnum];
50}
51
52/* Return the GDB type object for the "standard" data type of data in
53 register REGNUM. */
54
55static struct type *
60
61/* Core file support. */
62
63/* Supply register REGNUM from the buffer specified by GREGS and LEN
64 in the general-purpose register set REGSET to register cache
65 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
66
67static void
69 int regnum, const void *gregs, size_t len)
70{
71 const gdb_byte *regs = (const gdb_byte *) gregs;
72 int i;
73
74 for (i = 0; i < VAX_NUM_REGS; i++)
75 {
76 if (regnum == i || regnum == -1)
77 regcache->raw_supply (i, regs + i * 4);
78 }
79}
80
81/* VAX register set. */
82
83static const struct regset vax_gregset =
84{
85 NULL,
87};
88
89/* Iterate over core file register note sections. */
90
91static void
94 void *cb_data,
95 const struct regcache *regcache)
96{
97 cb (".reg", VAX_NUM_REGS * 4, VAX_NUM_REGS * 4, &vax_gregset, NULL, cb_data);
98}
99
100/* The VAX UNIX calling convention uses R1 to pass a structure return
101 value address instead of passing it as a first (hidden) argument as
102 the VMS calling convention suggests. */
103
104static CORE_ADDR
106 struct value **args, CORE_ADDR sp)
107{
108 struct gdbarch *gdbarch = regcache->arch ();
109 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
110 gdb_byte buf[4];
111 int count = 0;
112 int i;
113
114 /* We create an argument list on the stack, and make the argument
115 pointer to it. */
116
117 /* Push arguments in reverse order. */
118 for (i = nargs - 1; i >= 0; i--)
119 {
120 int len = args[i]->enclosing_type ()->length ();
121
122 sp -= (len + 3) & ~3;
123 count += (len + 3) / 4;
124 write_memory (sp, args[i]->contents_all ().data (), len);
125 }
126
127 /* Push argument count. */
128 sp -= 4;
129 store_unsigned_integer (buf, 4, byte_order, count);
130 write_memory (sp, buf, 4);
131
132 /* Update the argument pointer. */
133 store_unsigned_integer (buf, 4, byte_order, sp);
135
136 return sp;
137}
138
139static CORE_ADDR
140vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
141 struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
142 struct value **args, CORE_ADDR sp,
143 function_call_return_method return_method,
144 CORE_ADDR struct_addr)
145{
146 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
147 CORE_ADDR fp = sp;
148 gdb_byte buf[4];
149
150 /* Set up the function arguments. */
151 sp = vax_store_arguments (regcache, nargs, args, sp);
152
153 /* Store return value address. */
154 if (return_method == return_method_struct)
156
157 /* Store return address in the PC slot. */
158 sp -= 4;
159 store_unsigned_integer (buf, 4, byte_order, bp_addr);
160 write_memory (sp, buf, 4);
161
162 /* Store the (fake) frame pointer in the FP slot. */
163 sp -= 4;
164 store_unsigned_integer (buf, 4, byte_order, fp);
165 write_memory (sp, buf, 4);
166
167 /* Skip the AP slot. */
168 sp -= 4;
169
170 /* Store register save mask and control bits. */
171 sp -= 4;
172 store_unsigned_integer (buf, 4, byte_order, 0);
173 write_memory (sp, buf, 4);
174
175 /* Store condition handler. */
176 sp -= 4;
177 store_unsigned_integer (buf, 4, byte_order, 0);
178 write_memory (sp, buf, 4);
179
180 /* Update the stack pointer and frame pointer. */
181 store_unsigned_integer (buf, 4, byte_order, sp);
184
185 /* Return the saved (fake) frame pointer. */
186 return fp;
187}
188
189static struct frame_id
191{
192 CORE_ADDR fp;
193
195 return frame_id_build (fp, get_frame_pc (this_frame));
196}
197
198
199static enum return_value_convention
200vax_return_value (struct gdbarch *gdbarch, struct value *function,
201 struct type *type, struct regcache *regcache,
202 gdb_byte *readbuf, const gdb_byte *writebuf)
203{
204 int len = type->length ();
205 gdb_byte buf[8];
206
207 if (type->code () == TYPE_CODE_STRUCT
208 || type->code () == TYPE_CODE_UNION
209 || type->code () == TYPE_CODE_ARRAY)
210 {
211 /* The default on VAX is to return structures in static memory.
212 Consequently a function must return the address where we can
213 find the return value. */
214
215 if (readbuf)
216 {
217 ULONGEST addr;
218
220 read_memory (addr, readbuf, len);
221 }
222
224 }
225
226 if (readbuf)
227 {
228 /* Read the contents of R0 and (if necessary) R1. */
230 if (len > 4)
232 memcpy (readbuf, buf, len);
233 }
234 if (writebuf)
235 {
236 /* Read the contents to R0 and (if necessary) R1. */
237 memcpy (buf, writebuf, len);
239 if (len > 4)
241 }
242
244}
245
246
247/* Use the program counter to determine the contents and size of a
248 breakpoint instruction. Return a pointer to a string of bytes that
249 encode a breakpoint instruction, store the length of the string in
250 *LEN and optionally adjust *PC to point to the correct memory
251 location for inserting the breakpoint. */
252
253constexpr gdb_byte vax_break_insn[] = { 3 };
254
255typedef BP_MANIPULATION (vax_break_insn) vax_breakpoint;
256
257/* Advance PC across any function entry prologue instructions
258 to reach some "real" code. */
259
260static CORE_ADDR
261vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
262{
263 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
264 gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order);
265
266 if (op == 0x11)
267 pc += 2; /* skip brb */
268 if (op == 0x31)
269 pc += 3; /* skip brw */
270 if (op == 0xC2
271 && read_memory_unsigned_integer (pc + 2, 1, byte_order) == 0x5E)
272 pc += 3; /* skip subl2 */
273 if (op == 0x9E
274 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xAE
275 && read_memory_unsigned_integer (pc + 3, 1, byte_order) == 0x5E)
276 pc += 4; /* skip movab */
277 if (op == 0x9E
278 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xCE
279 && read_memory_unsigned_integer (pc + 4, 1, byte_order) == 0x5E)
280 pc += 5; /* skip movab */
281 if (op == 0x9E
282 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xEE
283 && read_memory_unsigned_integer (pc + 6, 1, byte_order) == 0x5E)
284 pc += 7; /* skip movab */
285
286 return pc;
287}
288
289
290/* Unwinding the stack is relatively easy since the VAX has a
291 dedicated frame pointer, and frames are set up automatically as the
292 result of a function call. Most of the relevant information can be
293 inferred from the documentation of the Procedure Call Instructions
294 in the VAX MACRO and Instruction Set Reference Manual. */
295
297{
298 /* Base address. */
299 CORE_ADDR base;
300
301 /* Table of saved registers. */
303};
304
305static struct vax_frame_cache *
306vax_frame_cache (frame_info_ptr this_frame, void **this_cache)
307{
308 struct vax_frame_cache *cache;
309 CORE_ADDR addr;
310 ULONGEST mask;
311 int regnum;
312
313 if (*this_cache)
314 return (struct vax_frame_cache *) *this_cache;
315
316 /* Allocate a new cache. */
317 cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
318 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
319
320 /* The frame pointer is used as the base for the frame. */
321 cache->base = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
322 if (cache->base == 0)
323 return cache;
324
325 /* The register save mask and control bits determine the layout of
326 the stack frame. */
327 mask = get_frame_memory_unsigned (this_frame, cache->base + 4, 4) >> 16;
328
329 /* These are always saved. */
330 cache->saved_regs[VAX_PC_REGNUM].set_addr (cache->base + 16);
331 cache->saved_regs[VAX_FP_REGNUM].set_addr (cache->base + 12);
332 cache->saved_regs[VAX_AP_REGNUM].set_addr (cache->base + 8);
333 cache->saved_regs[VAX_PS_REGNUM].set_addr (cache->base + 4);
334
335 /* Scan the register save mask and record the location of the saved
336 registers. */
337 addr = cache->base + 20;
338 for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
339 {
340 if (mask & (1 << regnum))
341 {
342 cache->saved_regs[regnum].set_addr (addr);
343 addr += 4;
344 }
345 }
346
347 /* The CALLS/CALLG flag determines whether this frame has a General
348 Argument List or a Stack Argument List. */
349 if (mask & (1 << 13))
350 {
351 ULONGEST numarg;
352
353 /* This is a procedure with Stack Argument List. Adjust the
354 stack address for the arguments that were pushed onto the
355 stack. The return instruction will automatically pop the
356 arguments from the stack. */
357 numarg = get_frame_memory_unsigned (this_frame, addr, 1);
358 addr += 4 + numarg * 4;
359 }
360
361 /* Bits 1:0 of the stack pointer were saved in the control bits. */
362 cache->saved_regs[VAX_SP_REGNUM].set_value (addr + (mask >> 14));
363
364 return cache;
365}
366
367static void
368vax_frame_this_id (frame_info_ptr this_frame, void **this_cache,
369 struct frame_id *this_id)
370{
371 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
372
373 /* This marks the outermost frame. */
374 if (cache->base == 0)
375 return;
376
377 (*this_id) = frame_id_build (cache->base, get_frame_func (this_frame));
378}
379
380static struct value *
382 void **this_cache, int regnum)
383{
384 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
385
386 return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
387}
388
389static const struct frame_unwind vax_frame_unwind =
390{
391 "vax prologue",
396 NULL,
398};
399
400
401static CORE_ADDR
402vax_frame_base_address (frame_info_ptr this_frame, void **this_cache)
403{
404 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
405
406 return cache->base;
407}
408
409static CORE_ADDR
410vax_frame_args_address (frame_info_ptr this_frame, void **this_cache)
411{
412 return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM);
413}
414
422
423/* Return number of arguments for FRAME. */
424
425static int
427{
428 CORE_ADDR args;
429
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)
433 return 0;
434
436 return get_frame_memory_unsigned (frame, args, 1);
437}
438
439
440
441/* Initialize the current architecture based on INFO. If possible, re-use an
442 architecture from ARCHES, which is a list of architectures already created
443 during this debugging session.
444
445 Called e.g. at program startup, when reading a core file, and when reading
446 a binary file. */
447
448static struct gdbarch *
450{
451 struct gdbarch *gdbarch;
452
453 /* If there is already a candidate, use it. */
455 if (arches != NULL)
456 return arches->gdbarch;
457
458 gdbarch = gdbarch_alloc (&info, NULL);
459
464
465 /* Register info */
472
475
476 /* Frame and stack info */
477 set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
480
481 /* Stack grows downward. */
483
484 /* Return value info */
486
487 /* Call dummy code. */
490
491 /* Breakpoint info */
492 set_gdbarch_breakpoint_kind_from_pc (gdbarch, vax_breakpoint::kind_from_pc);
493 set_gdbarch_sw_breakpoint_from_kind (gdbarch, vax_breakpoint::bp_from_kind);
494
495 /* Misc info */
498
500
501 /* Hook in ABI-specific overrides, if they have been registered. */
503
505
506 return (gdbarch);
507}
508
510void
512{
513 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
514}
int regnum
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep, gdbarch_supports_arch_info_ftype *supports_arch_info)
static std::vector< const char * > arches
Definition arch-utils.c:685
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition arch-utils.c:177
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
#define BP_MANIPULATION(BREAK_INSN)
Definition arch-utils.h:70
enum register_status cooked_read(int regnum, gdb_byte *buf)
Definition regcache.c:698
gdbarch * arch() const
Definition regcache.c:231
void raw_supply(int regnum, const void *buf) override
Definition regcache.c:1062
void cooked_write(int regnum, const gdb_byte *buf)
Definition regcache.c:870
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition corefile.c:347
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:306
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition corefile.c:238
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:515
return_value_convention
Definition defs.h:257
@ RETURN_VALUE_ABI_RETURNS_ADDRESS
Definition defs.h:273
@ RETURN_VALUE_REGISTER_CONVENTION
Definition defs.h:260
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition frame-base.c:93
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1399
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2712
CORE_ADDR get_frame_base_address(frame_info_ptr fi)
Definition frame.c:2887
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
ULONGEST get_frame_memory_unsigned(frame_info_ptr this_frame, CORE_ADDR addr, int len)
Definition frame.c:3007
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
Definition frame.c:1098
@ NORMAL_FRAME
Definition frame.h:187
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition frame.h:825
void set_gdbarch_ps_regnum(struct gdbarch *gdbarch, int ps_regnum)
Definition gdbarch.c:2081
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch, int believe_pcc_promotion)
Definition gdbarch.c:2470
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition gdbarch.c:2047
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
Definition gdbarch.c:1663
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition gdbarch.c:2064
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
void set_gdbarch_frame_num_args(struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args)
void set_gdbarch_deprecated_function_start_offset(struct gdbarch *gdbarch, CORE_ADDR deprecated_function_start_offset)
Definition gdbarch.c:2930
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition gdbarch.c:1941
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition gdbarch.c:1646
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id)
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
Definition gdbarch.c:1629
void set_gdbarch_float_format(struct gdbarch *gdbarch, const struct floatformat **float_format)
Definition gdbarch.c:1595
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections)
void set_gdbarch_frame_args_skip(struct gdbarch *gdbarch, CORE_ADDR frame_args_skip)
Definition gdbarch.c:3012
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, gdbarch_tdep_up tdep)
Definition gdbarch.c:266
void iterate_over_regset_sections_cb(const char *sect_name, int supply_size, int collect_size, const struct regset *regset, const char *human_name, void *cb_data)
Definition gdbarch.h:104
function_call_return_method
Definition gdbarch.h:114
@ return_method_struct
Definition gdbarch.h:126
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
const struct floatformat * floatformats_vax_d[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:121
const struct floatformat * floatformats_vax_f[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:117
info(Component c)
Definition gdbarch.py:41
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition osabi.c:382
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition regcache.c:649
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:825
struct type * builtin_int
Definition gdbtypes.h:2080
void set_addr(LONGEST addr)
Definition trad-frame.h:102
void set_value(LONGEST val)
Definition trad-frame.h:88
type_code code() const
Definition gdbtypes.h:956
ULONGEST length() const
Definition gdbtypes.h:983
Definition value.h:130
trad_frame_saved_reg * saved_regs
Definition vax-tdep.c:302
CORE_ADDR base
Definition vax-tdep.c:299
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
Definition trad-frame.c:62
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
Definition trad-frame.c:187
static CORE_ADDR vax_frame_args_address(frame_info_ptr this_frame, void **this_cache)
Definition vax-tdep.c:410
static const struct frame_unwind vax_frame_unwind
Definition vax-tdep.c:389
static CORE_ADDR vax_store_arguments(struct regcache *regcache, int nargs, struct value **args, CORE_ADDR sp)
Definition vax-tdep.c:105
static struct vax_frame_cache * vax_frame_cache(frame_info_ptr this_frame, void **this_cache)
Definition vax-tdep.c:306
static void vax_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
Definition vax-tdep.c:68
static int vax_frame_num_args(frame_info_ptr frame)
Definition vax-tdep.c:426
static enum return_value_convention vax_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition vax-tdep.c:200
static struct gdbarch * vax_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition vax-tdep.c:449
static struct type * vax_register_type(struct gdbarch *gdbarch, int regnum)
Definition vax-tdep.c:56
constexpr gdb_byte vax_break_insn[]
Definition vax-tdep.c:253
static CORE_ADDR vax_frame_base_address(frame_info_ptr this_frame, void **this_cache)
Definition vax-tdep.c:402
static struct frame_id vax_dummy_id(struct gdbarch *gdbarch, frame_info_ptr this_frame)
Definition vax-tdep.c:190
static CORE_ADDR vax_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr)
Definition vax-tdep.c:140
static struct value * vax_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
Definition vax-tdep.c:381
static const struct regset vax_gregset
Definition vax-tdep.c:83
static void vax_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
Definition vax-tdep.c:368
static void vax_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
Definition vax-tdep.c:92
static const struct frame_base vax_frame_base
Definition vax-tdep.c:415
static const char * vax_register_name(struct gdbarch *gdbarch, int regnum)
Definition vax-tdep.c:39
void _initialize_vax_tdep()
Definition vax-tdep.c:511
@ VAX_SP_REGNUM
Definition vax-tdep.h:31
@ VAX_PS_REGNUM
Definition vax-tdep.h:33
@ VAX_FP_REGNUM
Definition vax-tdep.h:30
@ VAX_PC_REGNUM
Definition vax-tdep.h:32
@ VAX_R1_REGNUM
Definition vax-tdep.h:28
@ VAX_R0_REGNUM
Definition vax-tdep.h:27
@ VAX_AP_REGNUM
Definition vax-tdep.h:29
#define VAX_NUM_REGS
Definition vax-tdep.h:37