doc/ChangeLog:
[external/binutils.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 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_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   gdb_byte buf[4];
117   int count = 0;
118   int i;
119
120   /* We create an argument list on the stack, and make the argument
121      pointer to it.  */
122
123   /* Push arguments in reverse order.  */
124   for (i = nargs - 1; i >= 0; i--)
125     {
126       int len = TYPE_LENGTH (value_enclosing_type (args[i]));
127
128       sp -= (len + 3) & ~3;
129       count += (len + 3) / 4;
130       write_memory (sp, value_contents_all (args[i]), len);
131     }
132
133   /* Push argument count.  */
134   sp -= 4;
135   store_unsigned_integer (buf, 4, count);
136   write_memory (sp, buf, 4);
137
138   /* Update the argument pointer.  */
139   store_unsigned_integer (buf, 4, sp);
140   regcache_cooked_write (regcache, VAX_AP_REGNUM, buf);
141
142   return sp;
143 }
144
145 static CORE_ADDR
146 vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
147                      struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
148                      struct value **args, CORE_ADDR sp, int struct_return,
149                      CORE_ADDR struct_addr)
150 {
151   CORE_ADDR fp = sp;
152   gdb_byte buf[4];
153
154   /* Set up the function arguments.  */
155   sp = vax_store_arguments (regcache, nargs, args, sp);
156
157   /* Store return value address.  */
158   if (struct_return)
159     regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr);
160
161   /* Store return address in the PC slot.  */
162   sp -= 4;
163   store_unsigned_integer (buf, 4, bp_addr);
164   write_memory (sp, buf, 4);
165
166   /* Store the (fake) frame pointer in the FP slot.  */
167   sp -= 4;
168   store_unsigned_integer (buf, 4, fp);
169   write_memory (sp, buf, 4);
170
171   /* Skip the AP slot.  */
172   sp -= 4;
173
174   /* Store register save mask and control bits.  */
175   sp -= 4;
176   store_unsigned_integer (buf, 4, 0);
177   write_memory (sp, buf, 4);
178
179   /* Store condition handler.  */
180   sp -= 4;
181   store_unsigned_integer (buf, 4, 0);
182   write_memory (sp, buf, 4);
183
184   /* Update the stack pointer and frame pointer.  */
185   store_unsigned_integer (buf, 4, sp);
186   regcache_cooked_write (regcache, VAX_SP_REGNUM, buf);
187   regcache_cooked_write (regcache, VAX_FP_REGNUM, buf);
188
189   /* Return the saved (fake) frame pointer.  */
190   return fp;
191 }
192
193 static struct frame_id
194 vax_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
195 {
196   CORE_ADDR fp;
197
198   fp = frame_unwind_register_unsigned (next_frame, VAX_FP_REGNUM);
199   return frame_id_build (fp, frame_pc_unwind (next_frame));
200 }
201 \f
202
203 static enum return_value_convention
204 vax_return_value (struct gdbarch *gdbarch, struct type *func_type,
205                   struct type *type, struct regcache *regcache,
206                   gdb_byte *readbuf, const gdb_byte *writebuf)
207 {
208   int len = TYPE_LENGTH (type);
209   gdb_byte buf[8];
210
211   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
212       || TYPE_CODE (type) == TYPE_CODE_UNION
213       || TYPE_CODE (type) == TYPE_CODE_ARRAY)
214     {
215       /* The default on VAX is to return structures in static memory.
216          Consequently a function must return the address where we can
217          find the return value.  */
218
219       if (readbuf)
220         {
221           ULONGEST addr;
222
223           regcache_raw_read_unsigned (regcache, VAX_R0_REGNUM, &addr);
224           read_memory (addr, readbuf, len);
225         }
226
227       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
228     }
229
230   if (readbuf)
231     {
232       /* Read the contents of R0 and (if necessary) R1.  */
233       regcache_cooked_read (regcache, VAX_R0_REGNUM, buf);
234       if (len > 4)
235         regcache_cooked_read (regcache, VAX_R1_REGNUM, buf + 4);
236       memcpy (readbuf, buf, len);
237     }
238   if (writebuf)
239     {
240       /* Read the contents to R0 and (if necessary) R1.  */
241       memcpy (buf, writebuf, len);
242       regcache_cooked_write (regcache, VAX_R0_REGNUM, buf);
243       if (len > 4)
244         regcache_cooked_write (regcache, VAX_R1_REGNUM, buf + 4);
245     }
246
247   return RETURN_VALUE_REGISTER_CONVENTION;
248 }
249 \f
250
251 /* Use the program counter to determine the contents and size of a
252    breakpoint instruction.  Return a pointer to a string of bytes that
253    encode a breakpoint instruction, store the length of the string in
254    *LEN and optionally adjust *PC to point to the correct memory
255    location for inserting the breakpoint.  */
256    
257 static const gdb_byte *
258 vax_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
259 {
260   static gdb_byte break_insn[] = { 3 };
261
262   *len = sizeof (break_insn);
263   return break_insn;
264 }
265 \f
266 /* Advance PC across any function entry prologue instructions
267    to reach some "real" code.  */
268
269 static CORE_ADDR
270 vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
271 {
272   gdb_byte op = read_memory_unsigned_integer (pc, 1);
273
274   if (op == 0x11)
275     pc += 2;                    /* skip brb */
276   if (op == 0x31)
277     pc += 3;                    /* skip brw */
278   if (op == 0xC2
279       && (read_memory_unsigned_integer (pc + 2, 1)) == 0x5E)
280     pc += 3;                    /* skip subl2 */
281   if (op == 0x9E
282       && (read_memory_unsigned_integer (pc + 1, 1)) == 0xAE
283       && (read_memory_unsigned_integer (pc + 3, 1)) == 0x5E)
284     pc += 4;                    /* skip movab */
285   if (op == 0x9E
286       && (read_memory_unsigned_integer (pc + 1, 1)) == 0xCE
287       && (read_memory_unsigned_integer (pc + 4, 1)) == 0x5E)
288     pc += 5;                    /* skip movab */
289   if (op == 0x9E
290       && (read_memory_unsigned_integer (pc + 1, 1)) == 0xEE
291       && (read_memory_unsigned_integer (pc + 6, 1)) == 0x5E)
292     pc += 7;                    /* skip movab */
293
294   return pc;
295 }
296 \f
297
298 /* Unwinding the stack is relatively easy since the VAX has a
299    dedicated frame pointer, and frames are set up automatically as the
300    result of a function call.  Most of the relevant information can be
301    inferred from the documentation of the Procedure Call Instructions
302    in the VAX MACRO and Instruction Set Reference Manual.  */
303
304 struct vax_frame_cache
305 {
306   /* Base address.  */
307   CORE_ADDR base;
308
309   /* Table of saved registers.  */
310   struct trad_frame_saved_reg *saved_regs;
311 };
312
313 struct vax_frame_cache *
314 vax_frame_cache (struct frame_info *next_frame, void **this_cache)
315 {
316   struct vax_frame_cache *cache;
317   CORE_ADDR addr;
318   ULONGEST mask;
319   int regnum;
320
321   if (*this_cache)
322     return *this_cache;
323
324   /* Allocate a new cache.  */
325   cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
326   cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
327
328   /* The frame pointer is used as the base for the frame.  */
329   cache->base = frame_unwind_register_unsigned (next_frame, VAX_FP_REGNUM);
330   if (cache->base == 0)
331     return cache;
332
333   /* The register save mask and control bits determine the layout of
334      the stack frame.  */
335   mask = get_frame_memory_unsigned (next_frame, cache->base + 4, 4) >> 16;
336
337   /* These are always saved.  */
338   cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16;
339   cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12;
340   cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8;
341   cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4;
342
343   /* Scan the register save mask and record the location of the saved
344      registers.  */
345   addr = cache->base + 20;
346   for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
347     {
348       if (mask & (1 << regnum))
349         {
350           cache->saved_regs[regnum].addr = addr;
351           addr += 4;
352         }
353     }
354
355   /* The CALLS/CALLG flag determines whether this frame has a General
356      Argument List or a Stack Argument List.  */
357   if (mask & (1 << 13))
358     {
359       ULONGEST numarg;
360
361       /* This is a procedure with Stack Argument List.  Adjust the
362          stack address for the arguments that were pushed onto the
363          stack.  The return instruction will automatically pop the
364          arguments from the stack.  */
365       numarg = get_frame_memory_unsigned (next_frame, addr, 1);
366       addr += 4 + numarg * 4;
367     }
368
369   /* Bits 1:0 of the stack pointer were saved in the control bits.  */
370   trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14));
371
372   return cache;
373 }
374
375 static void
376 vax_frame_this_id (struct frame_info *next_frame, void **this_cache,
377                    struct frame_id *this_id)
378 {
379   struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache);
380
381   /* This marks the outermost frame.  */
382   if (cache->base == 0)
383     return;
384
385   (*this_id) = frame_id_build (cache->base,
386                                frame_func_unwind (next_frame, NORMAL_FRAME));
387 }
388
389 static void
390 vax_frame_prev_register (struct frame_info *next_frame, void **this_cache,
391                          int regnum, int *optimizedp,
392                          enum lval_type *lvalp, CORE_ADDR *addrp,
393                          int *realnump, gdb_byte *valuep)
394 {
395   struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache);
396
397   trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
398                                 optimizedp, lvalp, addrp, realnump, valuep);
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 };
407
408 static const struct frame_unwind *
409 vax_frame_sniffer (struct frame_info *next_frame)
410 {
411   return &vax_frame_unwind;
412 }
413 \f
414
415 static CORE_ADDR
416 vax_frame_base_address (struct frame_info *next_frame, void **this_cache)
417 {
418   struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache);
419
420   return cache->base;
421 }
422
423 static CORE_ADDR
424 vax_frame_args_address (struct frame_info *next_frame, void **this_cache)
425 {
426   return frame_unwind_register_unsigned (next_frame, VAX_AP_REGNUM);
427 }
428
429 static const struct frame_base vax_frame_base =
430 {
431   &vax_frame_unwind,
432   vax_frame_base_address,
433   vax_frame_base_address,
434   vax_frame_args_address
435 };
436
437 /* Return number of arguments for FRAME.  */
438
439 static int
440 vax_frame_num_args (struct frame_info *frame)
441 {
442   CORE_ADDR args;
443
444   /* Assume that the argument pointer for the outermost frame is
445      hosed, as is the case on NetBSD/vax ELF.  */
446   if (get_frame_base_address (frame) == 0)
447     return 0;
448
449   args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
450   return get_frame_memory_unsigned (frame, args, 1);
451 }
452
453 static CORE_ADDR
454 vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
455 {
456   return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM);
457 }
458 \f
459
460 /* Initialize the current architecture based on INFO.  If possible, re-use an
461    architecture from ARCHES, which is a list of architectures already created
462    during this debugging session.
463
464    Called e.g. at program startup, when reading a core file, and when reading
465    a binary file.  */
466
467 static struct gdbarch *
468 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
469 {
470   struct gdbarch *gdbarch;
471
472   /* If there is already a candidate, use it.  */
473   arches = gdbarch_list_lookup_by_info (arches, &info);
474   if (arches != NULL)
475     return arches->gdbarch;
476
477   gdbarch = gdbarch_alloc (&info, NULL);
478
479   set_gdbarch_float_format (gdbarch, floatformats_vax_f);
480   set_gdbarch_double_format (gdbarch, floatformats_vax_d);
481   set_gdbarch_long_double_format (gdbarch, floatformats_vax_d);
482   set_gdbarch_long_double_bit (gdbarch, 64);
483
484   /* Register info */
485   set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
486   set_gdbarch_register_name (gdbarch, vax_register_name);
487   set_gdbarch_register_type (gdbarch, vax_register_type);
488   set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
489   set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
490   set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
491
492   set_gdbarch_regset_from_core_section
493     (gdbarch, vax_regset_from_core_section);
494
495   /* Frame and stack info */
496   set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
497   set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
498   set_gdbarch_frame_args_skip (gdbarch, 4);
499
500   /* Stack grows downward.  */
501   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
502
503   /* Return value info */
504   set_gdbarch_return_value (gdbarch, vax_return_value);
505
506   /* Call dummy code.  */
507   set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
508   set_gdbarch_unwind_dummy_id (gdbarch, vax_unwind_dummy_id);
509
510   /* Breakpoint info */
511   set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
512
513   /* Misc info */
514   set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
515   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
516
517   set_gdbarch_print_insn (gdbarch, print_insn_vax);
518
519   set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
520
521   frame_base_set_default (gdbarch, &vax_frame_base);
522
523   /* Hook in ABI-specific overrides, if they have been registered.  */
524   gdbarch_init_osabi (info, gdbarch);
525
526   frame_unwind_append_sniffer (gdbarch, vax_frame_sniffer);
527
528   return (gdbarch);
529 }
530
531 /* Provide a prototype to silence -Wmissing-prototypes.  */
532 void _initialize_vax_tdep (void);
533
534 void
535 _initialize_vax_tdep (void)
536 {
537   gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
538 }