1 /* Print VAX instructions for GDB, the GNU debugger.
2 Copyright 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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. */
24 #include "opcode/vax.h"
30 #include "arch-utils.h"
31 #include "gdb_string.h"
36 static gdbarch_register_name_ftype vax_register_name
;
37 static gdbarch_register_byte_ftype vax_register_byte
;
38 static gdbarch_register_raw_size_ftype vax_register_raw_size
;
39 static gdbarch_register_virtual_size_ftype vax_register_virtual_size
;
40 static gdbarch_register_virtual_type_ftype vax_register_virtual_type
;
42 static gdbarch_skip_prologue_ftype vax_skip_prologue
;
43 static gdbarch_saved_pc_after_call_ftype vax_saved_pc_after_call
;
44 static gdbarch_frame_num_args_ftype vax_frame_num_args
;
45 static gdbarch_frame_chain_ftype vax_frame_chain
;
46 static gdbarch_frame_saved_pc_ftype vax_frame_saved_pc
;
47 static gdbarch_frame_args_address_ftype vax_frame_args_address
;
48 static gdbarch_frame_locals_address_ftype vax_frame_locals_address
;
49 static gdbarch_frame_init_saved_regs_ftype vax_frame_init_saved_regs
;
51 static gdbarch_store_struct_return_ftype vax_store_struct_return
;
52 static gdbarch_deprecated_extract_return_value_ftype vax_extract_return_value
;
53 static gdbarch_deprecated_extract_struct_value_address_ftype
54 vax_extract_struct_value_address
;
56 static gdbarch_push_dummy_frame_ftype vax_push_dummy_frame
;
57 static gdbarch_pop_frame_ftype vax_pop_frame
;
58 static gdbarch_fix_call_dummy_ftype vax_fix_call_dummy
;
60 /* Return 1 if P points to an invalid floating point value.
61 LEN is the length in bytes -- not relevant on the Vax. */
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
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. */
76 #define INVALID_FLOAT(p, len) ((*(short *) p & 0xff80) == 0x8000)
78 /* Vax instructions are never longer than this. */
81 /* Number of elements in the opcode table. */
82 #define NOPCODES (sizeof votstrs / sizeof votstrs[0])
84 static unsigned char *print_insn_arg ();
87 vax_register_name (int regno
)
89 static char *register_names
[] =
91 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
92 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
98 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
100 return (register_names
[regno
]);
104 vax_register_byte (int regno
)
110 vax_register_raw_size (int regno
)
116 vax_register_virtual_size (int regno
)
122 vax_register_virtual_type (int regno
)
124 return (builtin_type_int
);
128 vax_frame_init_saved_regs (struct frame_info
*frame
)
133 if (get_frame_saved_regs (frame
))
136 frame_saved_regs_zalloc (frame
);
138 regmask
= read_memory_integer (get_frame_base (frame
) + 4, 4) >> 16;
140 next_addr
= get_frame_base (frame
) + 16;
142 /* regmask's low bit is for register 0, which is the first one
143 what would be pushed. */
144 for (regnum
= 0; regnum
< VAX_AP_REGNUM
; regnum
++)
146 if (regmask
& (1 << regnum
))
147 get_frame_saved_regs (frame
)[regnum
] = next_addr
+= 4;
150 get_frame_saved_regs (frame
)[SP_REGNUM
] = next_addr
+ 4;
151 if (regmask
& (1 << FP_REGNUM
))
152 get_frame_saved_regs (frame
)[SP_REGNUM
] +=
153 4 + (4 * read_memory_integer (next_addr
+ 4, 4));
155 get_frame_saved_regs (frame
)[PC_REGNUM
] = get_frame_base (frame
) + 16;
156 get_frame_saved_regs (frame
)[FP_REGNUM
] = get_frame_base (frame
) + 12;
157 get_frame_saved_regs (frame
)[VAX_AP_REGNUM
] = get_frame_base (frame
) + 8;
158 get_frame_saved_regs (frame
)[PS_REGNUM
] = get_frame_base (frame
) + 4;
161 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */
164 vax_sigtramp_saved_pc (struct frame_info
*frame
)
166 CORE_ADDR sigcontext_addr
;
168 int ptrbytes
= TYPE_LENGTH (builtin_type_void_func_ptr
);
169 int sigcontext_offs
= (2 * TARGET_INT_BIT
) / TARGET_CHAR_BIT
;
171 buf
= alloca (ptrbytes
);
172 /* Get sigcontext address, it is the third parameter on the stack. */
173 if (get_next_frame (frame
))
174 sigcontext_addr
= read_memory_typed_address
175 (FRAME_ARGS_ADDRESS (get_next_frame (frame
))
176 + FRAME_ARGS_SKIP
+ sigcontext_offs
,
177 builtin_type_void_data_ptr
);
179 sigcontext_addr
= read_memory_typed_address
180 (read_register (SP_REGNUM
) + sigcontext_offs
, builtin_type_void_data_ptr
);
182 /* Don't cause a memory_error when accessing sigcontext in case the stack
183 layout has changed or the stack is corrupt. */
184 target_read_memory (sigcontext_addr
+ SIGCONTEXT_PC_OFFSET
, buf
, ptrbytes
);
185 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
189 vax_frame_saved_pc (struct frame_info
*frame
)
191 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
192 return (vax_sigtramp_saved_pc (frame
)); /* XXXJRT */
194 return (read_memory_integer (get_frame_base (frame
) + 16, 4));
198 vax_frame_args_address_correct (struct frame_info
*frame
)
200 /* Cannot find the AP register value directly from the FP value. Must
201 find it saved in the frame called by this one, or in the AP register
202 for the innermost frame. However, there is no way to tell the
203 difference between the innermost frame and a frame for which we
204 just don't know the frame that it called (e.g. "info frame 0x7ffec789").
205 For the sake of argument, suppose that the stack is somewhat trashed
206 (which is one reason that "info frame" exists). So, return 0 (indicating
207 we don't know the address of the arglist) if we don't know what frame
209 if (get_next_frame (frame
))
210 return (read_memory_integer (get_frame_base (get_next_frame (frame
)) + 8, 4));
216 vax_frame_args_address (struct frame_info
*frame
)
218 /* In most of GDB, getting the args address is too important to
219 just say "I don't know". This is sometimes wrong for functions
220 that aren't on top of the stack, but c'est la vie. */
221 if (get_next_frame (frame
))
222 return (read_memory_integer (get_frame_base (get_next_frame (frame
)) + 8, 4));
224 return (read_register (VAX_AP_REGNUM
));
228 vax_frame_locals_address (struct frame_info
*frame
)
230 return (get_frame_base (frame
));
234 vax_frame_num_args (struct frame_info
*fi
)
236 return (0xff & read_memory_integer (FRAME_ARGS_ADDRESS (fi
), 1));
240 vax_frame_chain (struct frame_info
*frame
)
242 /* In the case of the VAX, the frame's nominal address is the FP value,
243 and 12 bytes later comes the saved previous FP value as a 4-byte word. */
244 if (inside_entry_file (get_frame_pc (frame
)))
247 return (read_memory_integer (get_frame_base (frame
) + 12, 4));
251 vax_push_dummy_frame (void)
253 CORE_ADDR sp
= read_register (SP_REGNUM
);
256 sp
= push_word (sp
, 0); /* arglist */
257 for (regnum
= 11; regnum
>= 0; regnum
--)
258 sp
= push_word (sp
, read_register (regnum
));
259 sp
= push_word (sp
, read_register (PC_REGNUM
));
260 sp
= push_word (sp
, read_register (FP_REGNUM
));
261 sp
= push_word (sp
, read_register (VAX_AP_REGNUM
));
262 sp
= push_word (sp
, (read_register (PS_REGNUM
) & 0xffef) + 0x2fff0000);
263 sp
= push_word (sp
, 0);
264 write_register (SP_REGNUM
, sp
);
265 write_register (FP_REGNUM
, sp
);
266 write_register (VAX_AP_REGNUM
, sp
+ (17 * 4));
272 CORE_ADDR fp
= read_register (FP_REGNUM
);
274 int regmask
= read_memory_integer (fp
+ 4, 4);
276 write_register (PS_REGNUM
,
278 | (read_register (PS_REGNUM
) & 0xffff0000));
279 write_register (PC_REGNUM
, read_memory_integer (fp
+ 16, 4));
280 write_register (FP_REGNUM
, read_memory_integer (fp
+ 12, 4));
281 write_register (VAX_AP_REGNUM
, read_memory_integer (fp
+ 8, 4));
283 for (regnum
= 0; regnum
< 12; regnum
++)
284 if (regmask
& (0x10000 << regnum
))
285 write_register (regnum
, read_memory_integer (fp
+= 4, 4));
286 fp
= fp
+ 4 + ((regmask
>> 30) & 3);
287 if (regmask
& 0x20000000)
289 regnum
= read_memory_integer (fp
, 4);
290 fp
+= (regnum
+ 1) * 4;
292 write_register (SP_REGNUM
, fp
);
293 flush_cached_frames ();
296 /* The VAX call dummy sequence:
298 calls #69, @#32323232
301 It is 8 bytes long. The address and argc are patched by
302 vax_fix_call_dummy(). */
303 static LONGEST vax_call_dummy_words
[] = { 0x329f69fb, 0x03323232 };
304 static int sizeof_vax_call_dummy_words
= sizeof(vax_call_dummy_words
);
307 vax_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
308 struct value
**args
, struct type
*type
, int gcc_p
)
311 store_unsigned_integer (dummy
+ 3, 4, fun
);
315 vax_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
317 write_register (1, addr
);
321 vax_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
323 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), TYPE_LENGTH (valtype
));
327 vax_store_return_value (struct type
*valtype
, char *valbuf
)
329 deprecated_write_register_bytes (0, valbuf
, TYPE_LENGTH (valtype
));
333 vax_extract_struct_value_address (char *regbuf
)
335 return (extract_address (regbuf
+ REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
338 static const unsigned char *
339 vax_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
341 static const unsigned char vax_breakpoint
[] = { 3 };
343 *lenptr
= sizeof(vax_breakpoint
);
344 return (vax_breakpoint
);
347 /* Advance PC across any function entry prologue instructions
348 to reach some "real" code. */
351 vax_skip_prologue (CORE_ADDR pc
)
353 register int op
= (unsigned char) read_memory_integer (pc
, 1);
355 pc
+= 2; /* skip brb */
357 pc
+= 3; /* skip brw */
359 && ((unsigned char) read_memory_integer (pc
+ 2, 1)) == 0x5E)
360 pc
+= 3; /* skip subl2 */
362 && ((unsigned char) read_memory_integer (pc
+ 1, 1)) == 0xAE
363 && ((unsigned char) read_memory_integer (pc
+ 3, 1)) == 0x5E)
364 pc
+= 4; /* skip movab */
366 && ((unsigned char) read_memory_integer (pc
+ 1, 1)) == 0xCE
367 && ((unsigned char) read_memory_integer (pc
+ 4, 1)) == 0x5E)
368 pc
+= 5; /* skip movab */
370 && ((unsigned char) read_memory_integer (pc
+ 1, 1)) == 0xEE
371 && ((unsigned char) read_memory_integer (pc
+ 6, 1)) == 0x5E)
372 pc
+= 7; /* skip movab */
377 vax_saved_pc_after_call (struct frame_info
*frame
)
379 return (FRAME_SAVED_PC(frame
));
382 /* Print the vax instruction at address MEMADDR in debugged memory,
383 from disassembler info INFO.
384 Returns length of the instruction, in bytes. */
387 vax_print_insn (CORE_ADDR memaddr
, disassemble_info
*info
)
389 unsigned char buffer
[MAXLEN
];
391 register unsigned char *p
;
394 int status
= (*info
->read_memory_func
) (memaddr
, buffer
, MAXLEN
, info
);
397 (*info
->memory_error_func
) (status
, memaddr
, info
);
401 for (i
= 0; i
< NOPCODES
; i
++)
402 if (votstrs
[i
].detail
.code
== buffer
[0]
403 || votstrs
[i
].detail
.code
== *(unsigned short *) buffer
)
406 /* Handle undefined instructions. */
409 (*info
->fprintf_func
) (info
->stream
, "0%o", buffer
[0]);
413 (*info
->fprintf_func
) (info
->stream
, "%s", votstrs
[i
].name
);
415 /* Point at first byte of argument data,
416 and at descriptor for first argument. */
417 p
= buffer
+ 1 + (votstrs
[i
].detail
.code
>= 0x100);
418 d
= votstrs
[i
].detail
.args
;
421 (*info
->fprintf_func
) (info
->stream
, " ");
425 p
= print_insn_arg (d
, p
, memaddr
+ (p
- buffer
), info
);
428 (*info
->fprintf_func
) (info
->stream
, ",");
433 static unsigned char *
434 print_insn_arg (char *d
, register char *p
, CORE_ADDR addr
,
435 disassemble_info
*info
)
437 register int regnum
= *p
& 0xf;
443 (*info
->fprintf_func
) (info
->stream
, "0x%x", addr
+ *p
++ + 1);
446 (*info
->fprintf_func
) (info
->stream
, "0x%x", addr
+ *(short *) p
+ 2);
451 switch ((*p
++ >> 4) & 0xf)
456 case 3: /* Literal mode */
457 if (d
[1] == 'd' || d
[1] == 'f' || d
[1] == 'g' || d
[1] == 'h')
459 *(int *) &floatlitbuf
= 0x4000 + ((p
[-1] & 0x3f) << 4);
460 (*info
->fprintf_func
) (info
->stream
, "$%f", floatlitbuf
);
463 (*info
->fprintf_func
) (info
->stream
, "$%d", p
[-1] & 0x3f);
466 case 4: /* Indexed */
467 p
= (char *) print_insn_arg (d
, p
, addr
+ 1, info
);
468 (*info
->fprintf_func
) (info
->stream
, "[%s]", REGISTER_NAME (regnum
));
471 case 5: /* Register */
472 (*info
->fprintf_func
) (info
->stream
, REGISTER_NAME (regnum
));
475 case 7: /* Autodecrement */
476 (*info
->fprintf_func
) (info
->stream
, "-");
477 case 6: /* Register deferred */
478 (*info
->fprintf_func
) (info
->stream
, "(%s)", REGISTER_NAME (regnum
));
481 case 9: /* Autoincrement deferred */
482 (*info
->fprintf_func
) (info
->stream
, "@");
483 if (regnum
== PC_REGNUM
)
485 (*info
->fprintf_func
) (info
->stream
, "#");
486 info
->target
= *(long *) p
;
487 (*info
->print_address_func
) (info
->target
, info
);
491 case 8: /* Autoincrement */
492 if (regnum
== PC_REGNUM
)
494 (*info
->fprintf_func
) (info
->stream
, "#");
498 (*info
->fprintf_func
) (info
->stream
, "%d", *p
++);
502 (*info
->fprintf_func
) (info
->stream
, "%d", *(short *) p
);
507 (*info
->fprintf_func
) (info
->stream
, "%d", *(long *) p
);
512 (*info
->fprintf_func
) (info
->stream
, "0x%x%08x",
513 ((long *) p
)[1], ((long *) p
)[0]);
518 (*info
->fprintf_func
) (info
->stream
, "0x%x%08x%08x%08x",
519 ((long *) p
)[3], ((long *) p
)[2],
520 ((long *) p
)[1], ((long *) p
)[0]);
525 if (INVALID_FLOAT (p
, 4))
526 (*info
->fprintf_func
) (info
->stream
,
527 "<<invalid float 0x%x>>",
530 (*info
->fprintf_func
) (info
->stream
, "%f", *(float *) p
);
535 if (INVALID_FLOAT (p
, 8))
536 (*info
->fprintf_func
) (info
->stream
,
537 "<<invalid float 0x%x%08x>>",
538 ((long *) p
)[1], ((long *) p
)[0]);
540 (*info
->fprintf_func
) (info
->stream
, "%f", *(double *) p
);
545 (*info
->fprintf_func
) (info
->stream
, "g-float");
550 (*info
->fprintf_func
) (info
->stream
, "h-float");
557 (*info
->fprintf_func
) (info
->stream
, "(%s)+", REGISTER_NAME (regnum
));
560 case 11: /* Byte displacement deferred */
561 (*info
->fprintf_func
) (info
->stream
, "@");
562 case 10: /* Byte displacement */
563 if (regnum
== PC_REGNUM
)
565 info
->target
= addr
+ *p
+ 2;
566 (*info
->print_address_func
) (info
->target
, info
);
569 (*info
->fprintf_func
) (info
->stream
, "%d(%s)", *p
, REGISTER_NAME (regnum
));
573 case 13: /* Word displacement deferred */
574 (*info
->fprintf_func
) (info
->stream
, "@");
575 case 12: /* Word displacement */
576 if (regnum
== PC_REGNUM
)
578 info
->target
= addr
+ *(short *) p
+ 3;
579 (*info
->print_address_func
) (info
->target
, info
);
582 (*info
->fprintf_func
) (info
->stream
, "%d(%s)",
583 *(short *) p
, REGISTER_NAME (regnum
));
587 case 15: /* Long displacement deferred */
588 (*info
->fprintf_func
) (info
->stream
, "@");
589 case 14: /* Long displacement */
590 if (regnum
== PC_REGNUM
)
592 info
->target
= addr
+ *(short *) p
+ 5;
593 (*info
->print_address_func
) (info
->target
, info
);
596 (*info
->fprintf_func
) (info
->stream
, "%d(%s)",
597 *(long *) p
, REGISTER_NAME (regnum
));
601 return (unsigned char *) p
;
604 /* Initialize the current architecture based on INFO. If possible, re-use an
605 architecture from ARCHES, which is a list of architectures already created
606 during this debugging session.
608 Called e.g. at program startup, when reading a core file, and when reading
611 static struct gdbarch
*
612 vax_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
614 struct gdbarch
*gdbarch
;
616 /* If there is already a candidate, use it. */
617 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
619 return arches
->gdbarch
;
621 gdbarch
= gdbarch_alloc (&info
, NULL
);
623 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
624 ready to unwind the PC first (see frame.c:get_prev_frame()). */
625 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
628 set_gdbarch_num_regs (gdbarch
, VAX_NUM_REGS
);
629 set_gdbarch_sp_regnum (gdbarch
, VAX_SP_REGNUM
);
630 set_gdbarch_fp_regnum (gdbarch
, VAX_FP_REGNUM
);
631 set_gdbarch_pc_regnum (gdbarch
, VAX_PC_REGNUM
);
632 set_gdbarch_ps_regnum (gdbarch
, VAX_PS_REGNUM
);
634 set_gdbarch_register_name (gdbarch
, vax_register_name
);
635 set_gdbarch_register_size (gdbarch
, VAX_REGISTER_SIZE
);
636 set_gdbarch_register_bytes (gdbarch
, VAX_REGISTER_BYTES
);
637 set_gdbarch_register_byte (gdbarch
, vax_register_byte
);
638 set_gdbarch_register_raw_size (gdbarch
, vax_register_raw_size
);
639 set_gdbarch_max_register_raw_size (gdbarch
, VAX_MAX_REGISTER_RAW_SIZE
);
640 set_gdbarch_register_virtual_size (gdbarch
, vax_register_virtual_size
);
641 set_gdbarch_max_register_virtual_size (gdbarch
,
642 VAX_MAX_REGISTER_VIRTUAL_SIZE
);
643 set_gdbarch_register_virtual_type (gdbarch
, vax_register_virtual_type
);
645 /* Frame and stack info */
646 set_gdbarch_skip_prologue (gdbarch
, vax_skip_prologue
);
647 set_gdbarch_saved_pc_after_call (gdbarch
, vax_saved_pc_after_call
);
649 set_gdbarch_frame_num_args (gdbarch
, vax_frame_num_args
);
650 set_gdbarch_frameless_function_invocation (gdbarch
,
651 generic_frameless_function_invocation_not
);
653 set_gdbarch_frame_chain (gdbarch
, vax_frame_chain
);
654 set_gdbarch_frame_saved_pc (gdbarch
, vax_frame_saved_pc
);
656 set_gdbarch_frame_args_address (gdbarch
, vax_frame_args_address
);
657 set_gdbarch_frame_locals_address (gdbarch
, vax_frame_locals_address
);
659 set_gdbarch_frame_init_saved_regs (gdbarch
, vax_frame_init_saved_regs
);
661 set_gdbarch_frame_args_skip (gdbarch
, 4);
663 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
665 /* Return value info */
666 set_gdbarch_store_struct_return (gdbarch
, vax_store_struct_return
);
667 set_gdbarch_deprecated_extract_return_value (gdbarch
, vax_extract_return_value
);
668 set_gdbarch_deprecated_store_return_value (gdbarch
, vax_store_return_value
);
669 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
, vax_extract_struct_value_address
);
671 /* Call dummy info */
672 set_gdbarch_push_dummy_frame (gdbarch
, vax_push_dummy_frame
);
673 set_gdbarch_pop_frame (gdbarch
, vax_pop_frame
);
674 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
675 set_gdbarch_call_dummy_p (gdbarch
, 1);
676 set_gdbarch_call_dummy_words (gdbarch
, vax_call_dummy_words
);
677 set_gdbarch_sizeof_call_dummy_words (gdbarch
, sizeof_vax_call_dummy_words
);
678 set_gdbarch_fix_call_dummy (gdbarch
, vax_fix_call_dummy
);
679 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
680 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
681 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 7);
682 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
683 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_on_stack
);
684 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
686 /* Breakpoint info */
687 set_gdbarch_breakpoint_from_pc (gdbarch
, vax_breakpoint_from_pc
);
688 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
691 set_gdbarch_function_start_offset (gdbarch
, 2);
692 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
694 /* Hook in ABI-specific overrides, if they have been registered. */
695 gdbarch_init_osabi (info
, gdbarch
);
701 _initialize_vax_tdep (void)
703 gdbarch_register (bfd_arch_vax
, vax_gdbarch_init
, NULL
);
705 tm_print_insn
= vax_print_insn
;