gdb/
[deliverable/binutils-gdb.git] / gdb / vax-tdep.c
1 /* Target-dependent code for the VAX.
2
3 Copyright (C) 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000, 2002,
4 2003, 2004, 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
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 3 of the License, or
11 (at your option) any later version.
12
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.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 #include "defs.h"
22 #include "arch-utils.h"
23 #include "dis-asm.h"
24 #include "floatformat.h"
25 #include "frame.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
28 #include "gdbcore.h"
29 #include "gdbtypes.h"
30 #include "osabi.h"
31 #include "regcache.h"
32 #include "regset.h"
33 #include "trad-frame.h"
34 #include "value.h"
35
36 #include "gdb_string.h"
37
38 #include "vax-tdep.h"
39
40 /* Return the name of register REGNUM. */
41
42 static const char *
43 vax_register_name (struct gdbarch *gdbarch, int regnum)
44 {
45 static char *register_names[] =
46 {
47 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
48 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
49 "ps",
50 };
51
52 if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
53 return register_names[regnum];
54
55 return NULL;
56 }
57
58 /* Return the GDB type object for the "standard" data type of data in
59 register REGNUM. */
60
61 static struct type *
62 vax_register_type (struct gdbarch *gdbarch, int regnum)
63 {
64 return builtin_type (gdbarch)->builtin_int;
65 }
66 \f
67 /* Core file support. */
68
69 /* Supply register REGNUM from the buffer specified by GREGS and LEN
70 in the general-purpose register set REGSET to register cache
71 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
72
73 static void
74 vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
75 int regnum, const void *gregs, size_t len)
76 {
77 const gdb_byte *regs = gregs;
78 int i;
79
80 for (i = 0; i < VAX_NUM_REGS; i++)
81 {
82 if (regnum == i || regnum == -1)
83 regcache_raw_supply (regcache, i, regs + i * 4);
84 }
85 }
86
87 /* VAX register set. */
88
89 static struct regset vax_gregset =
90 {
91 NULL,
92 vax_supply_gregset
93 };
94
95 /* Return the appropriate register set for the core section identified
96 by SECT_NAME and SECT_SIZE. */
97
98 static const struct regset *
99 vax_regset_from_core_section (struct gdbarch *gdbarch,
100 const char *sect_name, size_t sect_size)
101 {
102 if (strcmp (sect_name, ".reg") == 0 && sect_size >= VAX_NUM_REGS * 4)
103 return &vax_gregset;
104
105 return NULL;
106 }
107 \f
108 /* The VAX UNIX calling convention uses R1 to pass a structure return
109 value address instead of passing it as a first (hidden) argument as
110 the VMS calling convention suggests. */
111
112 static CORE_ADDR
113 vax_store_arguments (struct regcache *regcache, int nargs,
114 struct value **args, CORE_ADDR sp)
115 {
116 struct gdbarch *gdbarch = get_regcache_arch (regcache);
117 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
118 gdb_byte buf[4];
119 int count = 0;
120 int i;
121
122 /* We create an argument list on the stack, and make the argument
123 pointer to it. */
124
125 /* Push arguments in reverse order. */
126 for (i = nargs - 1; i >= 0; i--)
127 {
128 int len = TYPE_LENGTH (value_enclosing_type (args[i]));
129
130 sp -= (len + 3) & ~3;
131 count += (len + 3) / 4;
132 write_memory (sp, value_contents_all (args[i]), len);
133 }
134
135 /* Push argument count. */
136 sp -= 4;
137 store_unsigned_integer (buf, 4, byte_order, count);
138 write_memory (sp, buf, 4);
139
140 /* Update the argument pointer. */
141 store_unsigned_integer (buf, 4, byte_order, sp);
142 regcache_cooked_write (regcache, VAX_AP_REGNUM, buf);
143
144 return sp;
145 }
146
147 static CORE_ADDR
148 vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
149 struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
150 struct value **args, CORE_ADDR sp, int struct_return,
151 CORE_ADDR struct_addr)
152 {
153 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
154 CORE_ADDR fp = sp;
155 gdb_byte buf[4];
156
157 /* Set up the function arguments. */
158 sp = vax_store_arguments (regcache, nargs, args, sp);
159
160 /* Store return value address. */
161 if (struct_return)
162 regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr);
163
164 /* Store return address in the PC slot. */
165 sp -= 4;
166 store_unsigned_integer (buf, 4, byte_order, bp_addr);
167 write_memory (sp, buf, 4);
168
169 /* Store the (fake) frame pointer in the FP slot. */
170 sp -= 4;
171 store_unsigned_integer (buf, 4, byte_order, fp);
172 write_memory (sp, buf, 4);
173
174 /* Skip the AP slot. */
175 sp -= 4;
176
177 /* Store register save mask and control bits. */
178 sp -= 4;
179 store_unsigned_integer (buf, 4, byte_order, 0);
180 write_memory (sp, buf, 4);
181
182 /* Store condition handler. */
183 sp -= 4;
184 store_unsigned_integer (buf, 4, byte_order, 0);
185 write_memory (sp, buf, 4);
186
187 /* Update the stack pointer and frame pointer. */
188 store_unsigned_integer (buf, 4, byte_order, sp);
189 regcache_cooked_write (regcache, VAX_SP_REGNUM, buf);
190 regcache_cooked_write (regcache, VAX_FP_REGNUM, buf);
191
192 /* Return the saved (fake) frame pointer. */
193 return fp;
194 }
195
196 static struct frame_id
197 vax_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
198 {
199 CORE_ADDR fp;
200
201 fp = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
202 return frame_id_build (fp, get_frame_pc (this_frame));
203 }
204 \f
205
206 static enum return_value_convention
207 vax_return_value (struct gdbarch *gdbarch, struct type *func_type,
208 struct type *type, struct regcache *regcache,
209 gdb_byte *readbuf, const gdb_byte *writebuf)
210 {
211 int len = TYPE_LENGTH (type);
212 gdb_byte buf[8];
213
214 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
215 || TYPE_CODE (type) == TYPE_CODE_UNION
216 || TYPE_CODE (type) == TYPE_CODE_ARRAY)
217 {
218 /* The default on VAX is to return structures in static memory.
219 Consequently a function must return the address where we can
220 find the return value. */
221
222 if (readbuf)
223 {
224 ULONGEST addr;
225
226 regcache_raw_read_unsigned (regcache, VAX_R0_REGNUM, &addr);
227 read_memory (addr, readbuf, len);
228 }
229
230 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
231 }
232
233 if (readbuf)
234 {
235 /* Read the contents of R0 and (if necessary) R1. */
236 regcache_cooked_read (regcache, VAX_R0_REGNUM, buf);
237 if (len > 4)
238 regcache_cooked_read (regcache, VAX_R1_REGNUM, buf + 4);
239 memcpy (readbuf, buf, len);
240 }
241 if (writebuf)
242 {
243 /* Read the contents to R0 and (if necessary) R1. */
244 memcpy (buf, writebuf, len);
245 regcache_cooked_write (regcache, VAX_R0_REGNUM, buf);
246 if (len > 4)
247 regcache_cooked_write (regcache, VAX_R1_REGNUM, buf + 4);
248 }
249
250 return RETURN_VALUE_REGISTER_CONVENTION;
251 }
252 \f
253
254 /* Use the program counter to determine the contents and size of a
255 breakpoint instruction. Return a pointer to a string of bytes that
256 encode a breakpoint instruction, store the length of the string in
257 *LEN and optionally adjust *PC to point to the correct memory
258 location for inserting the breakpoint. */
259
260 static const gdb_byte *
261 vax_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
262 {
263 static gdb_byte break_insn[] = { 3 };
264
265 *len = sizeof (break_insn);
266 return break_insn;
267 }
268 \f
269 /* Advance PC across any function entry prologue instructions
270 to reach some "real" code. */
271
272 static CORE_ADDR
273 vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
274 {
275 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
276 gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order);
277
278 if (op == 0x11)
279 pc += 2; /* skip brb */
280 if (op == 0x31)
281 pc += 3; /* skip brw */
282 if (op == 0xC2
283 && read_memory_unsigned_integer (pc + 2, 1, byte_order) == 0x5E)
284 pc += 3; /* skip subl2 */
285 if (op == 0x9E
286 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xAE
287 && read_memory_unsigned_integer (pc + 3, 1, byte_order) == 0x5E)
288 pc += 4; /* skip movab */
289 if (op == 0x9E
290 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xCE
291 && read_memory_unsigned_integer (pc + 4, 1, byte_order) == 0x5E)
292 pc += 5; /* skip movab */
293 if (op == 0x9E
294 && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xEE
295 && read_memory_unsigned_integer (pc + 6, 1, byte_order) == 0x5E)
296 pc += 7; /* skip movab */
297
298 return pc;
299 }
300 \f
301
302 /* Unwinding the stack is relatively easy since the VAX has a
303 dedicated frame pointer, and frames are set up automatically as the
304 result of a function call. Most of the relevant information can be
305 inferred from the documentation of the Procedure Call Instructions
306 in the VAX MACRO and Instruction Set Reference Manual. */
307
308 struct vax_frame_cache
309 {
310 /* Base address. */
311 CORE_ADDR base;
312
313 /* Table of saved registers. */
314 struct trad_frame_saved_reg *saved_regs;
315 };
316
317 static struct vax_frame_cache *
318 vax_frame_cache (struct frame_info *this_frame, void **this_cache)
319 {
320 struct vax_frame_cache *cache;
321 CORE_ADDR addr;
322 ULONGEST mask;
323 int regnum;
324
325 if (*this_cache)
326 return *this_cache;
327
328 /* Allocate a new cache. */
329 cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
330 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
331
332 /* The frame pointer is used as the base for the frame. */
333 cache->base = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
334 if (cache->base == 0)
335 return cache;
336
337 /* The register save mask and control bits determine the layout of
338 the stack frame. */
339 mask = get_frame_memory_unsigned (this_frame, cache->base + 4, 4) >> 16;
340
341 /* These are always saved. */
342 cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16;
343 cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12;
344 cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8;
345 cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4;
346
347 /* Scan the register save mask and record the location of the saved
348 registers. */
349 addr = cache->base + 20;
350 for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
351 {
352 if (mask & (1 << regnum))
353 {
354 cache->saved_regs[regnum].addr = addr;
355 addr += 4;
356 }
357 }
358
359 /* The CALLS/CALLG flag determines whether this frame has a General
360 Argument List or a Stack Argument List. */
361 if (mask & (1 << 13))
362 {
363 ULONGEST numarg;
364
365 /* This is a procedure with Stack Argument List. Adjust the
366 stack address for the arguments that were pushed onto the
367 stack. The return instruction will automatically pop the
368 arguments from the stack. */
369 numarg = get_frame_memory_unsigned (this_frame, addr, 1);
370 addr += 4 + numarg * 4;
371 }
372
373 /* Bits 1:0 of the stack pointer were saved in the control bits. */
374 trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14));
375
376 return cache;
377 }
378
379 static void
380 vax_frame_this_id (struct frame_info *this_frame, void **this_cache,
381 struct frame_id *this_id)
382 {
383 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
384
385 /* This marks the outermost frame. */
386 if (cache->base == 0)
387 return;
388
389 (*this_id) = frame_id_build (cache->base, get_frame_func (this_frame));
390 }
391
392 static struct value *
393 vax_frame_prev_register (struct frame_info *this_frame,
394 void **this_cache, int regnum)
395 {
396 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
397
398 return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
399 }
400
401 static const struct frame_unwind vax_frame_unwind =
402 {
403 NORMAL_FRAME,
404 vax_frame_this_id,
405 vax_frame_prev_register,
406 NULL,
407 default_frame_sniffer
408 };
409 \f
410
411 static CORE_ADDR
412 vax_frame_base_address (struct frame_info *this_frame, void **this_cache)
413 {
414 struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
415
416 return cache->base;
417 }
418
419 static CORE_ADDR
420 vax_frame_args_address (struct frame_info *this_frame, void **this_cache)
421 {
422 return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM);
423 }
424
425 static const struct frame_base vax_frame_base =
426 {
427 &vax_frame_unwind,
428 vax_frame_base_address,
429 vax_frame_base_address,
430 vax_frame_args_address
431 };
432
433 /* Return number of arguments for FRAME. */
434
435 static int
436 vax_frame_num_args (struct frame_info *frame)
437 {
438 CORE_ADDR args;
439
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)
443 return 0;
444
445 args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
446 return get_frame_memory_unsigned (frame, args, 1);
447 }
448
449 static CORE_ADDR
450 vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
451 {
452 return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM);
453 }
454 \f
455
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.
459
460 Called e.g. at program startup, when reading a core file, and when reading
461 a binary file. */
462
463 static struct gdbarch *
464 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
465 {
466 struct gdbarch *gdbarch;
467
468 /* If there is already a candidate, use it. */
469 arches = gdbarch_list_lookup_by_info (arches, &info);
470 if (arches != NULL)
471 return arches->gdbarch;
472
473 gdbarch = gdbarch_alloc (&info, NULL);
474
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);
479
480 /* Register info */
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);
487
488 set_gdbarch_regset_from_core_section
489 (gdbarch, vax_regset_from_core_section);
490
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);
495
496 /* Stack grows downward. */
497 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
498
499 /* Return value info */
500 set_gdbarch_return_value (gdbarch, vax_return_value);
501
502 /* Call dummy code. */
503 set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
504 set_gdbarch_dummy_id (gdbarch, vax_dummy_id);
505
506 /* Breakpoint info */
507 set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
508
509 /* Misc info */
510 set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
511 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
512
513 set_gdbarch_print_insn (gdbarch, print_insn_vax);
514
515 set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
516
517 frame_base_set_default (gdbarch, &vax_frame_base);
518
519 /* Hook in ABI-specific overrides, if they have been registered. */
520 gdbarch_init_osabi (info, gdbarch);
521
522 frame_unwind_append_unwinder (gdbarch, &vax_frame_unwind);
523
524 return (gdbarch);
525 }
526
527 /* Provide a prototype to silence -Wmissing-prototypes. */
528 void _initialize_vax_tdep (void);
529
530 void
531 _initialize_vax_tdep (void)
532 {
533 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
534 }
This page took 0.051026 seconds and 4 git commands to generate.