]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame_incremental - gdb/vax-tdep.c
projects / thirdparty / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
* simops.c (trace_result): Fix printf formatting.
[thirdparty/binutils-gdb.git] / gdb / vax-tdep.c
... / ...
CommitLineData
1/* Print VAX instructions for GDB, the GNU debugger.
2 Copyright 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000, 2002
3 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 2 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22#include "defs.h"
23#include "symtab.h"
24#include "opcode/vax.h"
25#include "gdbcore.h"
26#include "inferior.h"
27#include "regcache.h"
28#include "frame.h"
29#include "value.h"
30#include "arch-utils.h"
31
32#include "vax-tdep.h"
33
34static gdbarch_register_name_ftype vax_register_name;
35static gdbarch_register_byte_ftype vax_register_byte;
36static gdbarch_register_raw_size_ftype vax_register_raw_size;
37static gdbarch_register_virtual_size_ftype vax_register_virtual_size;
38static gdbarch_register_virtual_type_ftype vax_register_virtual_type;
39
40static gdbarch_skip_prologue_ftype vax_skip_prologue;
41static gdbarch_saved_pc_after_call_ftype vax_saved_pc_after_call;
42static gdbarch_frame_num_args_ftype vax_frame_num_args;
43static gdbarch_frame_chain_ftype vax_frame_chain;
44static gdbarch_frame_saved_pc_ftype vax_frame_saved_pc;
45static gdbarch_frame_args_address_ftype vax_frame_args_address;
46static gdbarch_frame_locals_address_ftype vax_frame_locals_address;
47static gdbarch_frame_init_saved_regs_ftype vax_frame_init_saved_regs;
48static gdbarch_get_saved_register_ftype vax_get_saved_register;
49
50static gdbarch_store_struct_return_ftype vax_store_struct_return;
51static gdbarch_deprecated_extract_return_value_ftype vax_extract_return_value;
52static gdbarch_store_return_value_ftype vax_store_return_value;
53static gdbarch_deprecated_extract_struct_value_address_ftype
54 vax_extract_struct_value_address;
55
56static gdbarch_push_dummy_frame_ftype vax_push_dummy_frame;
57static gdbarch_pop_frame_ftype vax_pop_frame;
58static gdbarch_fix_call_dummy_ftype vax_fix_call_dummy;
59
60/* Return 1 if P points to an invalid floating point value.
61 LEN is the length in bytes -- not relevant on the Vax. */
62
63/* FIXME: cagney/2002-01-19: The macro below was originally defined in
64 tm-vax.h and used in values.c. Two problems. Firstly this is a
65 very non-portable and secondly it is wrong. The VAX should be
66 using floatformat and associated methods to identify and handle
67 invalid floating-point values. Adding to the poor target's woes
68 there is no floatformat_vax_{f,d} and no TARGET_FLOAT_FORMAT
69 et.al.. */
70
71/* FIXME: cagney/2002-01-19: It turns out that the only thing that
72 uses this macro is the vax disassembler code (so how old is this
73 target?). This target should instead be using the opcodes
74 disassembler. That allowing the macro to be eliminated. */
75
76#define INVALID_FLOAT(p, len) ((*(short *) p & 0xff80) == 0x8000)
77
78/* Vax instructions are never longer than this. */
79#define MAXLEN 62
80
81/* Number of elements in the opcode table. */
82#define NOPCODES (sizeof votstrs / sizeof votstrs[0])
83
84static unsigned char *print_insn_arg ();
85\f
86static char *
87vax_register_name (int regno)
88{
89 static char *register_names[] =
90 {
91 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
92 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
93 "ps",
94 };
95
96 if (regno < 0)
97 return (NULL);
98 if (regno >= (sizeof(register_names) / sizeof(*register_names)))
99 return (NULL);
100 return (register_names[regno]);
101}
102
103static int
104vax_register_byte (int regno)
105{
106 return (regno * 4);
107}
108
109static int
110vax_register_raw_size (int regno)
111{
112 return (4);
113}
114
115static int
116vax_register_virtual_size (int regno)
117{
118 return (4);
119}
120
121static struct type *
122vax_register_virtual_type (int regno)
123{
124 return (builtin_type_int);
125}
126\f
127static void
128vax_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
129 struct frame_info *frame, int regnum,
130 enum lval_type *lval)
131{
132 CORE_ADDR addr;
133
134 if (!target_has_registers)
135 error ("No registers.");
136
137 /* Normal systems don't optimize out things with register numbers. */
138 if (optimized != NULL)
139 *optimized = 0;
140 addr = find_saved_register (frame, regnum);
141 if (addr != 0)
142 {
143 if (lval != NULL)
144 *lval = lval_memory;
145 if (regnum == SP_REGNUM)
146 {
147 if (raw_buffer != NULL)
148 {
149 /* Put it back in target format. */
150 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
151 (LONGEST) addr);
152 }
153 if (addrp != NULL)
154 *addrp = 0;
155 return;
156 }
157 if (raw_buffer != NULL)
158 target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
159 }
160 else
161 {
162 if (lval != NULL)
163 *lval = lval_register;
164 addr = REGISTER_BYTE (regnum);
165 if (raw_buffer != NULL)
166 read_register_gen (regnum, raw_buffer);
167 }
168 if (addrp != NULL)
169 *addrp = addr;
170}
171
172static void
173vax_frame_init_saved_regs (struct frame_info *frame)
174{
175 int regnum, regmask;
176 CORE_ADDR next_addr;
177
178 if (frame->saved_regs)
179 return;
180
181 frame_saved_regs_zalloc (frame);
182
183 regmask = read_memory_integer (frame->frame + 4, 4) >> 16;
184
185 next_addr = frame->frame + 16;
186
187 /* regmask's low bit is for register 0, which is the first one
188 what would be pushed. */
189 for (regnum = 0; regnum < AP_REGNUM; regnum++)
190 {
191 if (regmask & (1 << regnum))
192 frame->saved_regs[regnum] = next_addr += 4;
193 }
194
195 frame->saved_regs[SP_REGNUM] = next_addr + 4;
196 if (regmask & (1 << FP_REGNUM))
197 frame->saved_regs[SP_REGNUM] +=
198 4 + (4 * read_memory_integer (next_addr + 4, 4));
199
200 frame->saved_regs[PC_REGNUM] = frame->frame + 16;
201 frame->saved_regs[FP_REGNUM] = frame->frame + 12;
202 frame->saved_regs[AP_REGNUM] = frame->frame + 8;
203 frame->saved_regs[PS_REGNUM] = frame->frame + 4;
204}
205
206static CORE_ADDR
207vax_frame_saved_pc (struct frame_info *frame)
208{
209 if (frame->signal_handler_caller)
210 return (sigtramp_saved_pc (frame)); /* XXXJRT */
211
212 return (read_memory_integer (frame->frame + 16, 4));
213}
214
215CORE_ADDR
216vax_frame_args_address_correct (struct frame_info *frame)
217{
218 /* Cannot find the AP register value directly from the FP value. Must
219 find it saved in the frame called by this one, or in the AP register
220 for the innermost frame. However, there is no way to tell the
221 difference between the innermost frame and a frame for which we
222 just don't know the frame that it called (e.g. "info frame 0x7ffec789").
223 For the sake of argument, suppose that the stack is somewhat trashed
224 (which is one reason that "info frame" exists). So, return 0 (indicating
225 we don't know the address of the arglist) if we don't know what frame
226 this frame calls. */
227 if (frame->next)
228 return (read_memory_integer (frame->next->frame + 8, 4));
229
230 return (0);
231}
232
233static CORE_ADDR
234vax_frame_args_address (struct frame_info *frame)
235{
236 /* In most of GDB, getting the args address is too important to
237 just say "I don't know". This is sometimes wrong for functions
238 that aren't on top of the stack, but c'est la vie. */
239 if (frame->next)
240 return (read_memory_integer (frame->next->frame + 8, 4));
241
242 return (read_register (AP_REGNUM));
243}
244
245static CORE_ADDR
246vax_frame_locals_address (struct frame_info *frame)
247{
248 return (frame->frame);
249}
250
251static int
252vax_frame_num_args (struct frame_info *fi)
253{
254 return (0xff & read_memory_integer (FRAME_ARGS_ADDRESS (fi), 1));
255}
256
257static CORE_ADDR
258vax_frame_chain (struct frame_info *frame)
259{
260 /* In the case of the VAX, the frame's nominal address is the FP value,
261 and 12 bytes later comes the saved previous FP value as a 4-byte word. */
262 if (inside_entry_file (frame->pc))
263 return (0);
264
265 return (read_memory_integer (frame->frame + 12, 4));
266}
267\f
268static void
269vax_push_dummy_frame (void)
270{
271 CORE_ADDR sp = read_register (SP_REGNUM);
272 int regnum;
273
274 sp = push_word (sp, 0); /* arglist */
275 for (regnum = 11; regnum >= 0; regnum--)
276 sp = push_word (sp, read_register (regnum));
277 sp = push_word (sp, read_register (PC_REGNUM));
278 sp = push_word (sp, read_register (FP_REGNUM));
279 sp = push_word (sp, read_register (AP_REGNUM));
280 sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef) + 0x2fff0000);
281 sp = push_word (sp, 0);
282 write_register (SP_REGNUM, sp);
283 write_register (FP_REGNUM, sp);
284 write_register (AP_REGNUM, sp + (17 * 4));
285}
286
287static void
288vax_pop_frame (void)
289{
290 CORE_ADDR fp = read_register (FP_REGNUM);
291 int regnum;
292 int regmask = read_memory_integer (fp + 4, 4);
293
294 write_register (PS_REGNUM,
295 (regmask & 0xffff)
296 | (read_register (PS_REGNUM) & 0xffff0000));
297 write_register (PC_REGNUM, read_memory_integer (fp + 16, 4));
298 write_register (FP_REGNUM, read_memory_integer (fp + 12, 4));
299 write_register (AP_REGNUM, read_memory_integer (fp + 8, 4));
300 fp += 16;
301 for (regnum = 0; regnum < 12; regnum++)
302 if (regmask & (0x10000 << regnum))
303 write_register (regnum, read_memory_integer (fp += 4, 4));
304 fp = fp + 4 + ((regmask >> 30) & 3);
305 if (regmask & 0x20000000)
306 {
307 regnum = read_memory_integer (fp, 4);
308 fp += (regnum + 1) * 4;
309 }
310 write_register (SP_REGNUM, fp);
311 flush_cached_frames ();
312}
313
314/* The VAX call dummy sequence:
315
316 calls #69, @#32323232
317 bpt
318
319 It is 8 bytes long. The address and argc are patched by
320 vax_fix_call_dummy(). */
321static LONGEST vax_call_dummy_words[] = { 0x329f69fb, 0x03323232 };
322static int sizeof_vax_call_dummy_words = sizeof(vax_call_dummy_words);
323
324static void
325vax_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
326 struct value **args, struct type *type, int gcc_p)
327{
328 dummy[1] = nargs;
329 store_unsigned_integer (dummy + 3, 4, fun);
330}
331\f
332static void
333vax_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
334{
335 write_register (1, addr);
336}
337
338static void
339vax_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
340{
341 memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (valtype));
342}
343
344static void
345vax_store_return_value (struct type *valtype, char *valbuf)
346{
347 write_register_bytes (0, valbuf, TYPE_LENGTH (valtype));
348}
349
350static CORE_ADDR
351vax_extract_struct_value_address (char *regbuf)
352{
353 return (extract_address (regbuf + REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
354}
355\f
356/* Advance PC across any function entry prologue instructions
357 to reach some "real" code. */
358
359static CORE_ADDR
360vax_skip_prologue (CORE_ADDR pc)
361{
362 register int op = (unsigned char) read_memory_integer (pc, 1);
363 if (op == 0x11)
364 pc += 2; /* skip brb */
365 if (op == 0x31)
366 pc += 3; /* skip brw */
367 if (op == 0xC2
368 && ((unsigned char) read_memory_integer (pc + 2, 1)) == 0x5E)
369 pc += 3; /* skip subl2 */
370 if (op == 0x9E
371 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xAE
372 && ((unsigned char) read_memory_integer (pc + 3, 1)) == 0x5E)
373 pc += 4; /* skip movab */
374 if (op == 0x9E
375 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xCE
376 && ((unsigned char) read_memory_integer (pc + 4, 1)) == 0x5E)
377 pc += 5; /* skip movab */
378 if (op == 0x9E
379 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xEE
380 && ((unsigned char) read_memory_integer (pc + 6, 1)) == 0x5E)
381 pc += 7; /* skip movab */
382 return pc;
383}
384
385static CORE_ADDR
386vax_saved_pc_after_call (struct frame_info *frame)
387{
388 return (FRAME_SAVED_PC(frame));
389}
390\f
391/* Print the vax instruction at address MEMADDR in debugged memory,
392 from disassembler info INFO.
393 Returns length of the instruction, in bytes. */
394
395static int
396vax_print_insn (CORE_ADDR memaddr, disassemble_info *info)
397{
398 unsigned char buffer[MAXLEN];
399 register int i;
400 register unsigned char *p;
401 const char *d;
402
403 int status = (*info->read_memory_func) (memaddr, buffer, MAXLEN, info);
404 if (status != 0)
405 {
406 (*info->memory_error_func) (status, memaddr, info);
407 return -1;
408 }
409
410 for (i = 0; i < NOPCODES; i++)
411 if (votstrs[i].detail.code == buffer[0]
412 || votstrs[i].detail.code == *(unsigned short *) buffer)
413 break;
414
415 /* Handle undefined instructions. */
416 if (i == NOPCODES)
417 {
418 (*info->fprintf_func) (info->stream, "0%o", buffer[0]);
419 return 1;
420 }
421
422 (*info->fprintf_func) (info->stream, "%s", votstrs[i].name);
423
424 /* Point at first byte of argument data,
425 and at descriptor for first argument. */
426 p = buffer + 1 + (votstrs[i].detail.code >= 0x100);
427 d = votstrs[i].detail.args;
428
429 if (*d)
430 (*info->fprintf_func) (info->stream, " ");
431
432 while (*d)
433 {
434 p = print_insn_arg (d, p, memaddr + (p - buffer), info);
435 d += 2;
436 if (*d)
437 (*info->fprintf_func) (info->stream, ",");
438 }
439 return p - buffer;
440}
441\f
442static unsigned char *
443print_insn_arg (char *d, register char *p, CORE_ADDR addr,
444 disassemble_info *info)
445{
446 register int regnum = *p & 0xf;
447 float floatlitbuf;
448
449 if (*d == 'b')
450 {
451 if (d[1] == 'b')
452 (*info->fprintf_func) (info->stream, "0x%x", addr + *p++ + 1);
453 else
454 {
455 (*info->fprintf_func) (info->stream, "0x%x", addr + *(short *) p + 2);
456 p += 2;
457 }
458 }
459 else
460 switch ((*p++ >> 4) & 0xf)
461 {
462 case 0:
463 case 1:
464 case 2:
465 case 3: /* Literal mode */
466 if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h')
467 {
468 *(int *) &floatlitbuf = 0x4000 + ((p[-1] & 0x3f) << 4);
469 (*info->fprintf_func) (info->stream, "$%f", floatlitbuf);
470 }
471 else
472 (*info->fprintf_func) (info->stream, "$%d", p[-1] & 0x3f);
473 break;
474
475 case 4: /* Indexed */
476 p = (char *) print_insn_arg (d, p, addr + 1, info);
477 (*info->fprintf_func) (info->stream, "[%s]", REGISTER_NAME (regnum));
478 break;
479
480 case 5: /* Register */
481 (*info->fprintf_func) (info->stream, REGISTER_NAME (regnum));
482 break;
483
484 case 7: /* Autodecrement */
485 (*info->fprintf_func) (info->stream, "-");
486 case 6: /* Register deferred */
487 (*info->fprintf_func) (info->stream, "(%s)", REGISTER_NAME (regnum));
488 break;
489
490 case 9: /* Autoincrement deferred */
491 (*info->fprintf_func) (info->stream, "@");
492 if (regnum == PC_REGNUM)
493 {
494 (*info->fprintf_func) (info->stream, "#");
495 info->target = *(long *) p;
496 (*info->print_address_func) (info->target, info);
497 p += 4;
498 break;
499 }
500 case 8: /* Autoincrement */
501 if (regnum == PC_REGNUM)
502 {
503 (*info->fprintf_func) (info->stream, "#");
504 switch (d[1])
505 {
506 case 'b':
507 (*info->fprintf_func) (info->stream, "%d", *p++);
508 break;
509
510 case 'w':
511 (*info->fprintf_func) (info->stream, "%d", *(short *) p);
512 p += 2;
513 break;
514
515 case 'l':
516 (*info->fprintf_func) (info->stream, "%d", *(long *) p);
517 p += 4;
518 break;
519
520 case 'q':
521 (*info->fprintf_func) (info->stream, "0x%x%08x",
522 ((long *) p)[1], ((long *) p)[0]);
523 p += 8;
524 break;
525
526 case 'o':
527 (*info->fprintf_func) (info->stream, "0x%x%08x%08x%08x",
528 ((long *) p)[3], ((long *) p)[2],
529 ((long *) p)[1], ((long *) p)[0]);
530 p += 16;
531 break;
532
533 case 'f':
534 if (INVALID_FLOAT (p, 4))
535 (*info->fprintf_func) (info->stream,
536 "<<invalid float 0x%x>>",
537 *(int *) p);
538 else
539 (*info->fprintf_func) (info->stream, "%f", *(float *) p);
540 p += 4;
541 break;
542
543 case 'd':
544 if (INVALID_FLOAT (p, 8))
545 (*info->fprintf_func) (info->stream,
546 "<<invalid float 0x%x%08x>>",
547 ((long *) p)[1], ((long *) p)[0]);
548 else
549 (*info->fprintf_func) (info->stream, "%f", *(double *) p);
550 p += 8;
551 break;
552
553 case 'g':
554 (*info->fprintf_func) (info->stream, "g-float");
555 p += 8;
556 break;
557
558 case 'h':
559 (*info->fprintf_func) (info->stream, "h-float");
560 p += 16;
561 break;
562
563 }
564 }
565 else
566 (*info->fprintf_func) (info->stream, "(%s)+", REGISTER_NAME (regnum));
567 break;
568
569 case 11: /* Byte displacement deferred */
570 (*info->fprintf_func) (info->stream, "@");
571 case 10: /* Byte displacement */
572 if (regnum == PC_REGNUM)
573 {
574 info->target = addr + *p + 2;
575 (*info->print_address_func) (info->target, info);
576 }
577 else
578 (*info->fprintf_func) (info->stream, "%d(%s)", *p, REGISTER_NAME (regnum));
579 p += 1;
580 break;
581
582 case 13: /* Word displacement deferred */
583 (*info->fprintf_func) (info->stream, "@");
584 case 12: /* Word displacement */
585 if (regnum == PC_REGNUM)
586 {
587 info->target = addr + *(short *) p + 3;
588 (*info->print_address_func) (info->target, info);
589 }
590 else
591 (*info->fprintf_func) (info->stream, "%d(%s)",
592 *(short *) p, REGISTER_NAME (regnum));
593 p += 2;
594 break;
595
596 case 15: /* Long displacement deferred */
597 (*info->fprintf_func) (info->stream, "@");
598 case 14: /* Long displacement */
599 if (regnum == PC_REGNUM)
600 {
601 info->target = addr + *(short *) p + 5;
602 (*info->print_address_func) (info->target, info);
603 }
604 else
605 (*info->fprintf_func) (info->stream, "%d(%s)",
606 *(long *) p, REGISTER_NAME (regnum));
607 p += 4;
608 }
609
610 return (unsigned char *) p;
611}
612\f
613/* Initialize the current architecture based on INFO. If possible, re-use an
614 architecture from ARCHES, which is a list of architectures already created
615 during this debugging session.
616
617 Called e.g. at program startup, when reading a core file, and when reading
618 a binary file. */
619
620static struct gdbarch *
621vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
622{
623 struct gdbarch *gdbarch;
624
625 /* Right now there is only one VAX architecture variant. */
626 if (arches != NULL)
627 return (arches->gdbarch);
628
629 gdbarch = gdbarch_alloc (&info, NULL);
630
631 /* Register info */
632 set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
633 set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
634 set_gdbarch_fp_regnum (gdbarch, VAX_FP_REGNUM);
635 set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
636 set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
637
638 set_gdbarch_register_name (gdbarch, vax_register_name);
639 set_gdbarch_register_size (gdbarch, VAX_REGISTER_SIZE);
640 set_gdbarch_register_bytes (gdbarch, VAX_REGISTER_BYTES);
641 set_gdbarch_register_byte (gdbarch, vax_register_byte);
642 set_gdbarch_register_raw_size (gdbarch, vax_register_raw_size);
643 set_gdbarch_max_register_raw_size (gdbarch, VAX_MAX_REGISTER_RAW_SIZE);
644 set_gdbarch_register_virtual_size (gdbarch, vax_register_virtual_size);
645 set_gdbarch_max_register_virtual_size (gdbarch,
646 VAX_MAX_REGISTER_VIRTUAL_SIZE);
647 set_gdbarch_register_virtual_type (gdbarch, vax_register_virtual_type);
648
649 /* Frame and stack info */
650 set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
651 set_gdbarch_saved_pc_after_call (gdbarch, vax_saved_pc_after_call);
652
653 set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
654 set_gdbarch_frameless_function_invocation (gdbarch,
655 generic_frameless_function_invocation_not);
656
657 set_gdbarch_frame_chain (gdbarch, vax_frame_chain);
658 set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
659 set_gdbarch_frame_saved_pc (gdbarch, vax_frame_saved_pc);
660
661 set_gdbarch_frame_args_address (gdbarch, vax_frame_args_address);
662 set_gdbarch_frame_locals_address (gdbarch, vax_frame_locals_address);
663
664 set_gdbarch_frame_init_saved_regs (gdbarch, vax_frame_init_saved_regs);
665
666 set_gdbarch_frame_args_skip (gdbarch, 4);
667
668 set_gdbarch_get_saved_register (gdbarch, vax_get_saved_register);
669
670 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
671
672 /* Return value info */
673 set_gdbarch_store_struct_return (gdbarch, vax_store_struct_return);
674 set_gdbarch_deprecated_extract_return_value (gdbarch, vax_extract_return_value);
675 set_gdbarch_store_return_value (gdbarch, vax_store_return_value);
676 set_gdbarch_deprecated_extract_struct_value_address (gdbarch, vax_extract_struct_value_address);
677
678 /* Call dummy info */
679 set_gdbarch_push_dummy_frame (gdbarch, vax_push_dummy_frame);
680 set_gdbarch_pop_frame (gdbarch, vax_pop_frame);
681 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
682 set_gdbarch_call_dummy_p (gdbarch, 1);
683 set_gdbarch_call_dummy_words (gdbarch, vax_call_dummy_words);
684 set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
685 set_gdbarch_fix_call_dummy (gdbarch, vax_fix_call_dummy);
686 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
687 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
688 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 7);
689 set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
690 set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_on_stack);
691 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
692
693 /* Breakpoint info */
694 set_gdbarch_decr_pc_after_break (gdbarch, 0);
695
696 /* Misc info */
697 set_gdbarch_function_start_offset (gdbarch, 2);
698
699 return (gdbarch);
700}
701
702void
703_initialize_vax_tdep (void)
704{
705 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
706
707 tm_print_insn = vax_print_insn;
708}
A mirror of the official binutils-gdb repository