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"
{
/* 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 (current_gdbarch, regnum) == NULL
+ || *gdbarch_register_name (current_gdbarch, regnum) == '\0')
return 0;
if (group == all_reggroup)
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))
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 (current_gdbarch);
}
- 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;
projects / deliverable / binutils-gdb.git / blobdiff