/* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
- Copyright (C) 1993-2020 Free Software Foundation, Inc.
+ Copyright (C) 1993-2022 Free Software Foundation, Inc.
This file is part of GDB.
alpha_cannot_store_register (struct gdbarch *gdbarch, int regno)
{
return (regno == ALPHA_ZERO_REGNUM
- || strlen (alpha_register_name (gdbarch, regno)) == 0);
+ || strlen (alpha_register_name (gdbarch, regno)) == 0);
}
static struct type *
/* Convert to VALTYPE. */
gdb_assert (TYPE_LENGTH (valtype) == 4);
- alpha_sts (gdbarch, out, value_contents_all (value));
+ alpha_sts (gdbarch, out, value_contents_all (value).data ());
release_value (value);
return 1;
struct type *arg_type = check_typedef (value_type (arg));
/* Cast argument to long if necessary as the compiler does it too. */
- switch (TYPE_CODE (arg_type))
+ switch (arg_type->code ())
{
case TYPE_CODE_INT:
case TYPE_CODE_BOOL:
sp = (sp & -16) - 16;
/* Write the real data into the stack. */
- write_memory (sp, value_contents (arg), 16);
+ write_memory (sp, value_contents (arg).data (), 16);
/* Construct the indirection. */
arg_type = lookup_pointer_type (arg_type);
sp = (sp & -16) - 16;
/* Write the real data into the stack. */
- write_memory (sp, value_contents (arg), 32);
+ write_memory (sp, value_contents (arg).data (), 32);
/* Construct the indirection. */
arg_type = lookup_pointer_type (arg_type);
m_arg->len = TYPE_LENGTH (arg_type);
m_arg->offset = accumulate_size;
accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
- m_arg->contents = value_contents (arg);
+ m_arg->contents = value_contents (arg).data ();
}
/* Determine required argument register loads, loading an argument register
gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
ULONGEST l;
- switch (TYPE_CODE (valtype))
+ switch (valtype->code ())
{
case TYPE_CODE_FLT:
switch (TYPE_LENGTH (valtype))
gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
ULONGEST l;
- switch (TYPE_CODE (valtype))
+ switch (valtype->code ())
{
case TYPE_CODE_FLT:
switch (TYPE_LENGTH (valtype))
struct type *type, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
{
- enum type_code code = TYPE_CODE (type);
+ enum type_code code = type->code ();
+ alpha_gdbarch_tdep *tdep = (alpha_gdbarch_tdep *) gdbarch_tdep (gdbarch);
if ((code == TYPE_CODE_STRUCT
|| code == TYPE_CODE_UNION
|| code == TYPE_CODE_ARRAY)
- && gdbarch_tdep (gdbarch)->return_in_memory (type))
+ && tdep->return_in_memory (type))
{
if (readbuf)
{
alpha_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ alpha_gdbarch_tdep *tdep = (alpha_gdbarch_tdep *) gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR jb_addr;
gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
void **this_prologue_cache)
{
struct alpha_sigtramp_unwind_cache *info;
- struct gdbarch_tdep *tdep;
if (*this_prologue_cache)
return (struct alpha_sigtramp_unwind_cache *) *this_prologue_cache;
info = FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache);
*this_prologue_cache = info;
- tdep = gdbarch_tdep (get_frame_arch (this_frame));
+ gdbarch *arch = get_frame_arch (this_frame);
+ alpha_gdbarch_tdep *tdep = (alpha_gdbarch_tdep *) gdbarch_tdep (arch);
info->sigcontext_addr = tdep->sigcontext_addr (this_frame);
return info;
alpha_sigtramp_register_address (struct gdbarch *gdbarch,
CORE_ADDR sigcontext_addr, int regnum)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ alpha_gdbarch_tdep *tdep = (alpha_gdbarch_tdep *) gdbarch_tdep (gdbarch);
if (regnum >= 0 && regnum < 32)
return sigcontext_addr + tdep->sc_regs_offset + regnum * 8;
struct frame_id *this_id)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ alpha_gdbarch_tdep *tdep = (alpha_gdbarch_tdep *) gdbarch_tdep (gdbarch);
struct alpha_sigtramp_unwind_cache *info
= alpha_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
CORE_ADDR stack_addr, code_addr;
addr = alpha_sigtramp_register_address (get_frame_arch (this_frame),
info->sigcontext_addr, regnum);
if (addr != 0)
- return frame_unwind_got_memory (this_frame, regnum, addr);
+ return frame_unwind_got_memory (this_frame, regnum, addr);
}
/* This extra register may actually be in the sigcontext, but our
static int
alpha_sigtramp_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
- void **this_prologue_cache)
+ struct frame_info *this_frame,
+ void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR pc = get_frame_pc (this_frame);
/* We shouldn't even bother to try if the OSABI didn't register a
sigcontext_addr handler or pc_in_sigtramp handler. */
- if (gdbarch_tdep (gdbarch)->sigcontext_addr == NULL)
+ alpha_gdbarch_tdep *tdep = (alpha_gdbarch_tdep *) gdbarch_tdep (gdbarch);
+ if (tdep->sigcontext_addr == NULL)
return 0;
- if (gdbarch_tdep (gdbarch)->pc_in_sigtramp == NULL)
+
+ if (tdep->pc_in_sigtramp == NULL)
return 0;
/* Otherwise we should be in a signal frame. */
find_pc_partial_function (pc, &name, NULL, NULL);
- if (gdbarch_tdep (gdbarch)->pc_in_sigtramp (gdbarch, pc, name))
+ if (tdep->pc_in_sigtramp (gdbarch, pc, name))
return 1;
return 0;
}
-static const struct frame_unwind alpha_sigtramp_frame_unwind = {
+static const struct frame_unwind alpha_sigtramp_frame_unwind =
+{
+ "alpha sigtramp",
SIGTRAMP_FRAME,
default_frame_unwind_stop_reason,
alpha_sigtramp_frame_this_id,
static CORE_ADDR
alpha_heuristic_proc_start (struct gdbarch *gdbarch, CORE_ADDR pc)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ alpha_gdbarch_tdep *tdep = (alpha_gdbarch_tdep *) gdbarch_tdep (gdbarch);
CORE_ADDR last_non_nop = pc;
CORE_ADDR fence = pc - heuristic_fence_post;
CORE_ADDR orig_pc = pc;
{
CORE_ADDR vfp;
CORE_ADDR start_pc;
- struct trad_frame_saved_reg *saved_regs;
+ trad_frame_saved_reg *saved_regs;
int return_reg;
};
/* The following pattern is recognized as a probing loop:
- lda REG_INDEX,NB_OF_ITERATIONS
- lda REG_PROBE,<immediate>(sp)
+ lda REG_INDEX,NB_OF_ITERATIONS
+ lda REG_PROBE,<immediate>(sp)
LOOP_START:
- stq zero,<immediate>(REG_PROBE)
- subq REG_INDEX,0x1,REG_INDEX
- lda REG_PROBE,<immediate>(REG_PROBE)
- bne REG_INDEX, LOOP_START
+ stq zero,<immediate>(REG_PROBE)
+ subq REG_INDEX,0x1,REG_INDEX
+ lda REG_PROBE,<immediate>(REG_PROBE)
+ bne REG_INDEX, LOOP_START
- lda sp,<immediate>(REG_PROBE)
+ lda sp,<immediate>(REG_PROBE)
If anything different is found, the function returns without
changing PC and FRAME_SIZE. Otherwise, PC will point immediately
{
reg = (word & 0x03e00000) >> 21;
- /* Ignore this instruction if we have already encountered
- an instruction saving the same register earlier in the
- function code. The current instruction does not tell
- us where the original value upon function entry is saved.
- All it says is that the function we are scanning reused
- that register for some computation of its own, and is now
- saving its result. */
- if (trad_frame_addr_p(info->saved_regs, reg))
- continue;
+ /* Ignore this instruction if we have already encountered
+ an instruction saving the same register earlier in the
+ function code. The current instruction does not tell
+ us where the original value upon function entry is saved.
+ All it says is that the function we are scanning reused
+ that register for some computation of its own, and is now
+ saving its result. */
+ if (info->saved_regs[reg].is_addr ())
+ continue;
if (reg == 31)
continue;
pointer or not. */
/* Hack: temporarily add one, so that the offset is non-zero
and we can tell which registers have save offsets below. */
- info->saved_regs[reg].addr = (word & 0xffff) + 1;
+ info->saved_regs[reg].set_addr ((word & 0xffff) + 1);
/* Starting with OSF/1-3.2C, the system libraries are shipped
without local symbols, but they still contain procedure
/* Convert offsets to absolute addresses. See above about adding
one to the offsets to make all detected offsets non-zero. */
for (reg = 0; reg < ALPHA_NUM_REGS; ++reg)
- if (trad_frame_addr_p(info->saved_regs, reg))
- info->saved_regs[reg].addr += val - 1;
+ if (info->saved_regs[reg].is_addr ())
+ info->saved_regs[reg].set_addr (info->saved_regs[reg].addr ()
+ + val - 1);
/* The stack pointer of the previous frame is computed by popping
the current stack frame. */
- if (!trad_frame_addr_p (info->saved_regs, ALPHA_SP_REGNUM))
- trad_frame_set_value (info->saved_regs, ALPHA_SP_REGNUM, info->vfp);
+ if (!info->saved_regs[ALPHA_SP_REGNUM].is_addr ())
+ info->saved_regs[ALPHA_SP_REGNUM].set_value (info->vfp);
return info;
}
return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
}
-static const struct frame_unwind alpha_heuristic_frame_unwind = {
+static const struct frame_unwind alpha_heuristic_frame_unwind =
+{
+ "alpha prologue",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
alpha_heuristic_frame_this_id,
|| op == 0x34) /* BSR */
{
branch_taken:
- offset = (insn & 0x001fffff);
+ offset = (insn & 0x001fffff);
if (offset & 0x00100000)
offset |= 0xffe00000;
offset *= ALPHA_INSN_SIZE;
/* Need to determine if branch is taken; read RA. */
regno = (insn >> 21) & 0x1f;
switch (op)
- {
- case 0x31: /* FBEQ */
- case 0x36: /* FBGE */
- case 0x37: /* FBGT */
- case 0x33: /* FBLE */
- case 0x32: /* FBLT */
- case 0x35: /* FBNE */
- regno += gdbarch_fp0_regnum (gdbarch);
+ {
+ case 0x31: /* FBEQ */
+ case 0x36: /* FBGE */
+ case 0x37: /* FBGT */
+ case 0x33: /* FBLE */
+ case 0x32: /* FBLT */
+ case 0x35: /* FBNE */
+ regno += gdbarch_fp0_regnum (gdbarch);
}
rav = regcache_raw_get_signed (regcache, regno);
goto branch_taken;
break;
- /* Floating point branches. */
-
- case 0x31: /* FBEQ */
- if (fp_register_zero_p (rav))
- goto branch_taken;
- break;
- case 0x36: /* FBGE */
- if (fp_register_sign_bit (rav) == 0 || fp_register_zero_p (rav))
- goto branch_taken;
- break;
- case 0x37: /* FBGT */
- if (fp_register_sign_bit (rav) == 0 && ! fp_register_zero_p (rav))
- goto branch_taken;
- break;
- case 0x33: /* FBLE */
- if (fp_register_sign_bit (rav) == 1 || fp_register_zero_p (rav))
- goto branch_taken;
- break;
- case 0x32: /* FBLT */
- if (fp_register_sign_bit (rav) == 1 && ! fp_register_zero_p (rav))
- goto branch_taken;
- break;
- case 0x35: /* FBNE */
- if (! fp_register_zero_p (rav))
- goto branch_taken;
- break;
+ /* Floating point branches. */
+
+ case 0x31: /* FBEQ */
+ if (fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
+ case 0x36: /* FBGE */
+ if (fp_register_sign_bit (rav) == 0 || fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
+ case 0x37: /* FBGT */
+ if (fp_register_sign_bit (rav) == 0 && ! fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
+ case 0x33: /* FBLE */
+ if (fp_register_sign_bit (rav) == 1 || fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
+ case 0x32: /* FBLT */
+ if (fp_register_sign_bit (rav) == 1 && ! fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
+ case 0x35: /* FBNE */
+ if (! fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
}
}
static struct gdbarch *
alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
- struct gdbarch_tdep *tdep;
struct gdbarch *gdbarch;
/* Find a candidate among extant architectures. */
if (arches != NULL)
return arches->gdbarch;
- tdep = XCNEW (struct gdbarch_tdep);
+ alpha_gdbarch_tdep *tdep = new alpha_gdbarch_tdep;
gdbarch = gdbarch_alloc (&info, tdep);
/* Lowest text address. This is used by heuristic_proc_start()
projects / binutils-gdb.git / blobdiff