/* Target-machine dependent code for Renesas H8/300, for GDB.
- Copyright (C) 1988-2016 Free Software Foundation, Inc.
+ Copyright (C) 1988-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcore.h"
#include "objfiles.h"
#include "dis-asm.h"
-#include "dwarf2-frame.h"
+#include "dwarf2/frame.h"
#include "frame-base.h"
#include "frame-unwind.h"
&& !is_h8300_normal_mode (gdbarch)) \
? h8300h_reg_size : h8300_reg_size)
-static CORE_ADDR
-h8300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
- return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
-}
-
-static CORE_ADDR
-h8300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
- return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
-}
-
-static struct frame_id
-h8300_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));
-}
-
/* Normal frames. */
/* Allocate and initialize a frame cache. */
if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc + 2,
2, byte_order)))
{
- LONGEST disp = read_memory_integer (pc + 4, 4, byte_order);
+ ULONGEST disp = read_memory_unsigned_integer (pc + 4, 4, byte_order);
/* ... and d:24 is negative. */
- if (disp < 0 && disp > 0xffffff)
+ if ((disp & 0x00800000) != 0)
return 8;
}
}
if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc + 2,
2, byte_order)))
{
- LONGEST disp = read_memory_integer (pc + 4, 4, byte_order);
+ ULONGEST disp = read_memory_unsigned_integer (pc + 4, 4, byte_order);
/* ... and d:24 is negative. */
- if (disp < 0 && disp > 0xffffff)
+ if ((disp & 0x00800000) != 0)
return 8;
}
}
}
else if (IS_MOVL_EXT (w2))
{
- int w3 = read_memory_integer (pc + 4, 2, byte_order);
-
if (IS_MOVL_Rn24_SP (read_memory_integer (pc + 4, 2, byte_order)))
{
- LONGEST disp = read_memory_integer (pc + 6, 4, byte_order);
+ ULONGEST disp = read_memory_unsigned_integer (pc + 6, 4,
+ byte_order);
/* ... and d:24 is negative. */
- if (disp < 0 && disp > 0xffffff)
+ if ((disp & 0x00800000) != 0)
return 10;
}
}
h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
struct regcache *regcache, CORE_ADDR bp_addr,
int nargs, struct value **args, CORE_ADDR sp,
- int struct_return, CORE_ADDR struct_addr)
+ function_call_return_method return_method,
+ CORE_ADDR struct_addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int stack_alloc = 0, stack_offset = 0;
If we're returning a structure by value, then we must pass a
pointer to the buffer for the return value as an invisible first
argument. */
- if (struct_return)
+ if (return_method == return_method_struct)
regcache_cooked_write_unsigned (regcache, reg++, struct_addr);
for (argument = 0; argument < nargs; argument++)
{
- struct cleanup *back_to;
struct type *type = value_type (args[argument]);
int len = TYPE_LENGTH (type);
char *contents = (char *) value_contents (args[argument]);
/* Pad the argument appropriately. */
int padded_len = align_up (len, wordsize);
- gdb_byte *padded = (gdb_byte *) xmalloc (padded_len);
- back_to = make_cleanup (xfree, padded);
+ /* Use std::vector here to get zero initialization. */
+ std::vector<gdb_byte> padded (padded_len);
- memset (padded, 0, padded_len);
- memcpy (len < wordsize ? padded + padded_len - len : padded,
+ memcpy ((len < wordsize ? padded.data () + padded_len - len
+ : padded.data ()),
contents, len);
/* Could the argument fit in the remaining registers? */
if (len > wordsize && len % wordsize)
{
/* I feel so unclean. */
- write_memory (sp + stack_offset, padded, padded_len);
+ write_memory (sp + stack_offset, padded.data (), padded_len);
stack_offset += padded_len;
/* That's right --- even though we passed the argument
for (offset = 0; offset < padded_len; offset += wordsize)
{
ULONGEST word
- = extract_unsigned_integer (padded + offset,
+ = extract_unsigned_integer (&padded[offset],
wordsize, byte_order);
regcache_cooked_write_unsigned (regcache, reg++, word);
}
else
{
/* It doesn't fit in registers! Onto the stack it goes. */
- write_memory (sp + stack_offset, padded, padded_len);
+ write_memory (sp + stack_offset, padded.data (), padded_len);
stack_offset += padded_len;
/* Once one argument has spilled onto the stack, all
subsequent arguments go on the stack. */
reg = E_ARGLAST_REGNUM + 1;
}
-
- do_cleanups (back_to);
}
/* Store return address. */
h8300_extract_return_value (struct type *type, struct regcache *regcache,
gdb_byte *valbuf)
{
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch *gdbarch = regcache->arch ();
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int len = TYPE_LENGTH (type);
ULONGEST c, addr;
store_unsigned_integer (valbuf + 2, 2, byte_order, c);
break;
case 8: /* long long is now 8 bytes. */
- if (TYPE_CODE (type) == TYPE_CODE_INT)
+ if (type->code () == TYPE_CODE_INT)
{
regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &addr);
c = read_memory_unsigned_integer ((CORE_ADDR) addr, len, byte_order);
h8300h_extract_return_value (struct type *type, struct regcache *regcache,
gdb_byte *valbuf)
{
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch *gdbarch = regcache->arch ();
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST c;
store_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order, c);
break;
case 8: /* long long is now 8 bytes. */
- if (TYPE_CODE (type) == TYPE_CODE_INT)
+ if (type->code () == TYPE_CODE_INT)
{
regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
store_unsigned_integer (valbuf, 4, byte_order, c);
/* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
stack. */
- if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
- || TYPE_CODE (value_type) == TYPE_CODE_UNION)
+ if (value_type->code () == TYPE_CODE_STRUCT
+ || value_type->code () == TYPE_CODE_UNION)
return 1;
return !(TYPE_LENGTH (value_type) == 1
|| TYPE_LENGTH (value_type) == 2
{
/* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
returned in R0/R1, everything else on the stack. */
- if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
- || TYPE_CODE (value_type) == TYPE_CODE_UNION)
+ if (value_type->code () == TYPE_CODE_STRUCT
+ || value_type->code () == TYPE_CODE_UNION)
return 1;
return !(TYPE_LENGTH (value_type) == 1
|| TYPE_LENGTH (value_type) == 2
|| TYPE_LENGTH (value_type) == 4
|| (TYPE_LENGTH (value_type) == 8
- && TYPE_CODE (value_type) == TYPE_CODE_INT));
+ && value_type->code () == TYPE_CODE_INT));
}
/* Function: store_return_value
h8300_store_return_value (struct type *type, struct regcache *regcache,
const gdb_byte *valbuf)
{
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch *gdbarch = regcache->arch ();
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST val;
h8300h_store_return_value (struct type *type, struct regcache *regcache,
const gdb_byte *valbuf)
{
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch *gdbarch = regcache->arch ();
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST val;
return regnum;
}
+static const char *
+h8300_register_name_common (const char *regnames[], int numregs,
+ struct gdbarch *gdbarch, int regno)
+{
+ if (regno < 0
+ || regno >= numregs)
+ internal_error (__FILE__, __LINE__,
+ _("h8300_register_name_common: illegal register number %d"),
+ regno);
+ else
+ return regnames[regno];
+}
+
static const char *
h8300_register_name (struct gdbarch *gdbarch, int regno)
{
/* The register names change depending on which h8300 processor
type is selected. */
- static char *register_names[] = {
+ static const char *register_names[] = {
"r0", "r1", "r2", "r3", "r4", "r5", "r6",
"sp", "", "pc", "cycles", "tick", "inst",
"ccr", /* pseudo register */
};
- if (regno < 0
- || regno >= (sizeof (register_names) / sizeof (*register_names)))
- internal_error (__FILE__, __LINE__,
- _("h8300_register_name: illegal register number %d"),
- regno);
- else
- return register_names[regno];
+ return h8300_register_name_common(register_names, ARRAY_SIZE(register_names),
+ gdbarch, regno);
+}
+
+static const char *
+h8300h_register_name (struct gdbarch *gdbarch, int regno)
+{
+ static const char *register_names[] = {
+ "er0", "er1", "er2", "er3", "er4", "er5", "er6",
+ "sp", "", "pc", "cycles", "tick", "inst",
+ "ccr", /* pseudo register */
+ };
+ return h8300_register_name_common(register_names, ARRAY_SIZE(register_names),
+ gdbarch, regno);
}
static const char *
h8300s_register_name (struct gdbarch *gdbarch, int regno)
{
- static char *register_names[] = {
+ static const char *register_names[] = {
"er0", "er1", "er2", "er3", "er4", "er5", "er6",
"sp", "", "pc", "cycles", "", "tick", "inst",
"mach", "macl",
"ccr", "exr" /* pseudo registers */
};
- if (regno < 0
- || regno >= (sizeof (register_names) / sizeof (*register_names)))
- internal_error (__FILE__, __LINE__,
- _("h8300s_register_name: illegal register number %d"),
- regno);
- else
- return register_names[regno];
+ return h8300_register_name_common(register_names, ARRAY_SIZE(register_names),
+ gdbarch, regno);
}
static const char *
h8300sx_register_name (struct gdbarch *gdbarch, int regno)
{
- static char *register_names[] = {
+ static const char *register_names[] = {
"er0", "er1", "er2", "er3", "er4", "er5", "er6",
"sp", "", "pc", "cycles", "", "tick", "inst",
"mach", "macl", "sbr", "vbr",
"ccr", "exr" /* pseudo registers */
};
- if (regno < 0
- || regno >= (sizeof (register_names) / sizeof (*register_names)))
- internal_error (__FILE__, __LINE__,
- _("h8300sx_register_name: illegal register number %d"),
- regno);
- else
- return register_names[regno];
+ return h8300_register_name_common(register_names, ARRAY_SIZE(register_names),
+ gdbarch, regno);
}
static void
fprintf_filtered (file, "u> ");
if ((C | Z) == 1)
fprintf_filtered (file, "u<= ");
- if ((C == 0))
+ if (C == 0)
fprintf_filtered (file, "u>= ");
if (C == 1)
fprintf_filtered (file, "u< ");
static struct type *
h8300_register_type (struct gdbarch *gdbarch, int regno)
{
- if (regno < 0 || regno >= gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch))
+ if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch))
internal_error (__FILE__, __LINE__,
_("h8300_register_type: illegal register number %d"),
regno);
raw registers. These helpers extend/narrow the values. */
static enum register_status
-pseudo_from_raw_register (struct gdbarch *gdbarch, struct regcache *regcache,
+pseudo_from_raw_register (struct gdbarch *gdbarch, readable_regcache *regcache,
gdb_byte *buf, int pseudo_regno, int raw_regno)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
enum register_status status;
ULONGEST val;
- status = regcache_raw_read_unsigned (regcache, raw_regno, &val);
+ status = regcache->raw_read (raw_regno, &val);
if (status == REG_VALID)
store_unsigned_integer (buf,
register_size (gdbarch, pseudo_regno),
static enum register_status
h8300_pseudo_register_read (struct gdbarch *gdbarch,
- struct regcache *regcache, int regno,
+ readable_regcache *regcache, int regno,
gdb_byte *buf)
{
if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
regno, E_EXR_REGNUM);
}
else
- return regcache_raw_read (regcache, regno, buf);
+ return regcache->raw_read (regno, buf);
}
static void
else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch))
raw_from_pseudo_register (gdbarch, regcache, buf, E_EXR_REGNUM, regno);
else
- regcache_raw_write (regcache, regno, buf);
+ regcache->raw_write (regno, buf);
}
static int
return regno;
}
-static const unsigned char *
-h8300_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
- int *lenptr)
-{
- /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
- static unsigned char breakpoint[] = { 0x01, 0x80 }; /* Sleep */
+/*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
+constexpr gdb_byte h8300_break_insn[] = { 0x01, 0x80 }; /* Sleep */
- *lenptr = sizeof (breakpoint);
- return breakpoint;
-}
+typedef BP_MANIPULATION (h8300_break_insn) h8300_breakpoint;
static struct gdbarch *
h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
- struct gdbarch_tdep *tdep = NULL;
struct gdbarch *gdbarch;
arches = gdbarch_list_lookup_by_info (arches, &info);
if (arches != NULL)
return arches->gdbarch;
-#if 0
- tdep = XNEW (struct gdbarch_tdep);
-#endif
-
if (info.bfd_arch_info->arch != bfd_arch_h8300)
return NULL;
case bfd_mach_h8300:
set_gdbarch_num_regs (gdbarch, 13);
set_gdbarch_num_pseudo_regs (gdbarch, 1);
- set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
set_gdbarch_register_name (gdbarch, h8300_register_name);
set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_return_value (gdbarch, h8300_return_value);
- set_gdbarch_print_insn (gdbarch, print_insn_h8300);
break;
case bfd_mach_h8300h:
case bfd_mach_h8300hn:
set_gdbarch_num_regs (gdbarch, 13);
set_gdbarch_num_pseudo_regs (gdbarch, 1);
- set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
- set_gdbarch_register_name (gdbarch, h8300_register_name);
+ set_gdbarch_register_name (gdbarch, h8300h_register_name);
if (info.bfd_arch_info->mach != bfd_mach_h8300hn)
{
set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
}
set_gdbarch_return_value (gdbarch, h8300h_return_value);
- set_gdbarch_print_insn (gdbarch, print_insn_h8300h);
break;
case bfd_mach_h8300s:
case bfd_mach_h8300sn:
set_gdbarch_num_regs (gdbarch, 16);
set_gdbarch_num_pseudo_regs (gdbarch, 2);
- set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
set_gdbarch_register_name (gdbarch, h8300s_register_name);
set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
}
set_gdbarch_return_value (gdbarch, h8300h_return_value);
- set_gdbarch_print_insn (gdbarch, print_insn_h8300s);
break;
case bfd_mach_h8300sx:
case bfd_mach_h8300sxn:
set_gdbarch_num_regs (gdbarch, 18);
set_gdbarch_num_pseudo_regs (gdbarch, 2);
- set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
set_gdbarch_register_name (gdbarch, h8300sx_register_name);
set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
}
set_gdbarch_return_value (gdbarch, h8300h_return_value);
- set_gdbarch_print_insn (gdbarch, print_insn_h8300s);
break;
}
set_gdbarch_skip_prologue (gdbarch, h8300_skip_prologue);
/* Frame unwinder. */
- set_gdbarch_unwind_pc (gdbarch, h8300_unwind_pc);
- set_gdbarch_unwind_sp (gdbarch, h8300_unwind_sp);
- set_gdbarch_dummy_id (gdbarch, h8300_dummy_id);
frame_base_set_default (gdbarch, &h8300_frame_base);
/*
- * Miscelany
+ * Miscellany
*/
/* Stack grows up. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
- set_gdbarch_breakpoint_from_pc (gdbarch, h8300_breakpoint_from_pc);
+ set_gdbarch_breakpoint_kind_from_pc (gdbarch,
+ h8300_breakpoint::kind_from_pc);
+ set_gdbarch_sw_breakpoint_from_kind (gdbarch,
+ h8300_breakpoint::bp_from_kind);
set_gdbarch_push_dummy_call (gdbarch, h8300_push_dummy_call);
set_gdbarch_char_signed (gdbarch, 0);
set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
+
+ set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+ set_gdbarch_wchar_signed (gdbarch, 0);
+
set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_double_format (gdbarch, floatformats_ieee_single);
set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
}
-extern initialize_file_ftype _initialize_h8300_tdep; /* -Wmissing-prototypes */
-
+void _initialize_h8300_tdep ();
void
-_initialize_h8300_tdep (void)
+_initialize_h8300_tdep ()
{
register_gdbarch_init (bfd_arch_h8300, h8300_gdbarch_init);
}
projects / deliverable / binutils-gdb.git / blobdiff