X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fvax-tdep.c;h=db57bee05c7ab0278092e4212ab90a613cf353e9;hb=32b40af94e919e235c21486110311647cbeecf2e;hp=5fc96a3c3543de017b1773aff384b015fab1fcff;hpb=8cc49c48551690179fcc7eb79288d75ce1b939b1;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/vax-tdep.c b/gdb/vax-tdep.c index 5fc96a3c35..db57bee05c 100644 --- a/gdb/vax-tdep.c +++ b/gdb/vax-tdep.c @@ -1,13 +1,12 @@ /* Target-dependent code for the VAX. - Copyright 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000, - 2002, 2003, 2004, 2005 Free Software Foundation, Inc. + Copyright (C) 1986-2015 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, @@ -16,13 +15,12 @@ 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 . */ #include "defs.h" #include "arch-utils.h" #include "dis-asm.h" +#include "floatformat.h" #include "frame.h" #include "frame-base.h" #include "frame-unwind.h" @@ -34,14 +32,12 @@ #include "trad-frame.h" #include "value.h" -#include "gdb_string.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[] = { @@ -57,12 +53,12 @@ vax_register_name (int regnum) } /* Return the GDB type object for the "standard" data type of data in - register REGNUM. */ + register REGNUM. */ static struct type * vax_register_type (struct gdbarch *gdbarch, int regnum) { - return builtin_type_int; + return builtin_type (gdbarch)->builtin_int; } /* Core file support. */ @@ -87,23 +83,21 @@ vax_supply_gregset (const struct regset *regset, struct regcache *regcache, /* VAX register set. */ -static struct regset vax_gregset = +static const struct regset vax_gregset = { NULL, vax_supply_gregset }; -/* Return the appropriate register set for the core section identified - by SECT_NAME and SECT_SIZE. */ +/* Iterate over core file register note sections. */ -static const struct regset * -vax_regset_from_core_section (struct gdbarch *gdbarch, - const char *sect_name, size_t sect_size) +static void +vax_iterate_over_regset_sections (struct gdbarch *gdbarch, + iterate_over_regset_sections_cb *cb, + void *cb_data, + const struct regcache *regcache) { - if (strcmp (sect_name, ".reg") == 0 && sect_size >= VAX_NUM_REGS * 4) - return &vax_gregset; - - return NULL; + cb (".reg", VAX_NUM_REGS * 4, &vax_gregset, NULL, cb_data); } /* The VAX UNIX calling convention uses R1 to pass a structure return @@ -114,6 +108,8 @@ static CORE_ADDR vax_store_arguments (struct regcache *regcache, int nargs, struct value **args, CORE_ADDR sp) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); gdb_byte buf[4]; int count = 0; int i; @@ -133,11 +129,11 @@ vax_store_arguments (struct regcache *regcache, int nargs, /* Push argument count. */ sp -= 4; - store_unsigned_integer (buf, 4, count); + store_unsigned_integer (buf, 4, byte_order, count); write_memory (sp, buf, 4); /* Update the argument pointer. */ - store_unsigned_integer (buf, 4, sp); + store_unsigned_integer (buf, 4, byte_order, sp); regcache_cooked_write (regcache, VAX_AP_REGNUM, buf); return sp; @@ -149,6 +145,7 @@ vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR fp = sp; gdb_byte buf[4]; @@ -161,12 +158,12 @@ vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Store return address in the PC slot. */ sp -= 4; - store_unsigned_integer (buf, 4, bp_addr); + store_unsigned_integer (buf, 4, byte_order, bp_addr); write_memory (sp, buf, 4); /* Store the (fake) frame pointer in the FP slot. */ sp -= 4; - store_unsigned_integer (buf, 4, fp); + store_unsigned_integer (buf, 4, byte_order, fp); write_memory (sp, buf, 4); /* Skip the AP slot. */ @@ -174,16 +171,16 @@ vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Store register save mask and control bits. */ sp -= 4; - store_unsigned_integer (buf, 4, 0); + store_unsigned_integer (buf, 4, byte_order, 0); write_memory (sp, buf, 4); /* Store condition handler. */ sp -= 4; - store_unsigned_integer (buf, 4, 0); + store_unsigned_integer (buf, 4, byte_order, 0); write_memory (sp, buf, 4); /* Update the stack pointer and frame pointer. */ - store_unsigned_integer (buf, 4, sp); + store_unsigned_integer (buf, 4, byte_order, sp); regcache_cooked_write (regcache, VAX_SP_REGNUM, buf); regcache_cooked_write (regcache, VAX_FP_REGNUM, buf); @@ -192,19 +189,19 @@ vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function, } static struct frame_id -vax_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) +vax_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) { CORE_ADDR fp; - fp = frame_unwind_register_unsigned (next_frame, VAX_FP_REGNUM); - return frame_id_build (fp, frame_pc_unwind (next_frame)); + fp = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM); + return frame_id_build (fp, get_frame_pc (this_frame)); } static enum return_value_convention -vax_return_value (struct gdbarch *gdbarch, struct type *type, - struct regcache *regcache, void *readbuf, - const void *writebuf) +vax_return_value (struct gdbarch *gdbarch, struct value *function, + struct type *type, struct regcache *regcache, + gdb_byte *readbuf, const gdb_byte *writebuf) { int len = TYPE_LENGTH (type); gdb_byte buf[8]; @@ -256,7 +253,7 @@ vax_return_value (struct gdbarch *gdbarch, struct type *type, location for inserting the breakpoint. */ static const gdb_byte * -vax_breakpoint_from_pc (CORE_ADDR *pc, int *len) +vax_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len) { static gdb_byte break_insn[] = { 3 }; @@ -268,28 +265,29 @@ vax_breakpoint_from_pc (CORE_ADDR *pc, int *len) to reach some "real" code. */ static CORE_ADDR -vax_skip_prologue (CORE_ADDR pc) +vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) { - gdb_byte op = read_memory_unsigned_integer (pc, 1); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order); if (op == 0x11) pc += 2; /* skip brb */ if (op == 0x31) pc += 3; /* skip brw */ if (op == 0xC2 - && (read_memory_unsigned_integer (pc + 2, 1)) == 0x5E) + && read_memory_unsigned_integer (pc + 2, 1, byte_order) == 0x5E) pc += 3; /* skip subl2 */ if (op == 0x9E - && (read_memory_unsigned_integer (pc + 1, 1)) == 0xAE - && (read_memory_unsigned_integer (pc + 3, 1)) == 0x5E) + && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xAE + && read_memory_unsigned_integer (pc + 3, 1, byte_order) == 0x5E) pc += 4; /* skip movab */ if (op == 0x9E - && (read_memory_unsigned_integer (pc + 1, 1)) == 0xCE - && (read_memory_unsigned_integer (pc + 4, 1)) == 0x5E) + && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xCE + && read_memory_unsigned_integer (pc + 4, 1, byte_order) == 0x5E) pc += 5; /* skip movab */ if (op == 0x9E - && (read_memory_unsigned_integer (pc + 1, 1)) == 0xEE - && (read_memory_unsigned_integer (pc + 6, 1)) == 0x5E) + && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xEE + && read_memory_unsigned_integer (pc + 6, 1, byte_order) == 0x5E) pc += 7; /* skip movab */ return pc; @@ -311,8 +309,8 @@ struct vax_frame_cache struct trad_frame_saved_reg *saved_regs; }; -struct vax_frame_cache * -vax_frame_cache (struct frame_info *next_frame, void **this_cache) +static struct vax_frame_cache * +vax_frame_cache (struct frame_info *this_frame, void **this_cache) { struct vax_frame_cache *cache; CORE_ADDR addr; @@ -324,16 +322,16 @@ vax_frame_cache (struct frame_info *next_frame, void **this_cache) /* Allocate a new cache. */ cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache); - cache->saved_regs = trad_frame_alloc_saved_regs (next_frame); + cache->saved_regs = trad_frame_alloc_saved_regs (this_frame); /* The frame pointer is used as the base for the frame. */ - cache->base = frame_unwind_register_unsigned (next_frame, VAX_FP_REGNUM); + cache->base = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM); if (cache->base == 0) return cache; /* The register save mask and control bits determine the layout of the stack frame. */ - mask = get_frame_memory_unsigned (next_frame, cache->base + 4, 4) >> 16; + mask = get_frame_memory_unsigned (this_frame, cache->base + 4, 4) >> 16; /* These are always saved. */ cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16; @@ -363,7 +361,7 @@ vax_frame_cache (struct frame_info *next_frame, void **this_cache) 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); + numarg = get_frame_memory_unsigned (this_frame, addr, 1); addr += 4 + numarg * 4; } @@ -374,56 +372,50 @@ vax_frame_cache (struct frame_info *next_frame, void **this_cache) } static void -vax_frame_this_id (struct frame_info *next_frame, void **this_cache, +vax_frame_this_id (struct frame_info *this_frame, void **this_cache, struct frame_id *this_id) { - struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache); + struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache); /* This marks the outermost frame. */ if (cache->base == 0) return; - (*this_id) = frame_id_build (cache->base, frame_func_unwind (next_frame)); + (*this_id) = frame_id_build (cache->base, get_frame_func (this_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) +static struct value * +vax_frame_prev_register (struct frame_info *this_frame, + void **this_cache, int regnum) { - struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache); + struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache); - trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum, - optimizedp, lvalp, addrp, realnump, valuep); + return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum); } static const struct frame_unwind vax_frame_unwind = { NORMAL_FRAME, + default_frame_unwind_stop_reason, vax_frame_this_id, - vax_frame_prev_register + vax_frame_prev_register, + NULL, + default_frame_sniffer }; - -static const struct frame_unwind * -vax_frame_sniffer (struct frame_info *next_frame) -{ - return &vax_frame_unwind; -} static CORE_ADDR -vax_frame_base_address (struct frame_info *next_frame, void **this_cache) +vax_frame_base_address (struct frame_info *this_frame, void **this_cache) { - struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache); + struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache); return cache->base; } static CORE_ADDR -vax_frame_args_address (struct frame_info *next_frame, void **this_cache) +vax_frame_args_address (struct frame_info *this_frame, void **this_cache) { - return frame_unwind_register_unsigned (next_frame, VAX_AP_REGNUM); + return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM); } static const struct frame_base vax_frame_base = @@ -476,6 +468,11 @@ vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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); @@ -484,8 +481,8 @@ vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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); + set_gdbarch_iterate_over_regset_sections + (gdbarch, vax_iterate_over_regset_sections); /* Frame and stack info */ set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue); @@ -500,7 +497,7 @@ vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Call dummy code. */ set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call); - set_gdbarch_unwind_dummy_id (gdbarch, vax_unwind_dummy_id); + set_gdbarch_dummy_id (gdbarch, vax_dummy_id); /* Breakpoint info */ set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc); @@ -518,7 +515,7 @@ vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Hook in ABI-specific overrides, if they have been registered. */ gdbarch_init_osabi (info, gdbarch); - frame_unwind_append_sniffer (gdbarch, vax_frame_sniffer); + frame_unwind_append_unwinder (gdbarch, &vax_frame_unwind); return (gdbarch); }