-/* Print VAX instructions for GDB, the GNU debugger.
+/* Target-dependent code for the VAX.
- Copyright 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000,
- 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000, 2002,
+ 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "symtab.h"
-#include "opcode/vax.h"
-#include "gdbcore.h"
-#include "inferior.h"
-#include "regcache.h"
+#include "arch-utils.h"
+#include "dis-asm.h"
+#include "floatformat.h"
#include "frame.h"
#include "frame-base.h"
#include "frame-unwind.h"
+#include "gdbcore.h"
+#include "gdbtypes.h"
+#include "osabi.h"
+#include "regcache.h"
+#include "regset.h"
#include "trad-frame.h"
#include "value.h"
-#include "arch-utils.h"
+
#include "gdb_string.h"
-#include "osabi.h"
-#include "dis-asm.h"
#include "vax-tdep.h"
/* Return the name of register REGNUM. */
static const char *
-vax_register_name (int regnum)
+vax_register_name (struct gdbarch *gdbarch, int regnum)
{
static char *register_names[] =
{
return builtin_type_int;
}
\f
+/* Core file support. */
+
+/* Supply register REGNUM from the buffer specified by GREGS and LEN
+ in the general-purpose register set REGSET to register cache
+ REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
+
+static void
+vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
+ int regnum, const void *gregs, size_t len)
+{
+ const gdb_byte *regs = gregs;
+ int i;
+
+ for (i = 0; i < VAX_NUM_REGS; i++)
+ {
+ if (regnum == i || regnum == -1)
+ regcache_raw_supply (regcache, i, regs + i * 4);
+ }
+}
+
+/* VAX register set. */
+
+static struct regset vax_gregset =
+{
+ NULL,
+ vax_supply_gregset
+};
+
+/* Return the appropriate register set for the core section identified
+ by SECT_NAME and SECT_SIZE. */
+
+static const struct regset *
+vax_regset_from_core_section (struct gdbarch *gdbarch,
+ const char *sect_name, size_t sect_size)
+{
+ if (strcmp (sect_name, ".reg") == 0 && sect_size >= VAX_NUM_REGS * 4)
+ return &vax_gregset;
-/* The VAX Unix calling convention uses R1 to pass a structure return
+ return NULL;
+}
+\f
+/* The VAX UNIX calling convention uses R1 to pass a structure return
value address instead of passing it as a first (hidden) argument as
the VMS calling convention suggests. */
vax_store_arguments (struct regcache *regcache, int nargs,
struct value **args, CORE_ADDR sp)
{
- char buf[4];
+ gdb_byte buf[4];
int count = 0;
int i;
/* Push arguments in reverse order. */
for (i = nargs - 1; i >= 0; i--)
{
- int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
+ int len = TYPE_LENGTH (value_enclosing_type (args[i]));
sp -= (len + 3) & ~3;
count += (len + 3) / 4;
- write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
+ write_memory (sp, value_contents_all (args[i]), len);
}
/* Push argument count. */
}
static CORE_ADDR
-vax_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
+vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
struct value **args, CORE_ADDR sp, int struct_return,
CORE_ADDR struct_addr)
{
CORE_ADDR fp = sp;
- char buf[4];
+ gdb_byte buf[4];
/* Set up the function arguments. */
sp = vax_store_arguments (regcache, nargs, args, sp);
static enum return_value_convention
vax_return_value (struct gdbarch *gdbarch, struct type *type,
- struct regcache *regcache, void *readbuf,
- const void *writebuf)
+ struct regcache *regcache, gdb_byte *readbuf,
+ const gdb_byte *writebuf)
{
int len = TYPE_LENGTH (type);
- char buf[8];
+ gdb_byte buf[8];
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
- || TYPE_CODE (type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (type) == TYPE_CODE_UNION
|| TYPE_CODE (type) == TYPE_CODE_ARRAY)
- return RETURN_VALUE_STRUCT_CONVENTION;
+ {
+ /* The default on VAX is to return structures in static memory.
+ Consequently a function must return the address where we can
+ find the return value. */
+
+ if (readbuf)
+ {
+ ULONGEST addr;
+
+ regcache_raw_read_unsigned (regcache, VAX_R0_REGNUM, &addr);
+ read_memory (addr, readbuf, len);
+ }
+
+ return RETURN_VALUE_ABI_RETURNS_ADDRESS;
+ }
if (readbuf)
{
*LEN and optionally adjust *PC to point to the correct memory
location for inserting the breakpoint. */
-static const unsigned char *
-vax_breakpoint_from_pc (CORE_ADDR *pc, int *len)
+static const gdb_byte *
+vax_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
{
- static unsigned char break_insn[] = { 3 };
+ static gdb_byte break_insn[] = { 3 };
*len = sizeof (break_insn);
return break_insn;
static CORE_ADDR
vax_skip_prologue (CORE_ADDR pc)
{
- int op = (unsigned char) read_memory_integer (pc, 1);
+ gdb_byte op = read_memory_unsigned_integer (pc, 1);
+
if (op == 0x11)
pc += 2; /* skip brb */
if (op == 0x31)
pc += 3; /* skip brw */
if (op == 0xC2
- && ((unsigned char) read_memory_integer (pc + 2, 1)) == 0x5E)
+ && (read_memory_unsigned_integer (pc + 2, 1)) == 0x5E)
pc += 3; /* skip subl2 */
if (op == 0x9E
- && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xAE
- && ((unsigned char) read_memory_integer (pc + 3, 1)) == 0x5E)
+ && (read_memory_unsigned_integer (pc + 1, 1)) == 0xAE
+ && (read_memory_unsigned_integer (pc + 3, 1)) == 0x5E)
pc += 4; /* skip movab */
if (op == 0x9E
- && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xCE
- && ((unsigned char) read_memory_integer (pc + 4, 1)) == 0x5E)
+ && (read_memory_unsigned_integer (pc + 1, 1)) == 0xCE
+ && (read_memory_unsigned_integer (pc + 4, 1)) == 0x5E)
pc += 5; /* skip movab */
if (op == 0x9E
- && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xEE
- && ((unsigned char) read_memory_integer (pc + 6, 1)) == 0x5E)
+ && (read_memory_unsigned_integer (pc + 1, 1)) == 0xEE
+ && (read_memory_unsigned_integer (pc + 6, 1)) == 0x5E)
pc += 7; /* skip movab */
+
return pc;
}
\f
ULONGEST numarg;
/* This is a procedure with Stack Argument List. Adjust the
- stack address for the arguments thet were pushed onto the
+ stack address for the arguments that were pushed onto the
stack. The return instruction will automatically pop the
arguments from the stack. */
numarg = get_frame_memory_unsigned (next_frame, addr, 1);
if (cache->base == 0)
return;
- (*this_id) = frame_id_build (cache->base, frame_pc_unwind (next_frame));
+ (*this_id) = frame_id_build (cache->base,
+ frame_func_unwind (next_frame, NORMAL_FRAME));
}
static void
vax_frame_prev_register (struct frame_info *next_frame, void **this_cache,
int regnum, int *optimizedp,
enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, void *valuep)
+ int *realnump, gdb_byte *valuep)
{
struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache);
- trad_frame_prev_register (next_frame, cache->saved_regs, regnum,
- optimizedp, lvalp, addrp, realnump, valuep);
+ trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
+ optimizedp, lvalp, addrp, realnump, valuep);
}
static const struct frame_unwind vax_frame_unwind =
/* Assume that the argument pointer for the outermost frame is
hosed, as is the case on NetBSD/vax ELF. */
- if (get_frame_base (frame) == 0)
+ if (get_frame_base_address (frame) == 0)
return 0;
args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
gdbarch = gdbarch_alloc (&info, NULL);
+ set_gdbarch_float_format (gdbarch, floatformats_vax_f);
+ set_gdbarch_double_format (gdbarch, floatformats_vax_d);
+ set_gdbarch_long_double_format (gdbarch, floatformats_vax_d);
+ set_gdbarch_long_double_bit (gdbarch, 64);
+
/* Register info */
set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
set_gdbarch_register_name (gdbarch, vax_register_name);
set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
+ set_gdbarch_regset_from_core_section
+ (gdbarch, vax_regset_from_core_section);
+
/* Frame and stack info */
set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
-
set_gdbarch_frame_args_skip (gdbarch, 4);
/* Stack grows downward. */
set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
/* Misc info */
- set_gdbarch_function_start_offset (gdbarch, 2);
+ set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
+ set_gdbarch_print_insn (gdbarch, print_insn_vax);
+
set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
frame_base_set_default (gdbarch, &vax_frame_base);
frame_unwind_append_sniffer (gdbarch, vax_frame_sniffer);
- set_gdbarch_print_insn (gdbarch, print_insn_vax);
-
return (gdbarch);
}
-extern initialize_file_ftype _initialize_vax_tdep; /* -Wmissing-prototypes */
+/* Provide a prototype to silence -Wmissing-prototypes. */
+void _initialize_vax_tdep (void);
void
_initialize_vax_tdep (void)
projects / binutils.git / blobdiff