/* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
- Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
- Free Software Foundation, Inc.
+ Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007,
+ 2008 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., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "frame.h"
};
static const char *
-v850_register_name (int regnum)
+v850_register_name (struct gdbarch *gdbarch, int regnum)
{
static const char *v850_reg_names[] =
{ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
}
static const char *
-v850e_register_name (int regnum)
+v850e_register_name (struct gdbarch *gdbarch, int regnum)
{
static const char *v850e_reg_names[] =
{
/* Return the address of the first code past the prologue of the function. */
static CORE_ADDR
-v850_skip_prologue (CORE_ADDR pc)
+v850_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
CORE_ADDR func_addr, func_end;
}
static enum return_value_convention
-v850_return_value (struct gdbarch *gdbarch, struct type *type,
- struct regcache *regcache,
+v850_return_value (struct gdbarch *gdbarch, struct type *func_type,
+ struct type *type, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
{
if (v850_use_struct_convention (type))
}
const static unsigned char *
-v850_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+v850_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
{
static unsigned char breakpoint[] = { 0x85, 0x05 };
*lenptr = sizeof (breakpoint);
}
static struct v850_frame_cache *
-v850_alloc_frame_cache (struct frame_info *next_frame)
+v850_alloc_frame_cache (struct frame_info *this_frame)
{
struct v850_frame_cache *cache;
int i;
cache = FRAME_OBSTACK_ZALLOC (struct v850_frame_cache);
- cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+ cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
/* Base address. */
cache->base = 0;
}
static struct v850_frame_cache *
-v850_frame_cache (struct frame_info *next_frame, void **this_cache)
+v850_frame_cache (struct frame_info *this_frame, void **this_cache)
{
struct v850_frame_cache *cache;
CORE_ADDR current_pc;
if (*this_cache)
return *this_cache;
- cache = v850_alloc_frame_cache (next_frame);
+ cache = v850_alloc_frame_cache (this_frame);
*this_cache = cache;
/* In principle, for normal frames, fp holds the frame pointer,
However, for functions that don't need it, the frame pointer is
optional. For these "frameless" functions the frame pointer is
actually the frame pointer of the calling frame. */
- cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM);
+ cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
if (cache->base == 0)
return cache;
- cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME);
- current_pc = frame_pc_unwind (next_frame);
+ cache->pc = get_frame_func (this_frame);
+ current_pc = get_frame_pc (this_frame);
if (cache->pc != 0)
{
ULONGEST ctbp;
- ctbp = frame_unwind_register_unsigned (next_frame, E_CTBP_REGNUM);
+ ctbp = get_frame_register_unsigned (this_frame, E_CTBP_REGNUM);
v850_analyze_prologue (cache->pc, current_pc, cache, ctbp);
}
setup yet. Try to reconstruct the base address for the stack
frame by looking at the stack pointer. For truly "frameless"
functions this might work too. */
- cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
+ cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
}
/* Now that we have the base address for the stack frame we can
}
-static void
-v850_frame_prev_register (struct frame_info *next_frame, void **this_cache,
- int regnum, int *optimizedp,
- enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, gdb_byte *valuep)
+static struct value *
+v850_frame_prev_register (struct frame_info *this_frame,
+ void **this_cache, int regnum)
{
- struct v850_frame_cache *cache = v850_frame_cache (next_frame, this_cache);
+ struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
gdb_assert (regnum >= 0);
- 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 void
-v850_frame_this_id (struct frame_info *next_frame, void **this_cache,
+v850_frame_this_id (struct frame_info *this_frame, void **this_cache,
struct frame_id *this_id)
{
- struct v850_frame_cache *cache = v850_frame_cache (next_frame, this_cache);
+ struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
/* This marks the outermost frame. */
if (cache->base == 0)
static const struct frame_unwind v850_frame_unwind = {
NORMAL_FRAME,
v850_frame_this_id,
- v850_frame_prev_register
+ v850_frame_prev_register,
+ NULL,
+ default_frame_sniffer
};
-
-static const struct frame_unwind *
-v850_frame_sniffer (struct frame_info *next_frame)
-{
- return &v850_frame_unwind;
-}
static CORE_ADDR
v850_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
- return frame_unwind_register_unsigned (next_frame, SP_REGNUM);
+ return frame_unwind_register_unsigned (next_frame,
+ gdbarch_sp_regnum (gdbarch));
}
static CORE_ADDR
v850_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
- return frame_unwind_register_unsigned (next_frame, PC_REGNUM);
+ return frame_unwind_register_unsigned (next_frame,
+ gdbarch_pc_regnum (gdbarch));
}
static struct frame_id
-v850_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+v850_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
{
- return frame_id_build (v850_unwind_sp (gdbarch, next_frame),
- frame_pc_unwind (next_frame));
+ CORE_ADDR sp = get_frame_register_unsigned (this_frame,
+ gdbarch_sp_regnum (gdbarch));
+ return frame_id_build (sp, get_frame_pc (this_frame));
}
static CORE_ADDR
-v850_frame_base_address (struct frame_info *next_frame, void **this_cache)
+v850_frame_base_address (struct frame_info *this_frame, void **this_cache)
{
- struct v850_frame_cache *cache = v850_frame_cache (next_frame, this_cache);
+ struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
return cache->base;
}
set_gdbarch_frame_align (gdbarch, v850_frame_align);
set_gdbarch_unwind_sp (gdbarch, v850_unwind_sp);
set_gdbarch_unwind_pc (gdbarch, v850_unwind_pc);
- set_gdbarch_unwind_dummy_id (gdbarch, v850_unwind_dummy_id);
+ set_gdbarch_dummy_id (gdbarch, v850_dummy_id);
frame_base_set_default (gdbarch, &v850_frame_base);
/* Hook in ABI-specific overrides, if they have been registered. */
gdbarch_init_osabi (info, gdbarch);
- frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
- frame_unwind_append_sniffer (gdbarch, v850_frame_sniffer);
+ dwarf2_append_unwinders (gdbarch);
+ frame_unwind_append_unwinder (gdbarch, &v850_frame_unwind);
return gdbarch;
}
projects / deliverable / binutils-gdb.git / blobdiff