Split size in regset section iterators
[external/binutils.git] / gdb / vax-tdep.c
1 /* Target-dependent code for the VAX.
2
3    Copyright (C) 1986-2018 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
38 static const char *
39 vax_register_name (struct gdbarch *gdbarch, int regnum)
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   if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
49     return register_names[regnum];
50
51   return NULL;
52 }
53
54 /* Return the GDB type object for the "standard" data type of data in
55    register REGNUM.  */
56
57 static struct type *
58 vax_register_type (struct gdbarch *gdbarch, int regnum)
59 {
60   return builtin_type (gdbarch)->builtin_int;
61 }
62 \f
63 /* Core file support.  */
64
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.  */
68
69 static void
70 vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
71                     int regnum, const void *gregs, size_t len)
72 {
73   const gdb_byte *regs = (const gdb_byte *) gregs;
74   int i;
75
76   for (i = 0; i < VAX_NUM_REGS; i++)
77     {
78       if (regnum == i || regnum == -1)
79         regcache->raw_supply (i, regs + i * 4);
80     }
81 }
82
83 /* VAX register set.  */
84
85 static const struct regset vax_gregset =
86 {
87   NULL,
88   vax_supply_gregset
89 };
90
91 /* Iterate over core file register note sections.  */
92
93 static void
94 vax_iterate_over_regset_sections (struct gdbarch *gdbarch,
95                                   iterate_over_regset_sections_cb *cb,
96                                   void *cb_data,
97                                   const struct regcache *regcache)
98 {
99   cb (".reg", VAX_NUM_REGS * 4, VAX_NUM_REGS * 4, &vax_gregset, NULL, cb_data);
100 }
101 \f
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.  */
105
106 static CORE_ADDR
107 vax_store_arguments (struct regcache *regcache, int nargs,
108                      struct value **args, CORE_ADDR sp)
109 {
110   struct gdbarch *gdbarch = regcache->arch ();
111   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
112   gdb_byte buf[4];
113   int count = 0;
114   int i;
115
116   /* We create an argument list on the stack, and make the argument
117      pointer to it.  */
118
119   /* Push arguments in reverse order.  */
120   for (i = nargs - 1; i >= 0; i--)
121     {
122       int len = TYPE_LENGTH (value_enclosing_type (args[i]));
123
124       sp -= (len + 3) & ~3;
125       count += (len + 3) / 4;
126       write_memory (sp, value_contents_all (args[i]), len);
127     }
128
129   /* Push argument count.  */
130   sp -= 4;
131   store_unsigned_integer (buf, 4, byte_order, count);
132   write_memory (sp, buf, 4);
133
134   /* Update the argument pointer.  */
135   store_unsigned_integer (buf, 4, byte_order, sp);
136   regcache->cooked_write (VAX_AP_REGNUM, buf);
137
138   return sp;
139 }
140
141 static CORE_ADDR
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)
146 {
147   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
148   CORE_ADDR fp = sp;
149   gdb_byte buf[4];
150
151   /* Set up the function arguments.  */
152   sp = vax_store_arguments (regcache, nargs, args, sp);
153
154   /* Store return value address.  */
155   if (struct_return)
156     regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr);
157
158   /* Store return address in the PC slot.  */
159   sp -= 4;
160   store_unsigned_integer (buf, 4, byte_order, bp_addr);
161   write_memory (sp, buf, 4);
162
163   /* Store the (fake) frame pointer in the FP slot.  */
164   sp -= 4;
165   store_unsigned_integer (buf, 4, byte_order, fp);
166   write_memory (sp, buf, 4);
167
168   /* Skip the AP slot.  */
169   sp -= 4;
170
171   /* Store register save mask and control bits.  */
172   sp -= 4;
173   store_unsigned_integer (buf, 4, byte_order, 0);
174   write_memory (sp, buf, 4);
175
176   /* Store condition handler.  */
177   sp -= 4;
178   store_unsigned_integer (buf, 4, byte_order, 0);
179   write_memory (sp, buf, 4);
180
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);
185
186   /* Return the saved (fake) frame pointer.  */
187   return fp;
188 }
189
190 static struct frame_id
191 vax_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
192 {
193   CORE_ADDR fp;
194
195   fp = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
196   return frame_id_build (fp, get_frame_pc (this_frame));
197 }
198 \f
199
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)
204 {
205   int len = TYPE_LENGTH (type);
206   gdb_byte buf[8];
207
208   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
209       || TYPE_CODE (type) == TYPE_CODE_UNION
210       || TYPE_CODE (type) == TYPE_CODE_ARRAY)
211     {
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.  */
215
216       if (readbuf)
217         {
218           ULONGEST addr;
219
220           regcache_raw_read_unsigned (regcache, VAX_R0_REGNUM, &addr);
221           read_memory (addr, readbuf, len);
222         }
223
224       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
225     }
226
227   if (readbuf)
228     {
229       /* Read the contents of R0 and (if necessary) R1.  */
230       regcache->cooked_read (VAX_R0_REGNUM, buf);
231       if (len > 4)
232         regcache->cooked_read (VAX_R1_REGNUM, buf + 4);
233       memcpy (readbuf, buf, len);
234     }
235   if (writebuf)
236     {
237       /* Read the contents to R0 and (if necessary) R1.  */
238       memcpy (buf, writebuf, len);
239       regcache->cooked_write (VAX_R0_REGNUM, buf);
240       if (len > 4)
241         regcache->cooked_write (VAX_R1_REGNUM, buf + 4);
242     }
243
244   return RETURN_VALUE_REGISTER_CONVENTION;
245 }
246 \f
247
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.  */
253
254 constexpr gdb_byte vax_break_insn[] = { 3 };
255
256 typedef BP_MANIPULATION (vax_break_insn) vax_breakpoint;
257 \f
258 /* Advance PC across any function entry prologue instructions
259    to reach some "real" code.  */
260
261 static CORE_ADDR
262 vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
263 {
264   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
265   gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order);
266
267   if (op == 0x11)
268     pc += 2;                    /* skip brb */
269   if (op == 0x31)
270     pc += 3;                    /* skip brw */
271   if (op == 0xC2
272       && read_memory_unsigned_integer (pc + 2, 1, byte_order) == 0x5E)
273     pc += 3;                    /* skip subl2 */
274   if (op == 0x9E
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 */
278   if (op == 0x9E
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 */
282   if (op == 0x9E
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 */
286
287   return pc;
288 }
289 \f
290
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.  */
296
297 struct vax_frame_cache
298 {
299   /* Base address.  */
300   CORE_ADDR base;
301
302   /* Table of saved registers.  */
303   struct trad_frame_saved_reg *saved_regs;
304 };
305
306 static struct vax_frame_cache *
307 vax_frame_cache (struct frame_info *this_frame, void **this_cache)
308 {
309   struct vax_frame_cache *cache;
310   CORE_ADDR addr;
311   ULONGEST mask;
312   int regnum;
313
314   if (*this_cache)
315     return (struct vax_frame_cache *) *this_cache;
316
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);
320
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)
324     return cache;
325
326   /* The register save mask and control bits determine the layout of
327      the stack frame.  */
328   mask = get_frame_memory_unsigned (this_frame, cache->base + 4, 4) >> 16;
329
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;
335
336   /* Scan the register save mask and record the location of the saved
337      registers.  */
338   addr = cache->base + 20;
339   for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
340     {
341       if (mask & (1 << regnum))
342         {
343           cache->saved_regs[regnum].addr = addr;
344           addr += 4;
345         }
346     }
347
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))
351     {
352       ULONGEST numarg;
353
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;
360     }
361
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));
364
365   return cache;
366 }
367
368 static void
369 vax_frame_this_id (struct frame_info *this_frame, void **this_cache,
370                    struct frame_id *this_id)
371 {
372   struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
373
374   /* This marks the outermost frame.  */
375   if (cache->base == 0)
376     return;
377
378   (*this_id) = frame_id_build (cache->base, get_frame_func (this_frame));
379 }
380
381 static struct value *
382 vax_frame_prev_register (struct frame_info *this_frame,
383                          void **this_cache, int regnum)
384 {
385   struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
386
387   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
388 }
389
390 static const struct frame_unwind vax_frame_unwind =
391 {
392   NORMAL_FRAME,
393   default_frame_unwind_stop_reason,
394   vax_frame_this_id,
395   vax_frame_prev_register,
396   NULL,
397   default_frame_sniffer
398 };
399 \f
400
401 static CORE_ADDR
402 vax_frame_base_address (struct frame_info *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
409 static CORE_ADDR
410 vax_frame_args_address (struct frame_info *this_frame, void **this_cache)
411 {
412   return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM);
413 }
414
415 static const struct frame_base vax_frame_base =
416 {
417   &vax_frame_unwind,
418   vax_frame_base_address,
419   vax_frame_base_address,
420   vax_frame_args_address
421 };
422
423 /* Return number of arguments for FRAME.  */
424
425 static int
426 vax_frame_num_args (struct frame_info *frame)
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
435   args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
436   return get_frame_memory_unsigned (frame, args, 1);
437 }
438
439 static CORE_ADDR
440 vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
441 {
442   return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM);
443 }
444 \f
445
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.
449
450    Called e.g. at program startup, when reading a core file, and when reading
451    a binary file.  */
452
453 static struct gdbarch *
454 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
455 {
456   struct gdbarch *gdbarch;
457
458   /* If there is already a candidate, use it.  */
459   arches = gdbarch_list_lookup_by_info (arches, &info);
460   if (arches != NULL)
461     return arches->gdbarch;
462
463   gdbarch = gdbarch_alloc (&info, NULL);
464
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);
469
470   /* Register info */
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);
477
478   set_gdbarch_iterate_over_regset_sections
479     (gdbarch, vax_iterate_over_regset_sections);
480
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);
485
486   /* Stack grows downward.  */
487   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
488
489   /* Return value info */
490   set_gdbarch_return_value (gdbarch, vax_return_value);
491
492   /* Call dummy code.  */
493   set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
494   set_gdbarch_dummy_id (gdbarch, vax_dummy_id);
495
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);
499
500   /* Misc info */
501   set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
502   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
503
504   set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
505
506   frame_base_set_default (gdbarch, &vax_frame_base);
507
508   /* Hook in ABI-specific overrides, if they have been registered.  */
509   gdbarch_init_osabi (info, gdbarch);
510
511   frame_unwind_append_unwinder (gdbarch, &vax_frame_unwind);
512
513   return (gdbarch);
514 }
515
516 void
517 _initialize_vax_tdep (void)
518 {
519   gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
520 }