/* Renesas M32C target-dependent code for GDB, the GNU debugger.
- Copyright (C) 2004-2018 Free Software Foundation, Inc.
+ Copyright (C) 2004-2022 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "elf-bfd.h"
-#include "elf/m32c.h"
#include "gdb/sim-m32c.h"
-#include "dis-asm.h"
#include "gdbtypes.h"
#include "regcache.h"
#include "arch-utils.h"
#include "frame.h"
#include "frame-unwind.h"
-#include "dwarf2-frame.h"
-#include "dwarf2expr.h"
#include "symtab.h"
#include "gdbcore.h"
#include "value.h"
#include "reggroups.h"
#include "prologue-value.h"
-#include "target.h"
#include "objfiles.h"
+#include "gdbarch.h"
\f
/* The m32c tdep structure. */
static struct reggroup *m32c_dma_reggroup;
-struct m32c_reg;
-
/* The type of a function that moves the value of REG between CACHE or
BUF --- in either direction. */
typedef enum register_status (m32c_write_reg_t) (struct m32c_reg *reg,
#define M32C_MAX_DWARF_REGNUM (40)
-struct gdbarch_tdep
+struct m32c_gdbarch_tdep : gdbarch_tdep
{
/* All the registers for this variant, indexed by GDB register
number, and the number of registers present. */
- struct m32c_reg regs[M32C_MAX_NUM_REGS];
+ struct m32c_reg regs[M32C_MAX_NUM_REGS] {};
/* The number of valid registers. */
- int num_regs;
+ int num_regs = 0;
/* Interesting registers. These are pointers into REGS. */
- struct m32c_reg *pc, *flg;
- struct m32c_reg *r0, *r1, *r2, *r3, *a0, *a1;
- struct m32c_reg *r2r0, *r3r2r1r0, *r3r1r2r0;
- struct m32c_reg *sb, *fb, *sp;
+ struct m32c_reg *pc = nullptr, *flg = nullptr;
+ struct m32c_reg *r0 = nullptr, *r1 = nullptr, *r2 = nullptr, *r3 = nullptr,
+ *a0 = nullptr, *a1 = nullptr;
+ struct m32c_reg *r2r0 = nullptr, *r3r2r1r0 = nullptr, *r3r1r2r0 = nullptr;
+ struct m32c_reg *sb = nullptr, *fb = nullptr, *sp = nullptr;
/* A table indexed by DWARF register numbers, pointing into
REGS. */
- struct m32c_reg *dwarf_regs[M32C_MAX_DWARF_REGNUM + 1];
+ struct m32c_reg *dwarf_regs[M32C_MAX_DWARF_REGNUM + 1] {};
/* Types for this architecture. We can't use the builtin_type_foo
types, because they're not initialized when building a gdbarch
structure. */
- struct type *voyd, *ptr_voyd, *func_voyd;
- struct type *uint8, *uint16;
- struct type *int8, *int16, *int32, *int64;
+ struct type *voyd = nullptr, *ptr_voyd = nullptr, *func_voyd = nullptr;
+ struct type *uint8 = nullptr, *uint16 = nullptr;
+ struct type *int8 = nullptr, *int16 = nullptr, *int32 = nullptr,
+ *int64 = nullptr;
/* The types for data address and code address registers. */
- struct type *data_addr_reg_type, *code_addr_reg_type;
+ struct type *data_addr_reg_type = nullptr, *code_addr_reg_type = nullptr;
/* The number of bytes a return address pushed by a 'jsr' instruction
occupies on the stack. */
- int ret_addr_bytes;
+ int ret_addr_bytes = 0;
/* The number of bytes an address register occupies on the stack
when saved by an 'enter' or 'pushm' instruction. */
- int push_addr_bytes;
+ int push_addr_bytes = 0;
};
\f
static void
make_types (struct gdbarch *arch)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
unsigned long mach = gdbarch_bfd_arch_info (arch)->mach;
int data_addr_reg_bits, code_addr_reg_bits;
char type_name[50];
static const char *
m32c_register_name (struct gdbarch *gdbarch, int num)
{
- return gdbarch_tdep (gdbarch)->regs[num].name;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (gdbarch);
+ return tdep->regs[num].name;
}
static struct type *
m32c_register_type (struct gdbarch *arch, int reg_nr)
{
- return gdbarch_tdep (arch)->regs[reg_nr].type;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
+ return tdep->regs[reg_nr].type;
}
static int
m32c_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
{
- return gdbarch_tdep (gdbarch)->regs[reg_nr].sim_num;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (gdbarch);
+ return tdep->regs[reg_nr].sim_num;
}
static int
m32c_debug_info_reg_to_regnum (struct gdbarch *gdbarch, int reg_nr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (gdbarch);
if (0 <= reg_nr && reg_nr <= M32C_MAX_DWARF_REGNUM
&& tdep->dwarf_regs[reg_nr])
return tdep->dwarf_regs[reg_nr]->num;
m32c_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
struct reggroup *group)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (gdbarch);
struct m32c_reg *reg = &tdep->regs[regnum];
/* The anonymous raw registers aren't in any groups. */
static int
m32c_read_flg (readable_regcache *cache)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (cache->arch ());
+ gdbarch *arch = cache->arch ();
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
ULONGEST flg;
cache->raw_read (tdep->flg->num, &flg);
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;
}
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;
static enum register_status
m32c_r3r2r1r0_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch);
+ gdbarch *arch = reg->arch;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
int len = TYPE_LENGTH (tdep->r0->type);
enum register_status status;
m32c_r3r2r1r0_write (struct m32c_reg *reg, struct regcache *cache,
const gdb_byte *buf)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch);
+ gdbarch *arch = reg->arch;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
int len = TYPE_LENGTH (tdep->r0->type);
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;
int cookednum,
gdb_byte *buf)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
struct m32c_reg *reg;
gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
int cookednum,
const gdb_byte *buf)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
struct m32c_reg *reg;
gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
struct m32c_reg *ry,
int n)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
struct m32c_reg *r = &tdep->regs[tdep->num_regs];
gdb_assert (tdep->num_regs < M32C_MAX_NUM_REGS);
reg->dwarf_num = num;
/* Update the DWARF->reg mapping. */
- gdbarch_tdep (reg->arch)->dwarf_regs[num] = reg;
+ gdbarch *arch = reg->arch;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
+ tdep->dwarf_regs[num] = reg;
}
}
-/* 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;
}
#define CB(name, raw_pair) \
(add_reg (arch, #name, (raw_pair)->type, 0, \
m32c_banked_read, m32c_banked_write, \
- (raw_pair), (raw_pair + 1), FLAGBIT_B))
+ (raw_pair), (raw_pair + 1), FLAGBIT_B))
/* A pair of registers named NAMEH and NAMEL, of type TYPE, that
access the top and bottom halves of the register pointed to by
static void
make_regs (struct gdbarch *arch)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
int mach = gdbarch_bfd_arch_info (arch)->mach;
int num_raw_regs;
int num_cooked_regs;
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;
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;
static int
m32c_pv_enter (struct m32c_pv_state *state, int size)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
-
/* 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 (state->stack->store_would_trash (state->sp))
return 1;
+ gdbarch *arch = state->arch;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
if (m32c_pv_push (state, state->fb, tdep->push_addr_bytes))
return 1;
+
state->fb = state->sp;
state->sp = pv_add_constant (state->sp, -size);
static int
m32c_pv_pushm (struct m32c_pv_state *state, int src)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
+ gdbarch *arch = state->arch;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
/* The bits in SRC indicating which registers to save are:
r0 r1 r2 r3 a0 a1 sb fb */
static int
m32c_is_1st_arg_reg (struct m32c_pv_state *state, pv_t value)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
+ gdbarch *arch = state->arch;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
+
return (value.kind == pvk_register
- && (gdbarch_bfd_arch_info (state->arch)->mach == bfd_mach_m16c
+ && (gdbarch_bfd_arch_info (state->arch)->mach == bfd_mach_m16c
? (value.reg == tdep->r1->num)
: (value.reg == tdep->r0->num))
- && value.k == 0);
+ && value.k == 0);
}
/* Return non-zero if VALUE is an incoming argument register. */
static int
m32c_is_arg_reg (struct m32c_pv_state *state, pv_t value)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
+ gdbarch *arch = state->arch;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
+
return (value.kind == pvk_register
- && (gdbarch_bfd_arch_info (state->arch)->mach == bfd_mach_m16c
+ && (gdbarch_bfd_arch_info (state->arch)->mach == bfd_mach_m16c
? (value.reg == tdep->r1->num || value.reg == tdep->r2->num)
: (value.reg == tdep->r0->num))
- && value.k == 0);
+ && value.k == 0);
}
/* Return non-zero if a store of VALUE to LOC is probably spilling an
struct srcdest loc,
pv_t value)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch);
+ gdbarch *arch = st->arch;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
return (m32c_is_arg_reg (st, value)
&& loc.kind == srcdest_mem
- && pv_is_register (loc.addr, tdep->sp->num)
- && ! st->stack->find_reg (st->arch, value.reg, 0));
+ && pv_is_register (loc.addr, tdep->sp->num)
+ && ! st->stack->find_reg (st->arch, value.reg, 0));
}
/* Return non-zero if a store of VALUE to LOC is probably
struct srcdest loc,
pv_t value)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch);
+ gdbarch *arch = st->arch;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
return (m32c_is_1st_arg_reg (st, value)
&& !st->stack->find_reg (st->arch, value.reg, 0)
static int
m32c_pushm_is_reg_save (struct m32c_pv_state *st, int src)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch);
+ gdbarch *arch = st->arch;
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
+
/* The bits in SRC indicating which registers to save are:
r0 r1 r2 r3 a0 a1 sb fb */
return
{
struct m32c_prologue *prologue = (struct m32c_prologue *) prologue_untyped;
struct gdbarch *arch = prologue->arch;
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
/* Is this the unchanged value of some register being saved on the
stack? */
CORE_ADDR start, CORE_ADDR limit,
struct m32c_prologue *prologue)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
unsigned long mach = gdbarch_bfd_arch_info (arch)->mach;
CORE_ADDR after_last_frame_related_insn;
struct m32c_pv_state st;
}
/* If this instruction changed the FB or decreased the SP (i.e.,
- allocated more stack space), then this may be a good place to
- declare the prologue finished. However, there are some
- exceptions:
+ allocated more stack space), then this may be a good place to
+ declare the prologue finished. However, there are some
+ exceptions:
- - If the instruction just changed the FB back to its original
- value, then that's probably a restore instruction. The
- prologue should definitely end before that.
+ - If the instruction just changed the FB back to its original
+ value, then that's probably a restore instruction. The
+ prologue should definitely end before that.
- - If the instruction increased the value of the SP (that is,
- shrunk the frame), then it's probably part of a frame
- teardown sequence, and the prologue should end before
- that. */
+ - If the instruction increased the value of the SP (that is,
+ shrunk the frame), then it's probably part of a frame
+ teardown sequence, and the prologue should end before
+ that. */
if (! pv_is_identical (st.fb, pre_insn_fb))
- {
- if (! pv_is_register_k (st.fb, tdep->fb->num, 0))
- after_last_frame_related_insn = st.next_addr;
- }
+ {
+ if (! pv_is_register_k (st.fb, tdep->fb->num, 0))
+ after_last_frame_related_insn = st.next_addr;
+ }
else if (! pv_is_identical (st.sp, pre_insn_sp))
- {
- /* The comparison of the constants looks odd, there, because
- .k is unsigned. All it really means is that the SP is
- lower than it was before the instruction. */
- if ( pv_is_register (pre_insn_sp, tdep->sp->num)
- && pv_is_register (st.sp, tdep->sp->num)
- && ((pre_insn_sp.k - st.sp.k) < (st.sp.k - pre_insn_sp.k)))
- after_last_frame_related_insn = st.next_addr;
- }
+ {
+ /* The comparison of the constants looks odd, there, because
+ .k is unsigned. All it really means is that the SP is
+ lower than it was before the instruction. */
+ if ( pv_is_register (pre_insn_sp, tdep->sp->num)
+ && pv_is_register (st.sp, tdep->sp->num)
+ && ((pre_insn_sp.k - st.sp.k) < (st.sp.k - pre_insn_sp.k)))
+ after_last_frame_related_insn = st.next_addr;
+ }
st.scan_pc = st.next_addr;
}
CORE_ADDR 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;
+ stop_addr = func_start;
*this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct m32c_prologue);
m32c_analyze_prologue (get_frame_arch (this_frame),
static CORE_ADDR
m32c_frame_base (struct frame_info *this_frame,
- void **this_prologue_cache)
+ void **this_prologue_cache)
{
struct m32c_prologue *p
= m32c_analyze_frame_prologue (this_frame, this_prologue_cache);
- struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
+ gdbarch *arch = get_frame_arch (this_frame);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
/* In functions that use alloca, the distance between the stack
pointer and the frame base varies dynamically, so we can't use
m32c_prev_register (struct frame_info *this_frame,
void **this_prologue_cache, int regnum)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
+ gdbarch *arch = get_frame_arch (this_frame);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (arch);
struct m32c_prologue *p
= m32c_analyze_frame_prologue (this_frame, this_prologue_cache);
CORE_ADDR frame_base = m32c_frame_base (this_frame, this_prologue_cache);
return a description of the stack slot holding it. */
if (p->reg_offset[regnum] != 1)
return frame_unwind_got_memory (this_frame, regnum,
- frame_base + p->reg_offset[regnum]);
+ frame_base + p->reg_offset[regnum]);
/* Otherwise, presume we haven't changed the value of this
register, and get it from the next frame. */
static const struct frame_unwind m32c_unwind = {
+ "m32c prologue",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
m32c_this_id,
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
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);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
unsigned long mach = gdbarch_bfd_arch_info (gdbarch)->mach;
CORE_ADDR cfa;
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;
for (i = nargs - 1; i >= 0; i--)
{
struct value *arg = args[i];
- const gdb_byte *arg_bits = value_contents (arg);
+ const gdb_byte *arg_bits = value_contents (arg).data ();
struct type *arg_type = value_type (arg);
ULONGEST arg_size = TYPE_LENGTH (arg_type);
&& 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);
gdb_byte *readbuf,
const gdb_byte *writebuf)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
enum return_value_convention conv;
ULONGEST valtype_len = TYPE_LENGTH (valtype);
m32c_jsri16:
- # Save return address.
+ # Save return address.
pop.w m32c_jsri_ret
pop.b m32c_jsri_ret+2
- # Store target function address.
+ # Store target function address.
pop.w m32c_jsri_addr
# Re-push return address.
m32c_skip_trampoline_code (struct frame_info *frame, CORE_ADDR stop_pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
/* It would be nicer to simply look up the addresses of known
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
enum type_code target_code;
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type));
+ 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)
{
= lookup_minimal_symbol_by_pc (addr);
if (! func_msym.minsym)
- error (_("Cannot convert code address %s to function pointer:\n"
- "couldn't find a symbol at that address, to find trampoline."),
- paddress (gdbarch, addr));
+ error (_("Cannot convert code address %s to function pointer:\n"
+ "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");
tramp_msym = lookup_minimal_symbol (tramp_name, NULL, NULL);
/* We've either got another copy of the name now, or don't need
- the name any more. */
+ the name any more. */
xfree (tramp_name);
if (! tramp_msym.minsym)
"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_IS_REFERENCE (type));
+ 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)
{
/* See if there is a minimal symbol at that address whose name is
- "NAME.plt". */
+ "NAME.plt". */
struct bound_minimal_symbol ptr_msym = lookup_minimal_symbol_by_pc (ptr);
if (ptr_msym.minsym)
- {
- const char *ptr_msym_name = MSYMBOL_LINKAGE_NAME (ptr_msym.minsym);
- int len = strlen (ptr_msym_name);
+ {
+ const char *ptr_msym_name = ptr_msym.minsym->linkage_name ();
+ int len = strlen (ptr_msym_name);
- if (len > 4
- && strcmp (ptr_msym_name + len - 4, ".plt") == 0)
- {
+ if (len > 4
+ && strcmp (ptr_msym_name + len - 4, ".plt") == 0)
+ {
struct bound_minimal_symbol func_msym;
- /* We have a .plt symbol; try to find the symbol for the
- corresponding function.
-
- Since the trampoline contains a jump instruction, we
- could also just extract the jump's target address. I
- don't see much advantage one way or the other. */
- char *func_name = (char *) xmalloc (len - 4 + 1);
- memcpy (func_name, ptr_msym_name, len - 4);
- func_name[len - 4] = '\0';
- func_msym
- = lookup_minimal_symbol (func_name, NULL, NULL);
-
- /* If we do have such a symbol, return its value as the
- function's true address. */
- if (func_msym.minsym)
- ptr = BMSYMBOL_VALUE_ADDRESS (func_msym);
- }
- }
+ /* We have a .plt symbol; try to find the symbol for the
+ corresponding function.
+
+ Since the trampoline contains a jump instruction, we
+ could also just extract the jump's target address. I
+ don't see much advantage one way or the other. */
+ char *func_name = (char *) xmalloc (len - 4 + 1);
+ memcpy (func_name, ptr_msym_name, len - 4);
+ func_name[len - 4] = '\0';
+ func_msym
+ = lookup_minimal_symbol (func_name, NULL, NULL);
+
+ /* If we do have such a symbol, return its value as the
+ function's true address. */
+ if (func_msym.minsym)
+ ptr = BMSYMBOL_VALUE_ADDRESS (func_msym);
+ }
+ }
else
{
int aspace;
struct m32c_prologue p;
struct regcache *regcache = get_current_regcache ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ m32c_gdbarch_tdep *tdep = (m32c_gdbarch_tdep *) gdbarch_tdep (gdbarch);
if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
internal_error (__FILE__, __LINE__,
m32c_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
struct gdbarch *gdbarch;
- struct gdbarch_tdep *tdep;
unsigned long mach = info.bfd_arch_info->mach;
/* Find a candidate among the list of architectures we've created
arches = gdbarch_list_lookup_by_info (arches->next, &info))
return arches->gdbarch;
- tdep = XCNEW (struct gdbarch_tdep);
+ m32c_gdbarch_tdep *tdep = new m32c_gdbarch_tdep;
gdbarch = gdbarch_alloc (&info, tdep);
/* Essential types. */
/* 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;
}
+void _initialize_m32c_tdep ();
void
-_initialize_m32c_tdep (void)
+_initialize_m32c_tdep ()
{
register_gdbarch_init (bfd_arch_m32c, m32c_gdbarch_init);
projects / binutils-gdb.git / blobdiff