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_args_address_ftype vax_frame_args_address
;
47 static gdbarch_frame_locals_address_ftype vax_frame_locals_address
;
49 static gdbarch_store_struct_return_ftype vax_store_struct_return
;
50 static gdbarch_deprecated_extract_return_value_ftype vax_extract_return_value
;
51 static gdbarch_deprecated_extract_struct_value_address_ftype
52 vax_extract_struct_value_address
;
54 static gdbarch_deprecated_push_dummy_frame_ftype vax_push_dummy_frame
;
55 static gdbarch_fix_call_dummy_ftype vax_fix_call_dummy
;
57 /* Return 1 if P points to an invalid floating point value.
58 LEN is the length in bytes -- not relevant on the Vax. */
60 /* FIXME: cagney/2002-01-19: The macro below was originally defined in
61 tm-vax.h and used in values.c. Two problems. Firstly this is a
62 very non-portable and secondly it is wrong. The VAX should be
63 using floatformat and associated methods to identify and handle
64 invalid floating-point values. Adding to the poor target's woes
65 there is no floatformat_vax_{f,d} and no TARGET_FLOAT_FORMAT
68 /* FIXME: cagney/2002-01-19: It turns out that the only thing that
69 uses this macro is the vax disassembler code (so how old is this
70 target?). This target should instead be using the opcodes
71 disassembler. That allowing the macro to be eliminated. */
73 #define INVALID_FLOAT(p, len) ((*(short *) p & 0xff80) == 0x8000)
75 /* Vax instructions are never longer than this. */
78 /* Number of elements in the opcode table. */
79 #define NOPCODES (sizeof votstrs / sizeof votstrs[0])
81 static unsigned char *print_insn_arg ();
84 vax_register_name (int regno
)
86 static char *register_names
[] =
88 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
89 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
95 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
97 return (register_names
[regno
]);
101 vax_register_byte (int regno
)
107 vax_register_raw_size (int regno
)
113 vax_register_virtual_size (int regno
)
119 vax_register_virtual_type (int regno
)
121 return (builtin_type_int
);
125 vax_frame_init_saved_regs (struct frame_info
*frame
)
130 if (get_frame_saved_regs (frame
))
133 frame_saved_regs_zalloc (frame
);
135 regmask
= read_memory_integer (get_frame_base (frame
) + 4, 4) >> 16;
137 next_addr
= get_frame_base (frame
) + 16;
139 /* regmask's low bit is for register 0, which is the first one
140 what would be pushed. */
141 for (regnum
= 0; regnum
< VAX_AP_REGNUM
; regnum
++)
143 if (regmask
& (1 << regnum
))
144 get_frame_saved_regs (frame
)[regnum
] = next_addr
+= 4;
147 get_frame_saved_regs (frame
)[SP_REGNUM
] = next_addr
+ 4;
148 if (regmask
& (1 << FP_REGNUM
))
149 get_frame_saved_regs (frame
)[SP_REGNUM
] +=
150 4 + (4 * read_memory_integer (next_addr
+ 4, 4));
152 get_frame_saved_regs (frame
)[PC_REGNUM
] = get_frame_base (frame
) + 16;
153 get_frame_saved_regs (frame
)[FP_REGNUM
] = get_frame_base (frame
) + 12;
154 get_frame_saved_regs (frame
)[VAX_AP_REGNUM
] = get_frame_base (frame
) + 8;
155 get_frame_saved_regs (frame
)[PS_REGNUM
] = get_frame_base (frame
) + 4;
158 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */
161 vax_sigtramp_saved_pc (struct frame_info
*frame
)
163 CORE_ADDR sigcontext_addr
;
165 int ptrbytes
= TYPE_LENGTH (builtin_type_void_func_ptr
);
166 int sigcontext_offs
= (2 * TARGET_INT_BIT
) / TARGET_CHAR_BIT
;
168 buf
= alloca (ptrbytes
);
169 /* Get sigcontext address, it is the third parameter on the stack. */
170 if (get_next_frame (frame
))
171 sigcontext_addr
= read_memory_typed_address
172 (FRAME_ARGS_ADDRESS (get_next_frame (frame
))
173 + FRAME_ARGS_SKIP
+ sigcontext_offs
,
174 builtin_type_void_data_ptr
);
176 sigcontext_addr
= read_memory_typed_address
177 (read_register (SP_REGNUM
) + sigcontext_offs
, builtin_type_void_data_ptr
);
179 /* Don't cause a memory_error when accessing sigcontext in case the stack
180 layout has changed or the stack is corrupt. */
181 target_read_memory (sigcontext_addr
+ SIGCONTEXT_PC_OFFSET
, buf
, ptrbytes
);
182 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
186 vax_frame_saved_pc (struct frame_info
*frame
)
188 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
189 return (vax_sigtramp_saved_pc (frame
)); /* XXXJRT */
191 return (read_memory_integer (get_frame_base (frame
) + 16, 4));
195 vax_frame_args_address_correct (struct frame_info
*frame
)
197 /* Cannot find the AP register value directly from the FP value. Must
198 find it saved in the frame called by this one, or in the AP register
199 for the innermost frame. However, there is no way to tell the
200 difference between the innermost frame and a frame for which we
201 just don't know the frame that it called (e.g. "info frame 0x7ffec789").
202 For the sake of argument, suppose that the stack is somewhat trashed
203 (which is one reason that "info frame" exists). So, return 0 (indicating
204 we don't know the address of the arglist) if we don't know what frame
206 if (get_next_frame (frame
))
207 return (read_memory_integer (get_frame_base (get_next_frame (frame
)) + 8, 4));
213 vax_frame_args_address (struct frame_info
*frame
)
215 /* In most of GDB, getting the args address is too important to
216 just say "I don't know". This is sometimes wrong for functions
217 that aren't on top of the stack, but c'est la vie. */
218 if (get_next_frame (frame
))
219 return (read_memory_integer (get_frame_base (get_next_frame (frame
)) + 8, 4));
221 return (read_register (VAX_AP_REGNUM
));
225 vax_frame_locals_address (struct frame_info
*frame
)
227 return (get_frame_base (frame
));
231 vax_frame_num_args (struct frame_info
*fi
)
233 return (0xff & read_memory_integer (FRAME_ARGS_ADDRESS (fi
), 1));
237 vax_frame_chain (struct frame_info
*frame
)
239 /* In the case of the VAX, the frame's nominal address is the FP value,
240 and 12 bytes later comes the saved previous FP value as a 4-byte word. */
241 if (inside_entry_file (get_frame_pc (frame
)))
244 return (read_memory_integer (get_frame_base (frame
) + 12, 4));
248 vax_push_dummy_frame (void)
250 CORE_ADDR sp
= read_register (SP_REGNUM
);
253 sp
= push_word (sp
, 0); /* arglist */
254 for (regnum
= 11; regnum
>= 0; regnum
--)
255 sp
= push_word (sp
, read_register (regnum
));
256 sp
= push_word (sp
, read_register (PC_REGNUM
));
257 sp
= push_word (sp
, read_register (FP_REGNUM
));
258 sp
= push_word (sp
, read_register (VAX_AP_REGNUM
));
259 sp
= push_word (sp
, (read_register (PS_REGNUM
) & 0xffef) + 0x2fff0000);
260 sp
= push_word (sp
, 0);
261 write_register (SP_REGNUM
, sp
);
262 write_register (FP_REGNUM
, sp
);
263 write_register (VAX_AP_REGNUM
, sp
+ (17 * 4));
269 CORE_ADDR fp
= read_register (FP_REGNUM
);
271 int regmask
= read_memory_integer (fp
+ 4, 4);
273 write_register (PS_REGNUM
,
275 | (read_register (PS_REGNUM
) & 0xffff0000));
276 write_register (PC_REGNUM
, read_memory_integer (fp
+ 16, 4));
277 write_register (FP_REGNUM
, read_memory_integer (fp
+ 12, 4));
278 write_register (VAX_AP_REGNUM
, read_memory_integer (fp
+ 8, 4));
280 for (regnum
= 0; regnum
< 12; regnum
++)
281 if (regmask
& (0x10000 << regnum
))
282 write_register (regnum
, read_memory_integer (fp
+= 4, 4));
283 fp
= fp
+ 4 + ((regmask
>> 30) & 3);
284 if (regmask
& 0x20000000)
286 regnum
= read_memory_integer (fp
, 4);
287 fp
+= (regnum
+ 1) * 4;
289 write_register (SP_REGNUM
, fp
);
290 flush_cached_frames ();
293 /* The VAX call dummy sequence:
295 calls #69, @#32323232
298 It is 8 bytes long. The address and argc are patched by
299 vax_fix_call_dummy(). */
300 static LONGEST vax_call_dummy_words
[] = { 0x329f69fb, 0x03323232 };
301 static int sizeof_vax_call_dummy_words
= sizeof(vax_call_dummy_words
);
304 vax_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
305 struct value
**args
, struct type
*type
, int gcc_p
)
308 store_unsigned_integer (dummy
+ 3, 4, fun
);
312 vax_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
314 write_register (1, addr
);
318 vax_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
320 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), TYPE_LENGTH (valtype
));
324 vax_store_return_value (struct type
*valtype
, char *valbuf
)
326 deprecated_write_register_bytes (0, valbuf
, TYPE_LENGTH (valtype
));
330 vax_extract_struct_value_address (char *regbuf
)
332 return (extract_address (regbuf
+ REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
335 static const unsigned char *
336 vax_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
338 static const unsigned char vax_breakpoint
[] = { 3 };
340 *lenptr
= sizeof(vax_breakpoint
);
341 return (vax_breakpoint
);
344 /* Advance PC across any function entry prologue instructions
345 to reach some "real" code. */
348 vax_skip_prologue (CORE_ADDR pc
)
350 register int op
= (unsigned char) read_memory_integer (pc
, 1);
352 pc
+= 2; /* skip brb */
354 pc
+= 3; /* skip brw */
356 && ((unsigned char) read_memory_integer (pc
+ 2, 1)) == 0x5E)
357 pc
+= 3; /* skip subl2 */
359 && ((unsigned char) read_memory_integer (pc
+ 1, 1)) == 0xAE
360 && ((unsigned char) read_memory_integer (pc
+ 3, 1)) == 0x5E)
361 pc
+= 4; /* skip movab */
363 && ((unsigned char) read_memory_integer (pc
+ 1, 1)) == 0xCE
364 && ((unsigned char) read_memory_integer (pc
+ 4, 1)) == 0x5E)
365 pc
+= 5; /* skip movab */
367 && ((unsigned char) read_memory_integer (pc
+ 1, 1)) == 0xEE
368 && ((unsigned char) read_memory_integer (pc
+ 6, 1)) == 0x5E)
369 pc
+= 7; /* skip movab */
374 vax_saved_pc_after_call (struct frame_info
*frame
)
376 return (DEPRECATED_FRAME_SAVED_PC(frame
));
379 /* Print the vax instruction at address MEMADDR in debugged memory,
380 from disassembler info INFO.
381 Returns length of the instruction, in bytes. */
384 vax_print_insn (CORE_ADDR memaddr
, disassemble_info
*info
)
386 unsigned char buffer
[MAXLEN
];
388 register unsigned char *p
;
391 int status
= (*info
->read_memory_func
) (memaddr
, buffer
, MAXLEN
, info
);
394 (*info
->memory_error_func
) (status
, memaddr
, info
);
398 for (i
= 0; i
< NOPCODES
; i
++)
399 if (votstrs
[i
].detail
.code
== buffer
[0]
400 || votstrs
[i
].detail
.code
== *(unsigned short *) buffer
)
403 /* Handle undefined instructions. */
406 (*info
->fprintf_func
) (info
->stream
, "0%o", buffer
[0]);
410 (*info
->fprintf_func
) (info
->stream
, "%s", votstrs
[i
].name
);
412 /* Point at first byte of argument data,
413 and at descriptor for first argument. */
414 p
= buffer
+ 1 + (votstrs
[i
].detail
.code
>= 0x100);
415 d
= votstrs
[i
].detail
.args
;
418 (*info
->fprintf_func
) (info
->stream
, " ");
422 p
= print_insn_arg (d
, p
, memaddr
+ (p
- buffer
), info
);
425 (*info
->fprintf_func
) (info
->stream
, ",");
430 static unsigned char *
431 print_insn_arg (char *d
, register char *p
, CORE_ADDR addr
,
432 disassemble_info
*info
)
434 register int regnum
= *p
& 0xf;
440 (*info
->fprintf_func
) (info
->stream
, "0x%x", addr
+ *p
++ + 1);
443 (*info
->fprintf_func
) (info
->stream
, "0x%x", addr
+ *(short *) p
+ 2);
448 switch ((*p
++ >> 4) & 0xf)
453 case 3: /* Literal mode */
454 if (d
[1] == 'd' || d
[1] == 'f' || d
[1] == 'g' || d
[1] == 'h')
456 *(int *) &floatlitbuf
= 0x4000 + ((p
[-1] & 0x3f) << 4);
457 (*info
->fprintf_func
) (info
->stream
, "$%f", floatlitbuf
);
460 (*info
->fprintf_func
) (info
->stream
, "$%d", p
[-1] & 0x3f);
463 case 4: /* Indexed */
464 p
= (char *) print_insn_arg (d
, p
, addr
+ 1, info
);
465 (*info
->fprintf_func
) (info
->stream
, "[%s]", REGISTER_NAME (regnum
));
468 case 5: /* Register */
469 (*info
->fprintf_func
) (info
->stream
, REGISTER_NAME (regnum
));
472 case 7: /* Autodecrement */
473 (*info
->fprintf_func
) (info
->stream
, "-");
474 case 6: /* Register deferred */
475 (*info
->fprintf_func
) (info
->stream
, "(%s)", REGISTER_NAME (regnum
));
478 case 9: /* Autoincrement deferred */
479 (*info
->fprintf_func
) (info
->stream
, "@");
480 if (regnum
== PC_REGNUM
)
482 (*info
->fprintf_func
) (info
->stream
, "#");
483 info
->target
= *(long *) p
;
484 (*info
->print_address_func
) (info
->target
, info
);
488 case 8: /* Autoincrement */
489 if (regnum
== PC_REGNUM
)
491 (*info
->fprintf_func
) (info
->stream
, "#");
495 (*info
->fprintf_func
) (info
->stream
, "%d", *p
++);
499 (*info
->fprintf_func
) (info
->stream
, "%d", *(short *) p
);
504 (*info
->fprintf_func
) (info
->stream
, "%d", *(long *) p
);
509 (*info
->fprintf_func
) (info
->stream
, "0x%x%08x",
510 ((long *) p
)[1], ((long *) p
)[0]);
515 (*info
->fprintf_func
) (info
->stream
, "0x%x%08x%08x%08x",
516 ((long *) p
)[3], ((long *) p
)[2],
517 ((long *) p
)[1], ((long *) p
)[0]);
522 if (INVALID_FLOAT (p
, 4))
523 (*info
->fprintf_func
) (info
->stream
,
524 "<<invalid float 0x%x>>",
527 (*info
->fprintf_func
) (info
->stream
, "%f", *(float *) p
);
532 if (INVALID_FLOAT (p
, 8))
533 (*info
->fprintf_func
) (info
->stream
,
534 "<<invalid float 0x%x%08x>>",
535 ((long *) p
)[1], ((long *) p
)[0]);
537 (*info
->fprintf_func
) (info
->stream
, "%f", *(double *) p
);
542 (*info
->fprintf_func
) (info
->stream
, "g-float");
547 (*info
->fprintf_func
) (info
->stream
, "h-float");
554 (*info
->fprintf_func
) (info
->stream
, "(%s)+", REGISTER_NAME (regnum
));
557 case 11: /* Byte displacement deferred */
558 (*info
->fprintf_func
) (info
->stream
, "@");
559 case 10: /* Byte displacement */
560 if (regnum
== PC_REGNUM
)
562 info
->target
= addr
+ *p
+ 2;
563 (*info
->print_address_func
) (info
->target
, info
);
566 (*info
->fprintf_func
) (info
->stream
, "%d(%s)", *p
, REGISTER_NAME (regnum
));
570 case 13: /* Word displacement deferred */
571 (*info
->fprintf_func
) (info
->stream
, "@");
572 case 12: /* Word displacement */
573 if (regnum
== PC_REGNUM
)
575 info
->target
= addr
+ *(short *) p
+ 3;
576 (*info
->print_address_func
) (info
->target
, info
);
579 (*info
->fprintf_func
) (info
->stream
, "%d(%s)",
580 *(short *) p
, REGISTER_NAME (regnum
));
584 case 15: /* Long displacement deferred */
585 (*info
->fprintf_func
) (info
->stream
, "@");
586 case 14: /* Long displacement */
587 if (regnum
== PC_REGNUM
)
589 info
->target
= addr
+ *(short *) p
+ 5;
590 (*info
->print_address_func
) (info
->target
, info
);
593 (*info
->fprintf_func
) (info
->stream
, "%d(%s)",
594 *(long *) p
, REGISTER_NAME (regnum
));
598 return (unsigned char *) p
;
601 /* Initialize the current architecture based on INFO. If possible, re-use an
602 architecture from ARCHES, which is a list of architectures already created
603 during this debugging session.
605 Called e.g. at program startup, when reading a core file, and when reading
608 static struct gdbarch
*
609 vax_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
611 struct gdbarch
*gdbarch
;
613 /* If there is already a candidate, use it. */
614 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
616 return arches
->gdbarch
;
618 gdbarch
= gdbarch_alloc (&info
, NULL
);
620 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
621 ready to unwind the PC first (see frame.c:get_prev_frame()). */
622 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
625 set_gdbarch_num_regs (gdbarch
, VAX_NUM_REGS
);
626 set_gdbarch_sp_regnum (gdbarch
, VAX_SP_REGNUM
);
627 set_gdbarch_fp_regnum (gdbarch
, VAX_FP_REGNUM
);
628 set_gdbarch_pc_regnum (gdbarch
, VAX_PC_REGNUM
);
629 set_gdbarch_ps_regnum (gdbarch
, VAX_PS_REGNUM
);
631 set_gdbarch_register_name (gdbarch
, vax_register_name
);
632 set_gdbarch_register_size (gdbarch
, VAX_REGISTER_SIZE
);
633 set_gdbarch_register_bytes (gdbarch
, VAX_REGISTER_BYTES
);
634 set_gdbarch_register_byte (gdbarch
, vax_register_byte
);
635 set_gdbarch_register_raw_size (gdbarch
, vax_register_raw_size
);
636 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, VAX_MAX_REGISTER_RAW_SIZE
);
637 set_gdbarch_register_virtual_size (gdbarch
, vax_register_virtual_size
);
638 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
,
639 VAX_MAX_REGISTER_VIRTUAL_SIZE
);
640 set_gdbarch_register_virtual_type (gdbarch
, vax_register_virtual_type
);
642 /* Frame and stack info */
643 set_gdbarch_skip_prologue (gdbarch
, vax_skip_prologue
);
644 set_gdbarch_saved_pc_after_call (gdbarch
, vax_saved_pc_after_call
);
646 set_gdbarch_frame_num_args (gdbarch
, vax_frame_num_args
);
647 set_gdbarch_frameless_function_invocation (gdbarch
,
648 generic_frameless_function_invocation_not
);
650 set_gdbarch_frame_chain (gdbarch
, vax_frame_chain
);
651 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, vax_frame_saved_pc
);
653 set_gdbarch_frame_args_address (gdbarch
, vax_frame_args_address
);
654 set_gdbarch_frame_locals_address (gdbarch
, vax_frame_locals_address
);
656 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, vax_frame_init_saved_regs
);
658 set_gdbarch_frame_args_skip (gdbarch
, 4);
660 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
662 /* Return value info */
663 set_gdbarch_store_struct_return (gdbarch
, vax_store_struct_return
);
664 set_gdbarch_deprecated_extract_return_value (gdbarch
, vax_extract_return_value
);
665 set_gdbarch_deprecated_store_return_value (gdbarch
, vax_store_return_value
);
666 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
, vax_extract_struct_value_address
);
668 /* Call dummy info */
669 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, vax_push_dummy_frame
);
670 set_gdbarch_deprecated_pop_frame (gdbarch
, vax_pop_frame
);
671 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
672 set_gdbarch_call_dummy_p (gdbarch
, 1);
673 set_gdbarch_call_dummy_words (gdbarch
, vax_call_dummy_words
);
674 set_gdbarch_sizeof_call_dummy_words (gdbarch
, sizeof_vax_call_dummy_words
);
675 set_gdbarch_fix_call_dummy (gdbarch
, vax_fix_call_dummy
);
676 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
677 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
678 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 7);
679 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
680 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_on_stack
);
681 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
683 /* Breakpoint info */
684 set_gdbarch_breakpoint_from_pc (gdbarch
, vax_breakpoint_from_pc
);
685 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
688 set_gdbarch_function_start_offset (gdbarch
, 2);
689 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
691 /* Hook in ABI-specific overrides, if they have been registered. */
692 gdbarch_init_osabi (info
, gdbarch
);
698 _initialize_vax_tdep (void)
700 gdbarch_register (bfd_arch_vax
, vax_gdbarch_init
, NULL
);
702 tm_print_insn
= vax_print_insn
;