This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "doublest.h"
compatibility with existing remote alpha targets. */
static const char *
-alpha_register_name (int regno)
+alpha_register_name (struct gdbarch *gdbarch, int regno)
{
static const char * const register_names[] =
{
}
static int
-alpha_cannot_fetch_register (int regno)
+alpha_cannot_fetch_register (struct gdbarch *gdbarch, int regno)
{
return (regno == ALPHA_ZERO_REGNUM
- || strlen (alpha_register_name (regno)) == 0);
+ || strlen (alpha_register_name (gdbarch, regno)) == 0);
}
static int
-alpha_cannot_store_register (int regno)
+alpha_cannot_store_register (struct gdbarch *gdbarch, int regno)
{
return (regno == ALPHA_ZERO_REGNUM
- || strlen (alpha_register_name (regno)) == 0);
+ || strlen (alpha_register_name (gdbarch, regno)) == 0);
}
static struct type *
{
/* Filter out any registers eliminated, but whose regnum is
reserved for backward compatibility, e.g. the vfp. */
- if (REGISTER_NAME (regnum) == NULL || *REGISTER_NAME (regnum) == '\0')
+ if (gdbarch_register_name (gdbarch, regnum) == NULL
+ || *gdbarch_register_name (gdbarch, regnum) == '\0')
return 0;
if (group == all_reggroup)
registers is different. */
static int
-alpha_convert_register_p (int regno, struct type *type)
+alpha_convert_register_p (struct gdbarch *gdbarch, int regno, struct type *type)
{
- return (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31);
+ return (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31
+ && TYPE_LENGTH (type) != 8);
}
static void
case 4:
alpha_sts (out, in);
break;
- case 8:
- memcpy (out, in, 8);
- break;
default:
error (_("Cannot retrieve value from floating point register"));
}
case 4:
alpha_lds (out, in);
break;
- case 8:
- memcpy (out, in, 8);
- break;
default:
error (_("Cannot store value in floating point register"));
}
}
\f
static const gdb_byte *
-alpha_breakpoint_from_pc (CORE_ADDR *pc, int *len)
+alpha_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
{
static const gdb_byte break_insn[] = { 0x80, 0, 0, 0 }; /* call_pal bpt */
into the "pc". This routine returns true on success. */
static int
-alpha_get_longjmp_target (CORE_ADDR *pc)
+alpha_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
CORE_ADDR jb_addr;
gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
- jb_addr = read_register (ALPHA_A0_REGNUM);
+ jb_addr = get_frame_register_unsigned (frame, ALPHA_A0_REGNUM);
if (target_read_memory (jb_addr + (tdep->jb_pc * tdep->jb_elt_size),
raw_buffer, tdep->jb_elt_size))
info = FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache);
*this_prologue_cache = info;
- tdep = gdbarch_tdep (current_gdbarch);
+ tdep = gdbarch_tdep (get_frame_arch (next_frame));
info->sigcontext_addr = tdep->sigcontext_addr (next_frame);
return info;
/* If we have dynamic signal trampolines, find their start.
If we do not, then we must assume there is a symbol record
that can provide the start address. */
- tdep = gdbarch_tdep (current_gdbarch);
+ tdep = gdbarch_tdep (get_frame_arch (next_frame));
if (tdep->dynamic_sigtramp_offset)
{
int offset;
static const struct frame_unwind *
alpha_sigtramp_frame_sniffer (struct frame_info *next_frame)
{
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
CORE_ADDR pc = frame_pc_unwind (next_frame);
char *name;
/* We shouldn't even bother to try if the OSABI didn't register a
sigcontext_addr handler or pc_in_sigtramp hander. */
- if (gdbarch_tdep (current_gdbarch)->sigcontext_addr == NULL)
+ if (gdbarch_tdep (gdbarch)->sigcontext_addr == NULL)
return NULL;
- if (gdbarch_tdep (current_gdbarch)->pc_in_sigtramp == NULL)
+ if (gdbarch_tdep (gdbarch)->pc_in_sigtramp == NULL)
return NULL;
/* Otherwise we should be in a signal frame. */
find_pc_partial_function (pc, &name, NULL, NULL);
- if (gdbarch_tdep (current_gdbarch)->pc_in_sigtramp (pc, name))
+ if (gdbarch_tdep (gdbarch)->pc_in_sigtramp (pc, name))
return &alpha_sigtramp_frame_unwind;
return NULL;
return_reg = ALPHA_RA_REGNUM;
info->return_reg = return_reg;
- frame_unwind_unsigned_register (next_frame, frame_reg, &val);
+ val = frame_unwind_register_unsigned (next_frame, frame_reg);
info->vfp = val + frame_size;
/* Convert offsets to absolute addresses. See above about adding
alpha_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
ULONGEST base;
- frame_unwind_unsigned_register (next_frame, ALPHA_SP_REGNUM, &base);
+ base = frame_unwind_register_unsigned (next_frame, ALPHA_SP_REGNUM);
return frame_id_build (base, frame_pc_unwind (next_frame));
}
alpha_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
ULONGEST pc;
- frame_unwind_unsigned_register (next_frame, ALPHA_PC_REGNUM, &pc);
+ pc = frame_unwind_register_unsigned (next_frame, ALPHA_PC_REGNUM);
return pc;
}
targets don't supply this value in their core files. */
void
-alpha_supply_int_regs (int regno, const void *r0_r30,
- const void *pc, const void *unique)
+alpha_supply_int_regs (struct regcache *regcache, int regno,
+ const void *r0_r30, const void *pc, const void *unique)
{
const gdb_byte *regs = r0_r30;
int i;
for (i = 0; i < 31; ++i)
if (regno == i || regno == -1)
- regcache_raw_supply (current_regcache, i, regs + i * 8);
+ regcache_raw_supply (regcache, i, regs + i * 8);
if (regno == ALPHA_ZERO_REGNUM || regno == -1)
- regcache_raw_supply (current_regcache, ALPHA_ZERO_REGNUM, NULL);
+ regcache_raw_supply (regcache, ALPHA_ZERO_REGNUM, NULL);
if (regno == ALPHA_PC_REGNUM || regno == -1)
- regcache_raw_supply (current_regcache, ALPHA_PC_REGNUM, pc);
+ regcache_raw_supply (regcache, ALPHA_PC_REGNUM, pc);
if (regno == ALPHA_UNIQUE_REGNUM || regno == -1)
- regcache_raw_supply (current_regcache, ALPHA_UNIQUE_REGNUM, unique);
+ regcache_raw_supply (regcache, ALPHA_UNIQUE_REGNUM, unique);
}
void
-alpha_fill_int_regs (int regno, void *r0_r30, void *pc, void *unique)
+alpha_fill_int_regs (const struct regcache *regcache,
+ int regno, void *r0_r30, void *pc, void *unique)
{
gdb_byte *regs = r0_r30;
int i;
for (i = 0; i < 31; ++i)
if (regno == i || regno == -1)
- regcache_raw_collect (current_regcache, i, regs + i * 8);
+ regcache_raw_collect (regcache, i, regs + i * 8);
if (regno == ALPHA_PC_REGNUM || regno == -1)
- regcache_raw_collect (current_regcache, ALPHA_PC_REGNUM, pc);
+ regcache_raw_collect (regcache, ALPHA_PC_REGNUM, pc);
if (unique && (regno == ALPHA_UNIQUE_REGNUM || regno == -1))
- regcache_raw_collect (current_regcache, ALPHA_UNIQUE_REGNUM, unique);
+ regcache_raw_collect (regcache, ALPHA_UNIQUE_REGNUM, unique);
}
void
-alpha_supply_fp_regs (int regno, const void *f0_f30, const void *fpcr)
+alpha_supply_fp_regs (struct regcache *regcache, int regno,
+ const void *f0_f30, const void *fpcr)
{
const gdb_byte *regs = f0_f30;
int i;
for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
if (regno == i || regno == -1)
- regcache_raw_supply (current_regcache, i,
+ regcache_raw_supply (regcache, i,
regs + (i - ALPHA_FP0_REGNUM) * 8);
if (regno == ALPHA_FPCR_REGNUM || regno == -1)
- regcache_raw_supply (current_regcache, ALPHA_FPCR_REGNUM, fpcr);
+ regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, fpcr);
}
void
-alpha_fill_fp_regs (int regno, void *f0_f30, void *fpcr)
+alpha_fill_fp_regs (const struct regcache *regcache,
+ int regno, void *f0_f30, void *fpcr)
{
gdb_byte *regs = f0_f30;
int i;
for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
if (regno == i || regno == -1)
- regcache_raw_collect (current_regcache, i,
+ regcache_raw_collect (regcache, i,
regs + (i - ALPHA_FP0_REGNUM) * 8);
if (regno == ALPHA_FPCR_REGNUM || regno == -1)
- regcache_raw_collect (current_regcache, ALPHA_FPCR_REGNUM, fpcr);
+ regcache_raw_collect (regcache, ALPHA_FPCR_REGNUM, fpcr);
}
\f
the target of the coming instruction and breakpoint it. */
static CORE_ADDR
-alpha_next_pc (CORE_ADDR pc)
+alpha_next_pc (struct frame_info *frame, CORE_ADDR pc)
{
unsigned int insn;
unsigned int op;
int regno;
int offset;
LONGEST rav;
- gdb_byte reg[ALPHA_REGISTER_SIZE];
insn = alpha_read_insn (pc);
{
/* Jump format: target PC is:
RB & ~3 */
- return (read_register ((insn >> 16) & 0x1f) & ~3);
+ return (get_frame_register_unsigned (frame, (insn >> 16) & 0x1f) & ~3);
}
if ((op & 0x30) == 0x30)
case 0x33: /* FBLE */
case 0x32: /* FBLT */
case 0x35: /* FBNE */
- regno += FP0_REGNUM;
+ regno += gdbarch_fp0_regnum (get_frame_arch (frame));
}
- regcache_cooked_read (current_regcache, regno, reg);
- rav = extract_signed_integer (reg, ALPHA_REGISTER_SIZE);
+ rav = get_frame_register_signed (frame, regno);
switch (op)
{
}
int
-alpha_software_single_step (struct regcache *regcache)
+alpha_software_single_step (struct frame_info *frame)
{
CORE_ADDR pc, next_pc;
- pc = read_pc ();
- next_pc = alpha_next_pc (pc);
+ pc = get_frame_pc (frame);
+ next_pc = alpha_next_pc (frame, pc);
insert_single_step_breakpoint (next_pc);
return 1;