/* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
- Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
+ 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 "frame.h"
Returns the name of the standard Xstormy16 register N. */
static const char *
-xstormy16_register_name (int regnum)
+xstormy16_register_name (struct gdbarch *gdbarch, int regnum)
{
static char *register_names[] = {
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
if (regnum < 0 || regnum >= E_NUM_REGS)
internal_error (__FILE__, __LINE__,
- "xstormy16_register_name: illegal register number %d",
+ _("xstormy16_register_name: illegal register number %d"),
regnum);
else
return register_names[regnum];
}
static enum return_value_convention
-xstormy16_return_value (struct gdbarch *gdbarch, struct type *type,
- struct regcache *regcache,
- void *readbuf, const void *writebuf)
+xstormy16_return_value (struct gdbarch *gdbarch, struct type *func_type,
+ struct type *type, struct regcache *regcache,
+ gdb_byte *readbuf, const gdb_byte *writebuf)
{
if (xstormy16_use_struct_convention (type))
return RETURN_VALUE_STRUCT_CONVENTION;
int argreg = E_1ST_ARG_REGNUM;
int i, j;
int typelen, slacklen;
- char *val;
+ const gdb_byte *val;
char buf[xstormy16_pc_size];
/* If struct_return is true, then the struct return address will
would fit in the remaining unused registers. */
for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
{
- typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
+ typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
if (typelen > E_MAX_RETTYPE_SIZE (argreg))
break;
/* Put argument into registers wordwise. */
- val = VALUE_CONTENTS (args[i]);
+ val = value_contents (args[i]);
for (j = 0; j < typelen; j += xstormy16_reg_size)
regcache_cooked_write_unsigned (regcache, argreg++,
extract_unsigned_integer (val + j,
wordaligned. */
for (j = nargs - 1; j >= i; j--)
{
- typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[j]));
+ char *val;
+
+ typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
slacklen = typelen & 1;
val = alloca (typelen + slacklen);
- memcpy (val, VALUE_CONTENTS (args[j]), typelen);
+ memcpy (val, value_contents (args[j]), typelen);
memset (val + typelen, 0, slacklen);
/* Now write this data to the stack. The stack grows upwards. */
static CORE_ADDR
xstormy16_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
struct xstormy16_frame_cache *cache,
- struct frame_info *next_frame)
+ struct frame_info *this_frame)
{
CORE_ADDR next_addr;
ULONGEST inst, inst2;
stepped into a function call. */
static CORE_ADDR
-xstormy16_skip_prologue (CORE_ADDR pc)
+xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
CORE_ADDR func_addr = 0, func_end = 0;
char *func_name;
struct symtab_and_line sal;
struct symbol *sym;
struct xstormy16_frame_cache cache;
+ CORE_ADDR plg_end;
+
+ memset (&cache, 0, sizeof cache);
/* Don't trust line number debug info in frameless functions. */
- CORE_ADDR plg_end = xstormy16_analyze_prologue (func_addr, func_end,
- &cache, NULL);
+ plg_end = xstormy16_analyze_prologue (func_addr, func_end, &cache, NULL);
if (!cache.uses_fp)
return plg_end;
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL);
+ sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
/* Don't use line number debug info for assembly source files. */
if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
{
}
const static unsigned char *
-xstormy16_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+xstormy16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
+ int *lenptr)
{
static unsigned char breakpoint[] = { 0x06, 0x0 };
*lenptr = sizeof (breakpoint);
if (osect < faddr_sect->objfile->sections_end)
{
- CORE_ADDR addr;
- for (addr = osect->addr;
- addr < osect->endaddr; addr += 2 * xstormy16_inst_size)
+ CORE_ADDR addr, endaddr;
+
+ addr = obj_section_addr (osect);
+ endaddr = obj_section_endaddr (osect);
+
+ for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
{
LONGEST inst, inst2, faddr2;
char buf[2 * xstormy16_inst_size];
}
static CORE_ADDR
-xstormy16_skip_trampoline_code (CORE_ADDR pc)
+xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (pc);
return 0;
}
-static int
-xstormy16_in_solib_call_trampoline (CORE_ADDR pc, char *name)
-{
- return xstormy16_skip_trampoline_code (pc) != 0;
-}
-
/* Function pointers are 16 bit. The address space is 24 bit, using
32 bit addresses. Pointers to functions on the XStormy16 are implemented
by using 16 bit pointers, which are either direct pointers in case the
and vice versa. */
static CORE_ADDR
-xstormy16_pointer_to_address (struct type *type, const void *buf)
+xstormy16_pointer_to_address (struct gdbarch *gdbarch,
+ struct type *type, const gdb_byte *buf)
{
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
}
static void
-xstormy16_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
+xstormy16_address_to_pointer (struct gdbarch *gdbarch,
+ struct type *type, gdb_byte *buf, CORE_ADDR addr)
{
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
}
static struct xstormy16_frame_cache *
-xstormy16_frame_cache (struct frame_info *next_frame, void **this_cache)
+xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
{
struct xstormy16_frame_cache *cache;
CORE_ADDR current_pc;
cache = xstormy16_alloc_frame_cache ();
*this_cache = cache;
- 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);
- current_pc = frame_pc_unwind (next_frame);
+ cache->pc = get_frame_func (this_frame);
+ current_pc = get_frame_pc (this_frame);
if (cache->pc)
- xstormy16_analyze_prologue (cache->pc, current_pc, cache, next_frame);
+ xstormy16_analyze_prologue (cache->pc, current_pc, cache, this_frame);
if (!cache->uses_fp)
- cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
+ cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
cache->saved_sp = cache->base - cache->framesize;
return cache;
}
-static void
-xstormy16_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 *
+xstormy16_frame_prev_register (struct frame_info *this_frame,
+ void **this_cache, int regnum)
{
- struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame,
+ struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
this_cache);
gdb_assert (regnum >= 0);
if (regnum == E_SP_REGNUM && cache->saved_sp)
- {
- *optimizedp = 0;
- *lvalp = not_lval;
- *addrp = 0;
- *realnump = -1;
- if (valuep)
- {
- /* Store the value. */
- store_unsigned_integer (valuep, xstormy16_reg_size, cache->saved_sp);
- }
- return;
- }
+ return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
- {
- *optimizedp = 0;
- *lvalp = lval_memory;
- *addrp = cache->saved_regs[regnum];
- *realnump = -1;
- if (valuep)
- {
- /* Read the value in from memory. */
- read_memory (*addrp, valuep,
- register_size (current_gdbarch, regnum));
- }
- return;
- }
+ return frame_unwind_got_memory (this_frame, regnum,
+ cache->saved_regs[regnum]);
- *optimizedp = 0;
- *lvalp = lval_register;
- *addrp = 0;
- *realnump = regnum;
- if (valuep)
- frame_unwind_register (next_frame, (*realnump), valuep);
+ return frame_unwind_got_register (this_frame, regnum, regnum);
}
static void
-xstormy16_frame_this_id (struct frame_info *next_frame, void **this_cache,
+xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
struct frame_id *this_id)
{
- struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame,
+ struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
this_cache);
/* This marks the outermost frame. */
}
static CORE_ADDR
-xstormy16_frame_base_address (struct frame_info *next_frame, void **this_cache)
+xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
{
- struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame,
+ struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
this_cache);
return cache->base;
}
static const struct frame_unwind xstormy16_frame_unwind = {
NORMAL_FRAME,
xstormy16_frame_this_id,
- xstormy16_frame_prev_register
+ xstormy16_frame_prev_register,
+ NULL,
+ default_frame_sniffer
};
static const struct frame_base xstormy16_frame_base = {
xstormy16_frame_base_address
};
-static const struct frame_unwind *
-xstormy16_frame_sniffer (struct frame_info *next_frame)
-{
- return &xstormy16_frame_unwind;
-}
-
static CORE_ADDR
xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
}
static struct frame_id
-xstormy16_unwind_dummy_id (struct gdbarch *gdbarch,
- struct frame_info *next_frame)
+xstormy16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
{
- return frame_id_build (xstormy16_unwind_sp (gdbarch, next_frame),
- frame_pc_unwind (next_frame));
+ CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
+ return frame_id_build (sp, get_frame_pc (this_frame));
}
set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
- set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-
/* Stack grows up. */
set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
*/
set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp);
set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc);
- set_gdbarch_unwind_dummy_id (gdbarch, xstormy16_unwind_dummy_id);
+ set_gdbarch_dummy_id (gdbarch, xstormy16_dummy_id);
set_gdbarch_frame_align (gdbarch, xstormy16_frame_align);
frame_base_set_default (gdbarch, &xstormy16_frame_base);
set_gdbarch_return_value (gdbarch, xstormy16_return_value);
set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
- set_gdbarch_in_solib_call_trampoline (gdbarch,
- xstormy16_in_solib_call_trampoline);
set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
gdbarch_init_osabi (info, gdbarch);
- frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
- frame_unwind_append_sniffer (gdbarch, xstormy16_frame_sniffer);
+ dwarf2_append_unwinders (gdbarch);
+ frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
return gdbarch;
}