/* Renesas M32C target-dependent code for GDB, the GNU debugger.
- Copyright (C) 2004-2016 Free Software Foundation, Inc.
+ Copyright (C) 2004-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "arch-utils.h"
#include "frame.h"
#include "frame-unwind.h"
-#include "dwarf2-frame.h"
-#include "dwarf2expr.h"
+#include "dwarf2/frame.h"
+#include "dwarf2/expr.h"
#include "symtab.h"
#include "gdbcore.h"
#include "value.h"
const gdb_byte *buf);
typedef enum register_status (m32c_read_reg_t) (struct m32c_reg *reg,
- struct regcache *cache,
+ readable_regcache *cache,
gdb_byte *buf);
struct m32c_reg
/* The builtin_type_mumble variables are sometimes uninitialized when
this is called, so we avoid using them. */
- tdep->voyd = arch_type (arch, TYPE_CODE_VOID, 1, "void");
+ tdep->voyd = arch_type (arch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
tdep->ptr_voyd
= arch_pointer_type (arch, gdbarch_ptr_bit (arch), NULL, tdep->voyd);
tdep->func_voyd = lookup_function_type (tdep->voyd);
/* Copy the value of the raw register REG from CACHE to BUF. */
static enum register_status
-m32c_raw_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf)
+m32c_raw_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
- return regcache_raw_read (cache, reg->num, buf);
+ return cache->raw_read (reg->num, buf);
}
m32c_raw_write (struct m32c_reg *reg, struct regcache *cache,
const gdb_byte *buf)
{
- regcache_raw_write (cache, reg->num, buf);
+ cache->raw_write (reg->num, buf);
return REG_VALID;
}
/* Return the value of the 'flg' register in CACHE. */
static int
-m32c_read_flg (struct regcache *cache)
+m32c_read_flg (readable_regcache *cache)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (cache));
+ struct gdbarch_tdep *tdep = gdbarch_tdep (cache->arch ());
ULONGEST flg;
- regcache_raw_read_unsigned (cache, tdep->flg->num, &flg);
+
+ cache->raw_read (tdep->flg->num, &flg);
return flg & 0xffff;
}
/* Evaluate the real register number of a banked register. */
static struct m32c_reg *
-m32c_banked_register (struct m32c_reg *reg, struct regcache *cache)
+m32c_banked_register (struct m32c_reg *reg, readable_regcache *cache)
{
return ((m32c_read_flg (cache) & reg->n) ? reg->ry : reg->rx);
}
masked in REG->n set, then read REG->ry. Otherwise, read
REG->rx. */
static enum register_status
-m32c_banked_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf)
+m32c_banked_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
struct m32c_reg *bank_reg = m32c_banked_register (reg, cache);
- return regcache_raw_read (cache, bank_reg->num, buf);
+ return cache->raw_read (bank_reg->num, buf);
}
const gdb_byte *buf)
{
struct m32c_reg *bank_reg = m32c_banked_register (reg, cache);
- regcache_raw_write (cache, bank_reg->num, buf);
+ cache->raw_write (bank_reg->num, buf);
return REG_VALID;
}
/* Move the value of SB from CACHE to BUF. On bfd_mach_m32c, SB is a
banked register; on bfd_mach_m16c, it's not. */
static enum register_status
-m32c_sb_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf)
+m32c_sb_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
if (gdbarch_bfd_arch_info (reg->arch)->mach == bfd_mach_m16c)
return m32c_raw_read (reg->rx, cache, buf);
REG->type values, where higher indices refer to more significant
bits, read the value of the REG->n'th element. */
static enum register_status
-m32c_part_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf)
+m32c_part_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
int offset, len;
memset (buf, 0, TYPE_LENGTH (reg->type));
m32c_find_part (reg, &offset, &len);
- return regcache_cooked_read_part (cache, reg->rx->num, offset, len, buf);
+ return cache->cooked_read_part (reg->rx->num, offset, len, buf);
}
int offset, len;
m32c_find_part (reg, &offset, &len);
- regcache_cooked_write_part (cache, reg->rx->num, offset, len, buf);
+ cache->cooked_write_part (reg->rx->num, offset, len, buf);
return REG_VALID;
}
concatenation of the values of the registers REG->rx and REG->ry,
with REG->rx contributing the more significant bits. */
static enum register_status
-m32c_cat_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf)
+m32c_cat_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
int high_bytes = TYPE_LENGTH (reg->rx->type);
int low_bytes = TYPE_LENGTH (reg->ry->type);
if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
{
- status = regcache_cooked_read (cache, reg->rx->num, buf);
+ status = cache->cooked_read (reg->rx->num, buf);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, reg->ry->num, buf + high_bytes);
+ status = cache->cooked_read (reg->ry->num, buf + high_bytes);
}
else
{
- status = regcache_cooked_read (cache, reg->rx->num, buf + low_bytes);
+ status = cache->cooked_read (reg->rx->num, buf + low_bytes);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, reg->ry->num, buf);
+ status = cache->cooked_read (reg->ry->num, buf);
}
-
return status;
}
if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
{
- regcache_cooked_write (cache, reg->rx->num, buf);
- regcache_cooked_write (cache, reg->ry->num, buf + high_bytes);
+ cache->cooked_write (reg->rx->num, buf);
+ cache->cooked_write (reg->ry->num, buf + high_bytes);
}
else
{
- regcache_cooked_write (cache, reg->rx->num, buf + low_bytes);
- regcache_cooked_write (cache, reg->ry->num, buf);
+ cache->cooked_write (reg->rx->num, buf + low_bytes);
+ cache->cooked_write (reg->ry->num, buf);
}
return REG_VALID;
the concatenation (from most significant to least) of r3, r2, r1,
and r0. */
static enum register_status
-m32c_r3r2r1r0_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf)
+m32c_r3r2r1r0_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch);
int len = TYPE_LENGTH (tdep->r0->type);
if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
{
- status = regcache_cooked_read (cache, tdep->r0->num, buf + len * 3);
+ status = cache->cooked_read (tdep->r0->num, buf + len * 3);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r1->num, buf + len * 2);
+ status = cache->cooked_read (tdep->r1->num, buf + len * 2);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r2->num, buf + len * 1);
+ status = cache->cooked_read (tdep->r2->num, buf + len * 1);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r3->num, buf);
+ status = cache->cooked_read (tdep->r3->num, buf);
}
else
{
- status = regcache_cooked_read (cache, tdep->r0->num, buf);
+ status = cache->cooked_read (tdep->r0->num, buf);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r1->num, buf + len * 1);
+ status = cache->cooked_read (tdep->r1->num, buf + len * 1);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r2->num, buf + len * 2);
+ status = cache->cooked_read (tdep->r2->num, buf + len * 2);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r3->num, buf + len * 3);
+ status = cache->cooked_read (tdep->r3->num, buf + len * 3);
}
return status;
if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
{
- regcache_cooked_write (cache, tdep->r0->num, buf + len * 3);
- regcache_cooked_write (cache, tdep->r1->num, buf + len * 2);
- regcache_cooked_write (cache, tdep->r2->num, buf + len * 1);
- regcache_cooked_write (cache, tdep->r3->num, buf);
+ cache->cooked_write (tdep->r0->num, buf + len * 3);
+ cache->cooked_write (tdep->r1->num, buf + len * 2);
+ cache->cooked_write (tdep->r2->num, buf + len * 1);
+ cache->cooked_write (tdep->r3->num, buf);
}
else
{
- regcache_cooked_write (cache, tdep->r0->num, buf);
- regcache_cooked_write (cache, tdep->r1->num, buf + len * 1);
- regcache_cooked_write (cache, tdep->r2->num, buf + len * 2);
- regcache_cooked_write (cache, tdep->r3->num, buf + len * 3);
+ cache->cooked_write (tdep->r0->num, buf);
+ cache->cooked_write (tdep->r1->num, buf + len * 1);
+ cache->cooked_write (tdep->r2->num, buf + len * 2);
+ cache->cooked_write (tdep->r3->num, buf + len * 3);
}
return REG_VALID;
static enum register_status
m32c_pseudo_register_read (struct gdbarch *arch,
- struct regcache *cache,
+ readable_regcache *cache,
int cookednum,
gdb_byte *buf)
{
struct m32c_reg *reg;
gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
- gdb_assert (arch == get_regcache_arch (cache));
+ gdb_assert (arch == cache->arch ());
gdb_assert (arch == tdep->regs[cookednum].arch);
reg = &tdep->regs[cookednum];
struct m32c_reg *reg;
gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
- gdb_assert (arch == get_regcache_arch (cache));
+ gdb_assert (arch == cache->arch ());
gdb_assert (arch == tdep->regs[cookednum].arch);
reg = &tdep->regs[cookednum];
}
-/* Mark REG as a DMA register, and return it. */
-static struct m32c_reg *
+/* Mark REG as a DMA register. */
+static void
mark_dma (struct m32c_reg *reg)
{
reg->dma_p = 1;
- return reg;
}
if (mach == bfd_mach_m32c)
{
- struct m32c_reg *svf = S (R16U (svf));
- struct m32c_reg *svp = S (RC (svp));
- struct m32c_reg *vct = S (RC (vct));
-
- struct m32c_reg *dmd01 = DMA (RP (dmd, tdep->uint8));
- struct m32c_reg *dct01 = DMA (RP (dct, tdep->uint16));
- struct m32c_reg *drc01 = DMA (RP (drc, tdep->uint16));
- struct m32c_reg *dma01 = DMA (RP (dma, tdep->data_addr_reg_type));
- struct m32c_reg *dsa01 = DMA (RP (dsa, tdep->data_addr_reg_type));
- struct m32c_reg *dra01 = DMA (RP (dra, tdep->data_addr_reg_type));
+ S (R16U (svf));
+ S (RC (svp));
+ S (RC (vct));
+
+ DMA (RP (dmd, tdep->uint8));
+ DMA (RP (dct, tdep->uint16));
+ DMA (RP (drc, tdep->uint16));
+ DMA (RP (dma, tdep->data_addr_reg_type));
+ DMA (RP (dsa, tdep->data_addr_reg_type));
+ DMA (RP (dra, tdep->data_addr_reg_type));
}
num_raw_regs = tdep->num_regs;
\f
/* Breakpoints. */
+constexpr gdb_byte m32c_break_insn[] = { 0x00 }; /* brk */
-static const unsigned char *
-m32c_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
-{
- static unsigned char break_insn[] = { 0x00 }; /* brk */
-
- *len = sizeof (break_insn);
- return break_insn;
-}
-
+typedef BP_MANIPULATION (m32c_break_insn) m32c_breakpoint;
\f
/* Prologue analysis. */
static int
m32c_pv_push (struct m32c_pv_state *state, pv_t value, int size)
{
- if (pv_area_store_would_trash (state->stack, state->sp))
+ if (state->stack->store_would_trash (state->sp))
return 1;
state->sp = pv_add_constant (state->sp, -size);
- pv_area_store (state->stack, state->sp, size, value);
+ state->stack->store (state->sp, size, value);
return 0;
}
m32c_srcdest_fetch (struct m32c_pv_state *state, struct srcdest loc, int size)
{
if (loc.kind == srcdest_mem)
- return pv_area_fetch (state->stack, loc.addr, size);
+ return state->stack->fetch (loc.addr, size);
else if (loc.kind == srcdest_partial_reg)
return pv_unknown ();
else
{
if (loc.kind == srcdest_mem)
{
- if (pv_area_store_would_trash (state->stack, loc.addr))
+ if (state->stack->store_would_trash (loc.addr))
return 1;
- pv_area_store (state->stack, loc.addr, size, value);
+ state->stack->store (loc.addr, size, value);
}
else if (loc.kind == srcdest_partial_reg)
*loc.reg = pv_unknown ();
switch (code)
{
- case 0x0: sd.reg = (size == 1 ? &st->r0 : &st->r0); break;
+ case 0x0: sd.reg = &st->r0; break;
case 0x1: sd.reg = (size == 1 ? &st->r0 : &st->r1); break;
case 0x2: sd.reg = (size == 1 ? &st->r1 : &st->r2); break;
case 0x3: sd.reg = (size == 1 ? &st->r1 : &st->r3); break;
/* If simulating this store would require us to forget
everything we know about the stack frame in the name of
accuracy, it would be better to just quit now. */
- if (pv_area_store_would_trash (state->stack, state->sp))
+ if (state->stack->store_would_trash (state->sp))
return 1;
if (m32c_pv_push (state, state->fb, tdep->push_addr_bytes))
return (m32c_is_arg_reg (st, value)
&& loc.kind == srcdest_mem
&& pv_is_register (loc.addr, tdep->sp->num)
- && ! pv_area_find_reg (st->stack, st->arch, value.reg, 0));
+ && ! st->stack->find_reg (st->arch, value.reg, 0));
}
/* Return non-zero if a store of VALUE to LOC is probably
struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch);
return (m32c_is_1st_arg_reg (st, value)
- && !pv_area_find_reg (st->stack, st->arch, value.reg, 0)
+ && !st->stack->find_reg (st->arch, value.reg, 0)
&& loc.kind == srcdest_reg
&& (pv_is_register (*loc.reg, tdep->a0->num)
|| pv_is_register (*loc.reg, tdep->a1->num)));
/* Function for finding saved registers in a 'struct pv_area'; we pass
- this to pv_area_scan.
+ this to pv_area::scan.
If VALUE is a saved register, ADDR says it was saved at a constant
offset from the frame base, and SIZE indicates that the whole
struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
unsigned long mach = gdbarch_bfd_arch_info (arch)->mach;
CORE_ADDR after_last_frame_related_insn;
- struct cleanup *back_to;
struct m32c_pv_state st;
st.arch = arch;
st.fb = pv_register (tdep->fb->num, 0);
st.sp = pv_register (tdep->sp->num, 0);
st.pc = pv_register (tdep->pc->num, 0);
- st.stack = make_pv_area (tdep->sp->num, gdbarch_addr_bit (arch));
- back_to = make_cleanup_free_pv_area (st.stack);
+ pv_area stack (tdep->sp->num, gdbarch_addr_bit (arch));
+ st.stack = &stack;
/* Record that the call instruction has saved the return address on
the stack. */
prologue->kind = prologue_first_frame;
/* Record where all the registers were saved. */
- pv_area_scan (st.stack, check_for_saved, (void *) prologue);
+ st.stack->scan (check_for_saved, (void *) prologue);
prologue->prologue_end = after_last_frame_related_insn;
-
- do_cleanups (back_to);
}
default_frame_sniffer
};
-
-static CORE_ADDR
-m32c_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame)
-{
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
- return frame_unwind_register_unsigned (next_frame, tdep->pc->num);
-}
-
-
-static CORE_ADDR
-m32c_unwind_sp (struct gdbarch *arch, struct frame_info *next_frame)
-{
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
- return frame_unwind_register_unsigned (next_frame, tdep->sp->num);
-}
-
\f
/* Inferior calls. */
static int
m32c_reg_arg_type (struct type *type)
{
- enum type_code code = TYPE_CODE (type);
+ enum type_code code = type->code ();
return (code == TYPE_CODE_INT
|| code == TYPE_CODE_ENUM
|| code == TYPE_CODE_PTR
- || code == TYPE_CODE_REF
+ || TYPE_IS_REFERENCE (type)
|| code == TYPE_CODE_BOOL
|| code == TYPE_CODE_CHAR);
}
static CORE_ADDR
m32c_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,
+ struct value **args, CORE_ADDR sp,
+ function_call_return_method return_method,
CORE_ADDR struct_addr)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
struct type *func_type = value_type (function);
/* Dereference function pointer types. */
- if (TYPE_CODE (func_type) == TYPE_CODE_PTR)
+ if (func_type->code () == TYPE_CODE_PTR)
func_type = TYPE_TARGET_TYPE (func_type);
- gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC ||
- TYPE_CODE (func_type) == TYPE_CODE_METHOD);
+ gdb_assert (func_type->code () == TYPE_CODE_FUNC ||
+ func_type->code () == TYPE_CODE_METHOD);
#if 0
/* The ABI description in gcc/config/m32c/m32c.abi says that
separately, but the code in GCC doesn't actually do so. */
if (TYPE_PROTOTYPED (func_type))
#endif
- num_prototyped_args = TYPE_NFIELDS (func_type);
+ num_prototyped_args = func_type->num_fields ();
}
/* First, if the function returns an aggregate by value, push a
pointer to a buffer for it. This doesn't affect the way
subsequent arguments are allocated to registers. */
- if (struct_return)
+ if (return_method == return_method_struct)
{
int ptr_len = TYPE_LENGTH (tdep->ptr_voyd);
sp -= ptr_len;
&& arg_size == 2
&& i < num_prototyped_args
&& m32c_reg_arg_type (arg_type))
- regcache_cooked_write (regcache, tdep->r2->num, arg_bits);
+ regcache->cooked_write (tdep->r2->num, arg_bits);
/* Everything else goes on the stack. */
else
}
-static struct frame_id
-m32c_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
-{
- /* This needs to return a frame ID whose PC is the return address
- passed to m32c_push_dummy_call, and whose stack_addr is the SP
- m32c_push_dummy_call returned.
-
- m32c_unwind_sp gives us the CFA, which is the value the SP had
- before the return address was pushed. */
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- CORE_ADDR sp = get_frame_register_unsigned (this_frame, tdep->sp->num);
- return frame_id_build (sp, get_frame_pc (this_frame));
-}
-
-
\f
/* Return values. */
static int
m32c_return_by_passed_buf (struct type *type)
{
- enum type_code code = TYPE_CODE (type);
+ enum type_code code = type->code ();
return (code == TYPE_CODE_STRUCT
|| code == TYPE_CODE_UNION);
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
enum type_code target_code;
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR ||
- TYPE_CODE (type) == TYPE_CODE_REF);
+ gdb_assert (type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type));
- target_code = TYPE_CODE (TYPE_TARGET_TYPE (type));
+ target_code = TYPE_TARGET_TYPE (type)->code ();
if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
{
"couldn't find a symbol at that address, to find trampoline."),
paddress (gdbarch, addr));
- func_name = MSYMBOL_LINKAGE_NAME (func_msym.minsym);
+ func_name = func_msym.minsym->linkage_name ();
tramp_name = (char *) xmalloc (strlen (func_name) + 5);
strcpy (tramp_name, func_name);
strcat (tramp_name, ".plt");
"couldn't find trampoline named '%s.plt'.\n"
"Returning pointer value %s instead; this may produce\n"
"a useful result if converted back into an address by GDB,\n"
- "but will most likely not be useful otherwise.\n"),
+ "but will most likely not be useful otherwise."),
paddress (gdbarch, addr), func_name,
paddress (gdbarch, ptrval));
CORE_ADDR ptr;
enum type_code target_code;
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR ||
- TYPE_CODE (type) == TYPE_CODE_REF);
+ gdb_assert (type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type));
ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
- target_code = TYPE_CODE (TYPE_TARGET_TYPE (type));
+ target_code = TYPE_TARGET_TYPE (type)->code ();
if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
{
if (ptr_msym.minsym)
{
- const char *ptr_msym_name = MSYMBOL_LINKAGE_NAME (ptr_msym.minsym);
+ const char *ptr_msym_name = ptr_msym.minsym->linkage_name ();
int len = strlen (ptr_msym_name);
if (len > 4
/* Register set. */
make_regs (gdbarch);
- /* Disassembly. */
- set_gdbarch_print_insn (gdbarch, print_insn_m32c);
-
/* Breakpoints. */
- set_gdbarch_breakpoint_from_pc (gdbarch, m32c_breakpoint_from_pc);
+ set_gdbarch_breakpoint_kind_from_pc (gdbarch, m32c_breakpoint::kind_from_pc);
+ set_gdbarch_sw_breakpoint_from_kind (gdbarch, m32c_breakpoint::bp_from_kind);
/* Prologue analysis and unwinding. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
set_gdbarch_skip_prologue (gdbarch, m32c_skip_prologue);
- set_gdbarch_unwind_pc (gdbarch, m32c_unwind_pc);
- set_gdbarch_unwind_sp (gdbarch, m32c_unwind_sp);
#if 0
/* I'm dropping the dwarf2 sniffer because it has a few problems.
They may be in the dwarf2 cfi code in GDB, or they may be in
/* Inferior calls. */
set_gdbarch_push_dummy_call (gdbarch, m32c_push_dummy_call);
set_gdbarch_return_value (gdbarch, m32c_return_value);
- set_gdbarch_dummy_id (gdbarch, m32c_dummy_id);
/* Trampolines. */
set_gdbarch_skip_trampoline_code (gdbarch, m32c_skip_trampoline_code);
return gdbarch;
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_m32c_tdep;
-
+void _initialize_m32c_tdep ();
void
-_initialize_m32c_tdep (void)
+_initialize_m32c_tdep ()
{
register_gdbarch_init (bfd_arch_m32c, m32c_gdbarch_init);
projects / deliverable / binutils-gdb.git / blobdiff