/* Target-dependent code for the Renesas RX for GDB, the GNU debugger.
- Copyright (C) 2008-2020 Free Software Foundation, Inc.
+ Copyright (C) 2008-2022 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
#include "dwarf2/frame.h"
#include "remote.h"
#include "target-descriptions.h"
+#include "gdbarch.h"
#include "elf/rx.h"
#include "elf-bfd.h"
};
/* Architecture specific data. */
-struct gdbarch_tdep
+struct rx_gdbarch_tdep : gdbarch_tdep
{
/* The ELF header flags specify the multilib used. */
- int elf_flags;
+ int elf_flags = 0;
/* Type of PSW and BPSW. */
- struct type *rx_psw_type;
+ struct type *rx_psw_type = nullptr;
/* Type of FPSW. */
- struct type *rx_fpsw_type;
+ struct type *rx_fpsw_type = nullptr;
};
/* This structure holds the results of a prologue analysis. */
static void
rx_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
- enum rx_frame_type frame_type,
+ enum rx_frame_type frame_type,
struct rx_prologue *result)
{
CORE_ADDR pc, next_pc;
if (frame_type == RX_FRAME_TYPE_FAST_INTERRUPT)
{
/* This code won't do anything useful at present, but this is
- what happens for fast interrupts. */
+ what happens for fast interrupts. */
reg[RX_BPSW_REGNUM] = reg[RX_PSW_REGNUM];
reg[RX_BPC_REGNUM] = reg[RX_PC_REGNUM];
}
else
{
/* When an exception occurs, the PSW is saved to the interrupt stack
- first. */
+ first. */
if (frame_type == RX_FRAME_TYPE_EXCEPTION)
{
reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4);
}
/* The call instruction (or an exception/interrupt) has saved the return
- address on the stack. */
+ address on the stack. */
reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4);
stack.store (reg[RX_SP_REGNUM], 4, reg[RX_PC_REGNUM]);
stop_addr = get_frame_pc (this_frame);
/* If we couldn't find any function containing the PC, then
- just initialize the prologue cache, but don't do anything. */
+ just initialize the prologue cache, but don't do anything. */
if (!func_start)
stop_addr = func_start;
else if (opc.id == RXO_rtfi)
return RX_FRAME_TYPE_FAST_INTERRUPT;
else if (opc.id == RXO_rte)
- return RX_FRAME_TYPE_EXCEPTION;
+ return RX_FRAME_TYPE_EXCEPTION;
pc += bytes_read;
}
static void
rx_frame_this_id (struct frame_info *this_frame, void **this_cache,
- struct frame_id *this_id)
+ struct frame_id *this_id)
{
*this_id = frame_id_build (rx_frame_base (this_frame, this_cache),
get_frame_func (this_frame));
static struct value *
rx_frame_prev_register (struct frame_info *this_frame, void **this_cache,
- int regnum)
+ int regnum)
{
enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache);
struct rx_prologue *p
if (regnum == RX_SP_REGNUM)
{
if (frame_type == RX_FRAME_TYPE_EXCEPTION)
- {
+ {
struct value *psw_val;
CORE_ADDR psw;
psw_val = rx_frame_prev_register (this_frame, this_cache,
- RX_PSW_REGNUM);
- psw = extract_unsigned_integer (value_contents_all (psw_val), 4,
- gdbarch_byte_order (
- get_frame_arch (this_frame)));
+ RX_PSW_REGNUM);
+ psw = extract_unsigned_integer
+ (value_contents_all (psw_val).data (), 4,
+ gdbarch_byte_order (get_frame_arch (this_frame)));
if ((psw & 0x20000 /* U bit */) != 0)
return rx_frame_prev_register (this_frame, this_cache,
- RX_USP_REGNUM);
+ RX_USP_REGNUM);
- /* Fall through for the case where U bit is zero. */
+ /* Fall through for the case where U bit is zero. */
}
return frame_unwind_got_constant (this_frame, regnum, frame_base);
if (frame_type == RX_FRAME_TYPE_FAST_INTERRUPT)
{
if (regnum == RX_PC_REGNUM)
- return rx_frame_prev_register (this_frame, this_cache,
- RX_BPC_REGNUM);
+ return rx_frame_prev_register (this_frame, this_cache,
+ RX_BPC_REGNUM);
if (regnum == RX_PSW_REGNUM)
- return rx_frame_prev_register (this_frame, this_cache,
- RX_BPSW_REGNUM);
+ return rx_frame_prev_register (this_frame, this_cache,
+ RX_BPSW_REGNUM);
}
/* If prologue analysis says we saved this register somewhere,
exception_frame_p (enum rx_frame_type frame_type)
{
return (frame_type == RX_FRAME_TYPE_EXCEPTION
- || frame_type == RX_FRAME_TYPE_FAST_INTERRUPT);
+ || frame_type == RX_FRAME_TYPE_FAST_INTERRUPT);
}
/* Common code used by both normal and exception frame sniffers. */
static int
rx_frame_sniffer_common (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ struct frame_info *this_frame,
void **this_cache,
int (*sniff_p)(enum rx_frame_type) )
{
enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache);
if (sniff_p (frame_type))
- {
+ {
/* The call below will fill in the cache, including the frame
type. */
(void) rx_analyze_frame_prologue (this_frame, frame_type, this_cache);
return 1;
- }
+ }
else
- return 0;
+ return 0;
}
else
{
static int
rx_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ struct frame_info *this_frame,
void **this_cache)
{
return rx_frame_sniffer_common (self, this_frame, this_cache,
- normal_frame_p);
+ normal_frame_p);
}
/* Frame sniffer for exception frames. */
static int
rx_exception_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ struct frame_info *this_frame,
void **this_cache)
{
return rx_frame_sniffer_common (self, this_frame, this_cache,
- exception_frame_p);
+ exception_frame_p);
}
/* Data structure for normal code using instruction-based prologue
analyzer. */
static const struct frame_unwind rx_frame_unwind = {
+ "rx prologue",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
rx_frame_this_id,
analyzer. */
static const struct frame_unwind rx_exception_unwind = {
+ "rx exception",
/* SIGTRAMP_FRAME could be used here, but backtraces are less informative. */
NORMAL_FRAME,
default_frame_unwind_stop_reason,
for (i = 0; i < nargs; i++)
{
struct value *arg = args[i];
- const gdb_byte *arg_bits = value_contents_all (arg);
+ const gdb_byte *arg_bits = value_contents_all (arg).data ();
struct type *arg_type = check_typedef (value_type (arg));
ULONGEST arg_size = TYPE_LENGTH (arg_type);
byte_order) == struct_addr)
{
/* This argument represents the address at which C++ (and
- possibly other languages) store their return value.
- Put this value in R15. */
+ possibly other languages) store their return value.
+ Put this value in R15. */
if (write_pass)
regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM,
struct_addr);
&& arg_reg <= RX_R4_REGNUM - 1)
{
/* If argument registers are going to be used to pass
- an 8 byte scalar, the ABI specifies that two registers
- must be available. */
+ an 8 byte scalar, the ABI specifies that two registers
+ must be available. */
if (write_pass)
{
regcache_cooked_write_unsigned (regcache, arg_reg,
else
{
/* Argument is a struct or union. Pass as much of the struct
- in registers, if possible. Pass the rest on the stack. */
+ in registers, if possible. Pass the rest on the stack. */
while (arg_size > 0)
{
if (i < num_register_candidate_args
rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
struct gdbarch *gdbarch;
- struct gdbarch_tdep *tdep;
int elf_flags;
- struct tdesc_arch_data *tdesc_data = NULL;
+ tdesc_arch_data_up tdesc_data;
const struct target_desc *tdesc = info.target_desc;
/* Extract the elf_flags if available. */
arches != NULL;
arches = gdbarch_list_lookup_by_info (arches->next, &info))
{
- if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
+ rx_gdbarch_tdep *tdep
+ = (rx_gdbarch_tdep *) gdbarch_tdep (arches->gdbarch);
+
+ if (tdep->elf_flags != elf_flags)
continue;
return arches->gdbarch;
{
tdesc_data = tdesc_data_alloc ();
for (int i = 0; i < RX_NUM_REGS; i++)
- valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
- rx_register_names[i]);
+ valid_p &= tdesc_numbered_register (feature, tdesc_data.get (), i,
+ rx_register_names[i]);
}
if (!valid_p)
- {
- tdesc_data_cleanup (tdesc_data);
- return NULL;
- }
+ return NULL;
}
gdb_assert(tdesc_data != NULL);
- tdep = XCNEW (struct gdbarch_tdep);
+ rx_gdbarch_tdep *tdep = new rx_gdbarch_tdep;
gdbarch = gdbarch_alloc (&info, tdep);
tdep->elf_flags = elf_flags;
set_gdbarch_num_regs (gdbarch, RX_NUM_REGS);
- tdesc_use_registers (gdbarch, tdesc, tdesc_data);
+ tdesc_use_registers (gdbarch, tdesc, std::move (tdesc_data));
set_gdbarch_num_pseudo_regs (gdbarch, 0);
set_gdbarch_pc_regnum (gdbarch, RX_PC_REGNUM);
projects / binutils-gdb.git / blobdiff