OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
binutils-gdb/gdb/mn10300-tdep.c

523 lines
14 KiB
C
Raw Blame History

/* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 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
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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. */
/* MVS Notes:
To get from 1.1 to 1.2, add:
use_struct_convention
store_return_value
extract_return_value
extract_struct_value_address
Make sure to use regcache. */
/* MVS Notes:
Apparently cannot run without a stub placeholder for unwind_dummy_id.
*/
/* MVS Notes:
To get from 1.2 to 1.3, add:
read_pc, write_pc
frame_unwind_init
struct mn10300_unwind_cache
unwind_pc
unwind_dummy_id
frame_this_id
frame_prev_register
frame_sniffer (struct mn10300_frame_unwind)
*/
#include "defs.h"
#include "arch-utils.h"
#include "dis-asm.h"
#include "gdbtypes.h"
#include "regcache.h"
#include "gdb_string.h"
#include "gdb_assert.h"
#include "frame.h"
#include "frame-unwind.h"
#include "frame-base.h"
#include "trad-frame.h"
#include "symtab.h"
#include "dwarf2-frame.h"
#include "regcache.h"
#include "mn10300-tdep.h"
enum {
E_D0_REGNUM = 0,
E_D1_REGNUM = 1,
E_D2_REGNUM = 2,
E_D3_REGNUM = 3,
E_A0_REGNUM = 4,
E_A1_REGNUM = 5,
E_A2_REGNUM = 6,
E_A3_REGNUM = 7,
E_SP_REGNUM = 8,
E_PC_REGNUM = 9,
E_MDR_REGNUM = 10,
E_PSW_REGNUM = 11,
E_LIR_REGNUM = 12,
E_LAR_REGNUM = 13,
E_MDRQ_REGNUM = 14,
E_E0_REGNUM = 15,
E_MCRH_REGNUM = 26,
E_MCRL_REGNUM = 27,
E_MCVF_REGNUM = 28,
E_NUM_REGS = 32
};
/* Compute the alignment required by a type. */
static int
mn10300_type_align (struct type *type)
{
int i, align = 1;
switch (TYPE_CODE (type))
{
case TYPE_CODE_INT:
case TYPE_CODE_ENUM:
case TYPE_CODE_SET:
case TYPE_CODE_RANGE:
case TYPE_CODE_CHAR:
case TYPE_CODE_BOOL:
case TYPE_CODE_FLT:
case TYPE_CODE_PTR:
case TYPE_CODE_REF:
return TYPE_LENGTH (type);
case TYPE_CODE_COMPLEX:
return TYPE_LENGTH (type) / 2;
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
while (align < falign)
align <<= 1;
}
return align;
case TYPE_CODE_ARRAY:
/* HACK! Structures containing arrays, even small ones, are not
elligible for returning in registers. */
return 256;
case TYPE_CODE_TYPEDEF:
return mn10300_type_align (check_typedef (type));
default:
internal_error (__FILE__, __LINE__, "bad switch");
}
}
/* MVS note this is deprecated. */
/* Should call_function allocate stack space for a struct return? */
/* gcc_p unused */
static int
mn10300_use_struct_convention (int gcc_p, struct type *type)
{
/* Structures bigger than a pair of words can't be returned in
registers. */
if (TYPE_LENGTH (type) > 8)
return 1;
switch (TYPE_CODE (type))
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
/* Structures with a single field are handled as the field
itself. */
if (TYPE_NFIELDS (type) == 1)
return mn10300_use_struct_convention (gcc_p,
TYPE_FIELD_TYPE (type, 0));
/* Structures with word or double-word size are passed in memory, as
long as they require at least word alignment. */
if (mn10300_type_align (type) >= 4)
return 0;
return 1;
/* Arrays are addressable, so they're never returned in
registers. This condition can only hold when the array is
the only field of a struct or union. */
case TYPE_CODE_ARRAY:
return 1;
case TYPE_CODE_TYPEDEF:
return mn10300_use_struct_convention (gcc_p, check_typedef (type));
default:
return 0;
}
}
/* MVS note this is deprecated. */
static void
mn10300_store_return_value (struct type *type,
struct regcache *regcache, const void *valbuf)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int len = TYPE_LENGTH (type);
int reg, regsz;
if (TYPE_CODE (type) == TYPE_CODE_PTR)
reg = 4;
else
reg = 0;
regsz = register_size (gdbarch, reg);
if (len <= regsz)
regcache_raw_write_part (regcache, reg, 0, len, valbuf);
else if (len <= 2 * regsz)
{
regcache_raw_write (regcache, reg, valbuf);
gdb_assert (regsz == register_size (gdbarch, reg + 1));
regcache_raw_write_part (regcache, reg+1, 0,
len - regsz, (char *) valbuf + regsz);
}
else
internal_error (__FILE__, __LINE__,
"Cannot store return value %d bytes long.", len);
}
/* MVS note deprecated. */
static void
mn10300_extract_return_value (struct type *type,
struct regcache *regcache, void *valbuf)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
char buf[MAX_REGISTER_SIZE];
int len = TYPE_LENGTH (type);
int reg, regsz;
if (TYPE_CODE (type) == TYPE_CODE_PTR)
reg = 4;
else
reg = 0;
regsz = register_size (gdbarch, reg);
if (len <= regsz)
{
regcache_raw_read (regcache, reg, buf);
memcpy (valbuf, buf, len);
}
else if (len <= 2 * regsz)
{
regcache_raw_read (regcache, reg, buf);
memcpy (valbuf, buf, regsz);
gdb_assert (regsz == register_size (gdbarch, reg + 1));
regcache_raw_read (regcache, reg + 1, buf);
memcpy ((char *) valbuf + regsz, buf, len - regsz);
}
else
internal_error (__FILE__, __LINE__,
"Cannot extract return value %d bytes long.", len);
}
static char *
register_name (int reg, char **regs, long sizeof_regs)
{
if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
return NULL;
else
return regs[reg];
}
static const char *
mn10300_generic_register_name (int reg)
{
static char *regs[] =
{ "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
"sp", "pc", "mdr", "psw", "lir", "lar", "", "",
"", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "fp"
};
return register_name (reg, regs, sizeof regs);
}
static const char *
am33_register_name (int reg)
{
static char *regs[] =
{ "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
"sp", "pc", "mdr", "psw", "lir", "lar", "",
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
"ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
};
return register_name (reg, regs, sizeof regs);
}
static struct type *
mn10300_register_type (struct gdbarch *gdbarch, int reg)
{
return builtin_type_int;
}
static CORE_ADDR
mn10300_read_pc (ptid_t ptid)
{
return read_register_pid (E_PC_REGNUM, ptid);
}
static void
mn10300_write_pc (CORE_ADDR val, ptid_t ptid)
{
return write_register_pid (E_PC_REGNUM, val, ptid);
}
/* The breakpoint instruction must be the same size as the smallest
instruction in the instruction set.
The Matsushita mn10x00 processors have single byte instructions
so we need a single byte breakpoint. Matsushita hasn't defined
one, so we defined it ourselves. */
const static unsigned char *
mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
{
static char breakpoint[] = {0xff};
*bp_size = 1;
return breakpoint;
}
/* Function: skip_prologue
Return the address of the first inst past the prologue of the function. */
static CORE_ADDR
mn10300_skip_prologue (CORE_ADDR pc)
{
/* FIXME: not implemented. */
/* First approximation, try simply using skip_prologue_using_sal. */
return skip_prologue_using_sal (pc);
}
/* Simple frame_unwind_cache.
This finds the "extra info" for the frame. */
struct trad_frame_cache *
mn10300_frame_unwind_cache (struct frame_info *next_frame,
void **this_prologue_cache)
{
struct trad_frame_cache *cache;
if (*this_prologue_cache)
return (*this_prologue_cache);
cache = trad_frame_cache_zalloc (next_frame);
trad_frame_set_id (cache,
frame_id_build (gdbarch_unwind_sp (current_gdbarch,
next_frame),
gdbarch_unwind_pc (current_gdbarch,
next_frame)));
/* FIXME: The SP isn't the frame base, so this is 0th approximation. */
/* FIXME: The A3 reg isn't always the frame register either, so this
is 1st approximation. */
trad_frame_set_this_base (cache,
frame_unwind_register_signed (next_frame,
E_A3_REGNUM));
(*this_prologue_cache) = cache;
return cache;
}
/* Here is a dummy implementation. */
static struct frame_id
mn10300_dummy_unwind_dummy_id (struct gdbarch *gdbarch,
struct frame_info *next_frame)
{
return frame_id_build (0, 0);
}
/* Trad frame implementation. */
static void
mn10300_frame_this_id (struct frame_info *next_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
struct trad_frame_cache *cache =
mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
trad_frame_get_id (cache, this_id);
}
static void
mn10300_frame_prev_register (struct frame_info *next_frame,
void **this_prologue_cache,
int regnum, int *optimizedp,
enum lval_type *lvalp, CORE_ADDR *addrp,
int *realnump, void *bufferp)
{
struct trad_frame_cache *cache =
mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
trad_frame_get_register (cache, next_frame, regnum, optimizedp,
lvalp, addrp, realnump, bufferp);
/* Or...
trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
optimizedp, lvalp, addrp, realnump, bufferp);
*/
}
static const struct frame_unwind mn10300_frame_unwind = {
NORMAL_FRAME,
mn10300_frame_this_id,
mn10300_frame_prev_register
};
static CORE_ADDR
mn10300_frame_base_address (struct frame_info *next_frame,
void **this_prologue_cache)
{
struct trad_frame_cache *cache =
mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
return trad_frame_get_this_base (cache);
}
static const struct frame_unwind *
mn10300_frame_sniffer (struct frame_info *next_frame)
{
return &mn10300_frame_unwind;
}
static const struct frame_base mn10300_frame_base = {
&mn10300_frame_unwind,
mn10300_frame_base_address,
mn10300_frame_base_address,
mn10300_frame_base_address
};
static CORE_ADDR
mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
ULONGEST pc;
frame_unwind_unsigned_register (next_frame, E_PC_REGNUM, &pc);
return pc;
}
static CORE_ADDR
mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
ULONGEST sp;
frame_unwind_unsigned_register (next_frame, E_SP_REGNUM, &sp);
return sp;
}
static void
mn10300_frame_unwind_init (struct gdbarch *gdbarch)
{
frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
frame_unwind_append_sniffer (gdbarch, mn10300_frame_sniffer);
frame_base_set_default (gdbarch, &mn10300_frame_base);
set_gdbarch_unwind_dummy_id (gdbarch, mn10300_dummy_unwind_dummy_id);
set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);
set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);
}
/* Dump out the mn10300 specific architecture information. */
static void
mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
tdep->am33_mode);
}
static struct gdbarch *
mn10300_gdbarch_init (struct gdbarch_info info,
struct gdbarch_list *arches)
{
struct gdbarch *gdbarch;
struct gdbarch_tdep *tdep;
arches = gdbarch_list_lookup_by_info (arches, &info);
if (arches != NULL)
return arches->gdbarch;
tdep = xmalloc (sizeof (struct gdbarch_tdep));
gdbarch = gdbarch_alloc (&info, tdep);
switch (info.bfd_arch_info->mach)
{
case 0:
case bfd_mach_mn10300:
set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);
tdep->am33_mode = 0;
break;
case bfd_mach_am33:
set_gdbarch_register_name (gdbarch, am33_register_name);
tdep->am33_mode = 1;
break;
default:
internal_error (__FILE__, __LINE__,
"mn10300_gdbarch_init: Unknown mn10300 variant");
break;
}
/* Registers. */
set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
set_gdbarch_register_type (gdbarch, mn10300_register_type);
set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
set_gdbarch_read_pc (gdbarch, mn10300_read_pc);
set_gdbarch_write_pc (gdbarch, mn10300_write_pc);
set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
/* Stack unwinding. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
/* Breakpoints. */
set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
/* decr_pc_after_break? */
/* Disassembly. */
set_gdbarch_print_insn (gdbarch, print_insn_mn10300);
/* Stage 2 */
/* MVS Note: at least the first one is deprecated! */
set_gdbarch_deprecated_use_struct_convention (gdbarch,
mn10300_use_struct_convention);
set_gdbarch_store_return_value (gdbarch, mn10300_store_return_value);
set_gdbarch_extract_return_value (gdbarch, mn10300_extract_return_value);
mn10300_frame_unwind_init (gdbarch);
return gdbarch;
}
void
_initialize_mn10300_tdep (void)
{
gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);
}
Reference in New Issue View Git Blame Copy Permalink