/* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
- Copyright (C) 2001-2017 Free Software Foundation, Inc.
+ Copyright (C) 2001-2023 Free Software Foundation, Inc.
This file is part of GDB.
#include "frame.h"
#include "frame-base.h"
#include "frame-unwind.h"
-#include "dwarf2-frame.h"
+#include "dwarf2/frame.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "gdbcmd.h"
#include "dis-asm.h"
#include "inferior.h"
#include "arch-utils.h"
-#include "floatformat.h"
#include "regcache.h"
-#include "doublest.h"
#include "osabi.h"
#include "objfiles.h"
-#include "common/byte-vector.h"
+#include "gdbsupport/byte-vector.h"
enum gdb_regnum
{
to the function in r2. Further arguments are beginning in r3 then.
R13 is used as frame pointer when GCC compiles w/o optimization
R14 is used as "PSW", displaying the CPU status.
- R15 is used implicitely as stack pointer. */
+ R15 is used implicitly as stack pointer. */
E_R0_REGNUM,
E_R1_REGNUM,
E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
"psw", "sp", "pc"
};
- if (regnum < 0 || regnum >= E_NUM_REGS)
- internal_error (__FILE__, __LINE__,
- _("xstormy16_register_name: illegal register number %d"),
- regnum);
- else
- return register_names[regnum];
-
+ gdb_static_assert (ARRAY_SIZE (register_names) == E_NUM_REGS);
+ return register_names[regnum];
}
static struct type *
static int
xstormy16_type_is_scalar (struct type *t)
{
- return (TYPE_CODE(t) != TYPE_CODE_STRUCT
- && TYPE_CODE(t) != TYPE_CODE_UNION
- && TYPE_CODE(t) != TYPE_CODE_ARRAY);
+ return (t->code () != TYPE_CODE_STRUCT
+ && t->code () != TYPE_CODE_UNION
+ && t->code () != TYPE_CODE_ARRAY);
}
/* Function: xstormy16_use_struct_convention
xstormy16_use_struct_convention (struct type *type)
{
return !xstormy16_type_is_scalar (type)
- || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
+ || type->length () > E_MAX_RETTYPE_SIZE_IN_REGS;
}
/* Function: xstormy16_extract_return_value
xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
gdb_byte *valbuf)
{
- int len = TYPE_LENGTH (type);
+ int len = type->length ();
int i, regnum = E_1ST_ARG_REGNUM;
for (i = 0; i < len; i += xstormy16_reg_size)
- regcache_raw_read (regcache, regnum++, valbuf + i);
+ regcache->raw_read (regnum++, valbuf + i);
}
/* Function: xstormy16_store_return_value
xstormy16_store_return_value (struct type *type, struct regcache *regcache,
const gdb_byte *valbuf)
{
- if (TYPE_LENGTH (type) == 1)
+ if (type->length () == 1)
{
/* Add leading zeros to the value. */
gdb_byte buf[xstormy16_reg_size];
memset (buf, 0, xstormy16_reg_size);
memcpy (buf, valbuf, 1);
- regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf);
+ regcache->raw_write (E_1ST_ARG_REGNUM, buf);
}
else
{
- int len = TYPE_LENGTH (type);
+ int len = type->length ();
int i, regnum = E_1ST_ARG_REGNUM;
for (i = 0; i < len; i += xstormy16_reg_size)
- regcache_raw_write (regcache, regnum++, valbuf + i);
+ regcache->raw_write (regnum++, valbuf + i);
}
}
struct regcache *regcache,
CORE_ADDR bp_addr, int nargs,
struct value **args,
- CORE_ADDR sp, int struct_return,
+ CORE_ADDR sp,
+ function_call_return_method return_method,
CORE_ADDR struct_addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int argreg = E_1ST_ARG_REGNUM;
int i, j;
int typelen, slacklen;
- const gdb_byte *val;
gdb_byte buf[xstormy16_pc_size];
- /* If struct_return is true, then the struct return address will
- consume one argument-passing register. */
- if (struct_return)
+ /* If returning a struct using target ABI method, then the struct return
+ address will consume one argument-passing register. */
+ if (return_method == return_method_struct)
{
regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
argreg++;
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 = value_enclosing_type (args[i])->length ();
if (typelen > E_MAX_RETTYPE_SIZE (argreg))
break;
/* Put argument into registers wordwise. */
- val = value_contents (args[i]);
+ const gdb_byte *val = value_contents (args[i]).data ();
for (j = 0; j < typelen; j += xstormy16_reg_size)
{
ULONGEST regval;
wordaligned. */
for (j = nargs - 1; j >= i; j--)
{
- const gdb_byte *bytes = value_contents (args[j]);
+ const gdb_byte *bytes = value_contents (args[j]).data ();
- typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
+ typelen = value_enclosing_type (args[j])->length ();
slacklen = typelen & 1;
gdb::byte_vector val (typelen + slacklen);
memcpy (val.data (), bytes, typelen);
xstormy16_analyze_prologue (struct gdbarch *gdbarch,
CORE_ADDR start_addr, CORE_ADDR end_addr,
struct xstormy16_frame_cache *cache,
- struct frame_info *this_frame)
+ frame_info_ptr this_frame)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR next_addr;
plg_end = xstormy16_analyze_prologue (gdbarch, func_addr, func_end,
&cache, NULL);
if (!cache.uses_fp)
- return plg_end;
+ return plg_end;
/* Found a function. */
sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
/* Don't use line number debug info for assembly source files. */
- if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
+ if (sym && sym->language () != language_asm)
{
sal = find_pc_line (func_addr, 0);
if (sal.end && sal.end < func_end)
return 0;
/* Check if we're on a `ret' instruction. Otherwise it's
- too dangerous to proceed. */
+ too dangerous to proceed. */
inst = read_memory_unsigned_integer (addr,
xstormy16_inst_size, byte_order);
if (inst != 0x0003)
{
CORE_ADDR addr, endaddr;
- addr = obj_section_addr (osect);
- endaddr = obj_section_endaddr (osect);
+ addr = osect->addr ();
+ endaddr = osect->endaddr ();
for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
{
xstormy16_inst_size,
byte_order);
inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
- xstormy16_inst_size,
+ xstormy16_inst_size,
byte_order);
faddr2 = inst2 << 8 | (inst & 0xff);
if (faddr == faddr2)
}
static CORE_ADDR
-xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
+xstormy16_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
struct type *type, const gdb_byte *buf)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
+ enum type_code target = type->target_type ()->code ();
CORE_ADDR addr
- = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
+ = extract_unsigned_integer (buf, type->length (), byte_order);
if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
{
struct type *type, gdb_byte *buf, CORE_ADDR addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
+ enum type_code target = type->target_type ()->code ();
if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
{
if (addr2)
addr = addr2;
}
- store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
+ store_unsigned_integer (buf, type->length (), byte_order, addr);
}
static struct xstormy16_frame_cache *
}
static struct xstormy16_frame_cache *
-xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
+xstormy16_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct xstormy16_frame_cache *cache;
}
static struct value *
-xstormy16_frame_prev_register (struct frame_info *this_frame,
+xstormy16_frame_prev_register (frame_info_ptr this_frame,
void **this_cache, int regnum)
{
struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
- this_cache);
+ this_cache);
gdb_assert (regnum >= 0);
if (regnum == E_SP_REGNUM && cache->saved_sp)
}
static void
-xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
+xstormy16_frame_this_id (frame_info_ptr this_frame, void **this_cache,
struct frame_id *this_id)
{
struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
}
static CORE_ADDR
-xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
+xstormy16_frame_base_address (frame_info_ptr this_frame, void **this_cache)
{
struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
this_cache);
}
static const struct frame_unwind xstormy16_frame_unwind = {
+ "xstormy16 prologue",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
xstormy16_frame_this_id,
xstormy16_frame_base_address
};
-static CORE_ADDR
-xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
- return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
-}
-
-static CORE_ADDR
-xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
- return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
-}
-
-static struct frame_id
-xstormy16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
-{
- CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
- return frame_id_build (sp, get_frame_pc (this_frame));
-}
-
-
/* Function: xstormy16_gdbarch_init
Initializer function for the xstormy16 gdbarch vector.
Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
/*
* Frame Info
*/
- set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp);
- set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc);
- set_gdbarch_dummy_id (gdbarch, xstormy16_dummy_id);
set_gdbarch_frame_align (gdbarch, xstormy16_frame_align);
frame_base_set_default (gdbarch, &xstormy16_frame_base);
Initializer function for the Sanyo Xstormy16a module.
Called by gdb at start-up. */
+void _initialize_xstormy16_tdep ();
void
-_initialize_xstormy16_tdep (void)
+_initialize_xstormy16_tdep ()
{
- register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
+ gdbarch_register (bfd_arch_xstormy16, xstormy16_gdbarch_init);
}
projects / thirdparty / binutils-gdb.git / blobdiff