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"
31 #include "arch-utils.h"
32 #include "gdb_string.h"
38 static gdbarch_skip_prologue_ftype vax_skip_prologue
;
39 static gdbarch_frame_num_args_ftype vax_frame_num_args
;
40 static gdbarch_deprecated_frame_chain_ftype vax_frame_chain
;
42 static gdbarch_deprecated_extract_return_value_ftype vax_extract_return_value
;
44 static gdbarch_deprecated_push_dummy_frame_ftype vax_push_dummy_frame
;
47 /* Return the name of register REGNUM. */
50 vax_register_name (int regnum
)
52 static char *register_names
[] =
54 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
55 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
59 if (regnum
>= 0 && regnum
< ARRAY_SIZE (register_names
))
60 return register_names
[regnum
];
65 /* Return the GDB type object for the "standard" data type of data in
69 vax_register_type (struct gdbarch
*gdbarch
, int regnum
)
71 return builtin_type_int
;
75 vax_frame_init_saved_regs (struct frame_info
*frame
)
80 if (deprecated_get_frame_saved_regs (frame
))
83 frame_saved_regs_zalloc (frame
);
85 regmask
= read_memory_integer (get_frame_base (frame
) + 4, 4) >> 16;
87 next_addr
= get_frame_base (frame
) + 16;
89 /* regmask's low bit is for register 0, which is the first one
90 what would be pushed. */
91 for (regnum
= 0; regnum
< VAX_AP_REGNUM
; regnum
++)
93 if (regmask
& (1 << regnum
))
94 deprecated_get_frame_saved_regs (frame
)[regnum
] = next_addr
+= 4;
97 deprecated_get_frame_saved_regs (frame
)[SP_REGNUM
] = next_addr
+ 4;
98 if (regmask
& (1 << DEPRECATED_FP_REGNUM
))
99 deprecated_get_frame_saved_regs (frame
)[SP_REGNUM
] +=
100 4 + (4 * read_memory_integer (next_addr
+ 4, 4));
102 deprecated_get_frame_saved_regs (frame
)[PC_REGNUM
] = get_frame_base (frame
) + 16;
103 deprecated_get_frame_saved_regs (frame
)[DEPRECATED_FP_REGNUM
] = get_frame_base (frame
) + 12;
104 deprecated_get_frame_saved_regs (frame
)[VAX_AP_REGNUM
] = get_frame_base (frame
) + 8;
105 deprecated_get_frame_saved_regs (frame
)[PS_REGNUM
] = get_frame_base (frame
) + 4;
108 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */
111 vax_sigtramp_saved_pc (struct frame_info
*frame
)
113 CORE_ADDR sigcontext_addr
;
115 int ptrbytes
= TYPE_LENGTH (builtin_type_void_func_ptr
);
116 int sigcontext_offs
= (2 * TARGET_INT_BIT
) / TARGET_CHAR_BIT
;
118 buf
= alloca (ptrbytes
);
119 /* Get sigcontext address, it is the third parameter on the stack. */
120 if (get_next_frame (frame
))
121 sigcontext_addr
= read_memory_typed_address
122 (DEPRECATED_FRAME_ARGS_ADDRESS (get_next_frame (frame
))
123 + FRAME_ARGS_SKIP
+ sigcontext_offs
,
124 builtin_type_void_data_ptr
);
126 sigcontext_addr
= read_memory_typed_address
127 (read_register (SP_REGNUM
) + sigcontext_offs
, builtin_type_void_data_ptr
);
129 /* Offset to saved PC in sigcontext, from <sys/signal.h>. Don't
130 cause a memory_error when accessing sigcontext in case the stack
131 layout has changed or the stack is corrupt. */
132 target_read_memory (sigcontext_addr
+ 12, buf
, ptrbytes
);
133 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
137 vax_frame_saved_pc (struct frame_info
*frame
)
139 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
140 return (vax_sigtramp_saved_pc (frame
)); /* XXXJRT */
142 return (read_memory_integer (get_frame_base (frame
) + 16, 4));
146 vax_frame_args_address (struct frame_info
*frame
)
148 /* In most of GDB, getting the args address is too important to just
149 say "I don't know". This is sometimes wrong for functions that
150 aren't on top of the stack, but c'est la vie. */
151 if (get_next_frame (frame
))
152 return (read_memory_integer (get_frame_base (get_next_frame (frame
)) + 8, 4));
153 /* Cannot find the AP register value directly from the FP value.
154 Must find it saved in the frame called by this one, or in the AP
155 register for the innermost frame. However, there is no way to
156 tell the difference between the innermost frame and a frame for
157 which we just don't know the frame that it called (e.g. "info
158 frame 0x7ffec789"). For the sake of argument, suppose that the
159 stack is somewhat trashed (which is one reason that "info frame"
160 exists). So, return 0 (indicating we don't know the address of
161 the arglist) if we don't know what frame this frame calls. */
166 vax_frame_num_args (struct frame_info
*fi
)
168 return (0xff & read_memory_integer (DEPRECATED_FRAME_ARGS_ADDRESS (fi
), 1));
172 vax_frame_chain (struct frame_info
*frame
)
174 /* In the case of the VAX, the frame's nominal address is the FP value,
175 and 12 bytes later comes the saved previous FP value as a 4-byte word. */
176 return (read_memory_integer (get_frame_base (frame
) + 12, 4));
180 vax_push_dummy_frame (void)
182 CORE_ADDR sp
= read_register (SP_REGNUM
);
185 sp
= push_word (sp
, 0); /* arglist */
186 for (regnum
= 11; regnum
>= 0; regnum
--)
187 sp
= push_word (sp
, read_register (regnum
));
188 sp
= push_word (sp
, read_register (PC_REGNUM
));
189 sp
= push_word (sp
, read_register (DEPRECATED_FP_REGNUM
));
190 sp
= push_word (sp
, read_register (VAX_AP_REGNUM
));
191 sp
= push_word (sp
, (read_register (PS_REGNUM
) & 0xffef) + 0x2fff0000);
192 sp
= push_word (sp
, 0);
193 write_register (SP_REGNUM
, sp
);
194 write_register (DEPRECATED_FP_REGNUM
, sp
);
195 write_register (VAX_AP_REGNUM
, sp
+ (17 * 4));
201 CORE_ADDR fp
= read_register (DEPRECATED_FP_REGNUM
);
203 int regmask
= read_memory_integer (fp
+ 4, 4);
205 write_register (PS_REGNUM
,
207 | (read_register (PS_REGNUM
) & 0xffff0000));
208 write_register (PC_REGNUM
, read_memory_integer (fp
+ 16, 4));
209 write_register (DEPRECATED_FP_REGNUM
, read_memory_integer (fp
+ 12, 4));
210 write_register (VAX_AP_REGNUM
, read_memory_integer (fp
+ 8, 4));
212 for (regnum
= 0; regnum
< 12; regnum
++)
213 if (regmask
& (0x10000 << regnum
))
214 write_register (regnum
, read_memory_integer (fp
+= 4, 4));
215 fp
= fp
+ 4 + ((regmask
>> 30) & 3);
216 if (regmask
& 0x20000000)
218 regnum
= read_memory_integer (fp
, 4);
219 fp
+= (regnum
+ 1) * 4;
221 write_register (SP_REGNUM
, fp
);
222 flush_cached_frames ();
225 /* The VAX call dummy sequence:
227 calls #69, @#32323232
230 It is 8 bytes long. The address and argc are patched by
231 vax_fix_call_dummy(). */
232 static LONGEST vax_call_dummy_words
[] = { 0x329f69fb, 0x03323232 };
233 static int sizeof_vax_call_dummy_words
= sizeof(vax_call_dummy_words
);
236 vax_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
237 struct value
**args
, struct type
*type
, int gcc_p
)
240 store_unsigned_integer (dummy
+ 3, 4, fun
);
244 vax_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
246 write_register (1, addr
);
250 vax_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
252 memcpy (valbuf
, regbuf
+ DEPRECATED_REGISTER_BYTE (0), TYPE_LENGTH (valtype
));
256 vax_store_return_value (struct type
*valtype
, char *valbuf
)
258 deprecated_write_register_bytes (0, valbuf
, TYPE_LENGTH (valtype
));
262 /* Use the program counter to determine the contents and size of a
263 breakpoint instruction. Return a pointer to a string of bytes that
264 encode a breakpoint instruction, store the length of the string in
265 *LEN and optionally adjust *PC to point to the correct memory
266 location for inserting the breakpoint. */
268 static const unsigned char *
269 vax_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
271 static unsigned char break_insn
[] = { 3 };
273 *len
= sizeof (break_insn
);
277 /* Advance PC across any function entry prologue instructions
278 to reach some "real" code. */
281 vax_skip_prologue (CORE_ADDR pc
)
283 int op
= (unsigned char) read_memory_integer (pc
, 1);
285 pc
+= 2; /* skip brb */
287 pc
+= 3; /* skip brw */
289 && ((unsigned char) read_memory_integer (pc
+ 2, 1)) == 0x5E)
290 pc
+= 3; /* skip subl2 */
292 && ((unsigned char) read_memory_integer (pc
+ 1, 1)) == 0xAE
293 && ((unsigned char) read_memory_integer (pc
+ 3, 1)) == 0x5E)
294 pc
+= 4; /* skip movab */
296 && ((unsigned char) read_memory_integer (pc
+ 1, 1)) == 0xCE
297 && ((unsigned char) read_memory_integer (pc
+ 4, 1)) == 0x5E)
298 pc
+= 5; /* skip movab */
300 && ((unsigned char) read_memory_integer (pc
+ 1, 1)) == 0xEE
301 && ((unsigned char) read_memory_integer (pc
+ 6, 1)) == 0x5E)
302 pc
+= 7; /* skip movab */
307 vax_saved_pc_after_call (struct frame_info
*frame
)
309 return (DEPRECATED_FRAME_SAVED_PC(frame
));
312 /* Initialize the current architecture based on INFO. If possible, re-use an
313 architecture from ARCHES, which is a list of architectures already created
314 during this debugging session.
316 Called e.g. at program startup, when reading a core file, and when reading
319 static struct gdbarch
*
320 vax_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
322 struct gdbarch
*gdbarch
;
324 /* If there is already a candidate, use it. */
325 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
327 return arches
->gdbarch
;
329 gdbarch
= gdbarch_alloc (&info
, NULL
);
331 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
332 ready to unwind the PC first (see frame.c:get_prev_frame()). */
333 set_gdbarch_deprecated_init_frame_pc (gdbarch
, deprecated_init_frame_pc_default
);
336 set_gdbarch_num_regs (gdbarch
, VAX_NUM_REGS
);
337 set_gdbarch_register_name (gdbarch
, vax_register_name
);
338 set_gdbarch_register_type (gdbarch
, vax_register_type
);
339 set_gdbarch_sp_regnum (gdbarch
, VAX_SP_REGNUM
);
340 set_gdbarch_deprecated_fp_regnum (gdbarch
, VAX_FP_REGNUM
);
341 set_gdbarch_pc_regnum (gdbarch
, VAX_PC_REGNUM
);
342 set_gdbarch_ps_regnum (gdbarch
, VAX_PS_REGNUM
);
344 /* Frame and stack info */
345 set_gdbarch_skip_prologue (gdbarch
, vax_skip_prologue
);
346 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, vax_saved_pc_after_call
);
348 set_gdbarch_frame_num_args (gdbarch
, vax_frame_num_args
);
350 set_gdbarch_deprecated_frame_chain (gdbarch
, vax_frame_chain
);
351 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, vax_frame_saved_pc
);
353 set_gdbarch_deprecated_frame_args_address (gdbarch
, vax_frame_args_address
);
355 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, vax_frame_init_saved_regs
);
357 set_gdbarch_frame_args_skip (gdbarch
, 4);
359 /* Stack grows downward. */
360 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
362 /* Return value info */
363 set_gdbarch_deprecated_store_struct_return (gdbarch
, vax_store_struct_return
);
364 set_gdbarch_deprecated_extract_return_value (gdbarch
, vax_extract_return_value
);
365 set_gdbarch_deprecated_store_return_value (gdbarch
, vax_store_return_value
);
367 /* Call dummy info */
368 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, vax_push_dummy_frame
);
369 set_gdbarch_deprecated_pop_frame (gdbarch
, vax_pop_frame
);
370 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
371 set_gdbarch_deprecated_call_dummy_words (gdbarch
, vax_call_dummy_words
);
372 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof_vax_call_dummy_words
);
373 set_gdbarch_deprecated_fix_call_dummy (gdbarch
, vax_fix_call_dummy
);
374 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch
, 7);
375 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
376 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_on_stack
);
378 /* Breakpoint info */
379 set_gdbarch_breakpoint_from_pc (gdbarch
, vax_breakpoint_from_pc
);
382 set_gdbarch_function_start_offset (gdbarch
, 2);
383 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
385 /* Should be using push_dummy_call. */
386 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, deprecated_write_sp
);
388 /* Hook in ABI-specific overrides, if they have been registered. */
389 gdbarch_init_osabi (info
, gdbarch
);
391 set_gdbarch_print_insn (gdbarch
, print_insn_vax
);
396 extern initialize_file_ftype _initialize_vax_tdep
; /* -Wmissing-prototypes */
399 _initialize_vax_tdep (void)
401 gdbarch_register (bfd_arch_vax
, vax_gdbarch_init
, NULL
);