This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
Re: [rfc][0/13] Eliminate read_register et al
- From: "Ulrich Weigand" <uweigand at de dot ibm dot com>
- To: uweigand at de dot ibm dot com (Ulrich Weigand)
- Cc: gdb-patches at sourceware dot org
- Date: Sat, 16 Jun 2007 00:50:46 +0200 (CEST)
- Subject: Re: [rfc][0/13] Eliminate read_register et al
> The patch set consists of 13 parts:
>
> First some special read_register et al uses:
> [1/13] write_register in solib-sunos.c
> [2/13] read_register in cris/frv_stopped_data_address
> [3/13] read_register in mep-tdep.c current_ routines
> [4/13] read_register in deprecated_mips_set_processor_regs_hack
> [5/13] read_register in sh_show_regs_command
> [6/13] read_register (invalidly) used in prologue analyzers
>
> Then more general classes of uses:
> [7/13] Uses that are already unnecessary
> [8/13] Uses in software_single_step callbacks
> [9/13] Uses in skip_trampoline callbacks
> [10/13] Uses in get_longjmp_target callbacks
> [11/13] Uses in push_dummy_code callbacks
> [12/13] Uses in read_pc / write_pc callbacks
>
> And finally:
> [13/13] Remove definition
I've now checked in the full patch set, adapted for intervening
mainline changed. FYI below the combined patch as checked in.
Bye,
Ulrich
diff -urNp gdb-orig/gdb/alpha-tdep.c gdb-head/gdb/alpha-tdep.c
--- gdb-orig/gdb/alpha-tdep.c 2007-06-16 00:20:40.499289888 +0200
+++ gdb-head/gdb/alpha-tdep.c 2007-06-16 00:18:54.464475800 +0200
@@ -724,13 +724,13 @@ alpha_skip_prologue (CORE_ADDR pc)
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))
@@ -1398,14 +1398,13 @@ fp_register_sign_bit (LONGEST reg)
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);
@@ -1416,7 +1415,7 @@ alpha_next_pc (CORE_ADDR 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)
@@ -1447,8 +1446,7 @@ alpha_next_pc (CORE_ADDR pc)
regno += FP0_REGNUM;
}
- regcache_cooked_read (current_regcache, regno, reg);
- rav = extract_signed_integer (reg, ALPHA_REGISTER_SIZE);
+ rav = get_frame_register_signed (frame, regno);
switch (op)
{
@@ -1520,12 +1518,12 @@ alpha_next_pc (CORE_ADDR pc)
}
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;
diff -urNp gdb-orig/gdb/alpha-tdep.h gdb-head/gdb/alpha-tdep.h
--- gdb-orig/gdb/alpha-tdep.h 2007-06-16 00:20:40.503289312 +0200
+++ gdb-head/gdb/alpha-tdep.h 2007-06-16 00:18:45.878381886 +0200
@@ -109,7 +109,7 @@ struct gdbarch_tdep
};
extern unsigned int alpha_read_insn (CORE_ADDR pc);
-extern int alpha_software_single_step (struct regcache *regcache);
+extern int alpha_software_single_step (struct frame_info *frame);
extern CORE_ADDR alpha_after_prologue (CORE_ADDR pc);
extern void alpha_mdebug_init_abi (struct gdbarch_info, struct gdbarch *);
diff -urNp gdb-orig/gdb/amd64-linux-tdep.c gdb-head/gdb/amd64-linux-tdep.c
--- gdb-orig/gdb/amd64-linux-tdep.c 2007-06-15 23:58:40.956942000 +0200
+++ gdb-head/gdb/amd64-linux-tdep.c 2007-06-16 00:20:17.637126848 +0200
@@ -237,9 +237,9 @@ amd64_linux_register_reggroup_p (struct
/* Set the program counter for process PTID to PC. */
static void
-amd64_linux_write_pc (CORE_ADDR pc, ptid_t ptid)
+amd64_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- write_register_pid (AMD64_RIP_REGNUM, pc, ptid);
+ regcache_cooked_write_unsigned (regcache, AMD64_RIP_REGNUM, pc);
/* We must be careful with modifying the program counter. If we
just interrupted a system call, the kernel might try to restart
@@ -255,7 +255,7 @@ amd64_linux_write_pc (CORE_ADDR pc, ptid
when we resume the inferior on return from a function call from
within GDB. In all other cases the system call will not be
restarted. */
- write_register_pid (AMD64_LINUX_ORIG_RAX_REGNUM, -1, ptid);
+ regcache_cooked_write_unsigned (regcache, AMD64_LINUX_ORIG_RAX_REGNUM, -1);
}
static void
diff -urNp gdb-orig/gdb/arch-utils.c gdb-head/gdb/arch-utils.c
--- gdb-orig/gdb/arch-utils.c 2007-06-16 00:20:38.032247703 +0200
+++ gdb-head/gdb/arch-utils.c 2007-06-16 00:18:49.439401678 +0200
@@ -96,7 +96,7 @@ legacy_register_sim_regno (int regnum)
}
CORE_ADDR
-generic_skip_trampoline_code (CORE_ADDR pc)
+generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
return 0;
}
diff -urNp gdb-orig/gdb/arch-utils.h gdb-head/gdb/arch-utils.h
--- gdb-orig/gdb/arch-utils.h 2007-06-16 00:20:38.036247127 +0200
+++ gdb-head/gdb/arch-utils.h 2007-06-16 00:18:49.444400958 +0200
@@ -77,7 +77,8 @@ int cannot_register_not (int regnum);
extern gdbarch_virtual_frame_pointer_ftype legacy_virtual_frame_pointer;
-extern CORE_ADDR generic_skip_trampoline_code (CORE_ADDR pc);
+extern CORE_ADDR generic_skip_trampoline_code (struct frame_info *frame,
+ CORE_ADDR pc);
extern CORE_ADDR generic_skip_solib_resolver (struct gdbarch *gdbarch,
CORE_ADDR pc);
diff -urNp gdb-orig/gdb/arm-tdep.c gdb-head/gdb/arm-tdep.c
--- gdb-orig/gdb/arm-tdep.c 2007-06-16 00:20:44.981309056 +0200
+++ gdb-head/gdb/arm-tdep.c 2007-06-16 00:20:17.646125552 +0200
@@ -1363,7 +1363,7 @@ static void
arm_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
struct frame_info *frame, const char *args)
{
- unsigned long status = read_register (ARM_FPS_REGNUM);
+ unsigned long status = get_frame_register_unsigned (frame, ARM_FPS_REGNUM);
int type;
type = (status >> 24) & 127;
@@ -1547,8 +1547,8 @@ condition_true (unsigned long cond, unsi
#define ARM_PC_32 1
static unsigned long
-shifted_reg_val (unsigned long inst, int carry, unsigned long pc_val,
- unsigned long status_reg)
+shifted_reg_val (struct frame_info *frame, unsigned long inst, int carry,
+ unsigned long pc_val, unsigned long status_reg)
{
unsigned long res, shift;
int rm = bits (inst, 0, 3);
@@ -1557,7 +1557,8 @@ shifted_reg_val (unsigned long inst, int
if (bit (inst, 4))
{
int rs = bits (inst, 8, 11);
- shift = (rs == 15 ? pc_val + 8 : read_register (rs)) & 0xFF;
+ shift = (rs == 15 ? pc_val + 8
+ : get_frame_register_unsigned (frame, rs)) & 0xFF;
}
else
shift = bits (inst, 7, 11);
@@ -1565,7 +1566,7 @@ shifted_reg_val (unsigned long inst, int
res = (rm == 15
? ((pc_val | (ARM_PC_32 ? 0 : status_reg))
+ (bit (inst, 4) ? 12 : 8))
- : read_register (rm));
+ : get_frame_register_unsigned (frame, rm));
switch (shifttype)
{
@@ -1608,7 +1609,7 @@ bitcount (unsigned long val)
}
static CORE_ADDR
-thumb_get_next_pc (CORE_ADDR pc)
+thumb_get_next_pc (struct frame_info *frame, CORE_ADDR pc)
{
unsigned long pc_val = ((unsigned long) pc) + 4; /* PC after prefetch */
unsigned short inst1 = read_memory_unsigned_integer (pc, 2);
@@ -1622,7 +1623,7 @@ thumb_get_next_pc (CORE_ADDR pc)
/* Fetch the saved PC from the stack. It's stored above
all of the other registers. */
offset = bitcount (bits (inst1, 0, 7)) * DEPRECATED_REGISTER_SIZE;
- sp = read_register (ARM_SP_REGNUM);
+ sp = get_frame_register_unsigned (frame, ARM_SP_REGNUM);
nextpc = (CORE_ADDR) read_memory_unsigned_integer (sp + offset, 4);
nextpc = gdbarch_addr_bits_remove (current_gdbarch, nextpc);
if (nextpc == pc)
@@ -1630,7 +1631,7 @@ thumb_get_next_pc (CORE_ADDR pc)
}
else if ((inst1 & 0xf000) == 0xd000) /* conditional branch */
{
- unsigned long status = read_register (ARM_PS_REGNUM);
+ unsigned long status = get_frame_register_unsigned (frame, ARM_PS_REGNUM);
unsigned long cond = bits (inst1, 8, 11);
if (cond != 0x0f && condition_true (cond, status)) /* 0x0f = SWI */
nextpc = pc_val + (sbits (inst1, 0, 7) << 1);
@@ -1653,7 +1654,7 @@ thumb_get_next_pc (CORE_ADDR pc)
if (bits (inst1, 3, 6) == 0x0f)
nextpc = pc_val;
else
- nextpc = read_register (bits (inst1, 3, 6));
+ nextpc = get_frame_register_unsigned (frame, bits (inst1, 3, 6));
nextpc = gdbarch_addr_bits_remove (current_gdbarch, nextpc);
if (nextpc == pc)
@@ -1664,7 +1665,7 @@ thumb_get_next_pc (CORE_ADDR pc)
}
static CORE_ADDR
-arm_get_next_pc (CORE_ADDR pc)
+arm_get_next_pc (struct frame_info *frame, CORE_ADDR pc)
{
unsigned long pc_val;
unsigned long this_instr;
@@ -1672,11 +1673,11 @@ arm_get_next_pc (CORE_ADDR pc)
CORE_ADDR nextpc;
if (arm_pc_is_thumb (pc))
- return thumb_get_next_pc (pc);
+ return thumb_get_next_pc (frame, pc);
pc_val = (unsigned long) pc;
this_instr = read_memory_unsigned_integer (pc, 4);
- status = read_register (ARM_PS_REGNUM);
+ status = get_frame_register_unsigned (frame, ARM_PS_REGNUM);
nextpc = (CORE_ADDR) (pc_val + 4); /* Default case */
if (condition_true (bits (this_instr, 28, 31), status))
@@ -1704,7 +1705,8 @@ arm_get_next_pc (CORE_ADDR pc)
|| bits (this_instr, 4, 27) == 0x12fff3)
{
rn = bits (this_instr, 0, 3);
- result = (rn == 15) ? pc_val + 8 : read_register (rn);
+ result = (rn == 15) ? pc_val + 8
+ : get_frame_register_unsigned (frame, rn);
nextpc = (CORE_ADDR) gdbarch_addr_bits_remove
(current_gdbarch, result);
@@ -1717,7 +1719,8 @@ arm_get_next_pc (CORE_ADDR pc)
/* Multiply into PC */
c = (status & FLAG_C) ? 1 : 0;
rn = bits (this_instr, 16, 19);
- operand1 = (rn == 15) ? pc_val + 8 : read_register (rn);
+ operand1 = (rn == 15) ? pc_val + 8
+ : get_frame_register_unsigned (frame, rn);
if (bit (this_instr, 25))
{
@@ -1727,7 +1730,7 @@ arm_get_next_pc (CORE_ADDR pc)
& 0xffffffff;
}
else /* operand 2 is a shifted register */
- operand2 = shifted_reg_val (this_instr, c, pc_val, status);
+ operand2 = shifted_reg_val (frame, this_instr, c, pc_val, status);
switch (bits (this_instr, 21, 24))
{
@@ -1813,14 +1816,15 @@ arm_get_next_pc (CORE_ADDR pc)
/* byte write to PC */
rn = bits (this_instr, 16, 19);
- base = (rn == 15) ? pc_val + 8 : read_register (rn);
+ base = (rn == 15) ? pc_val + 8
+ : get_frame_register_unsigned (frame, rn);
if (bit (this_instr, 24))
{
/* pre-indexed */
int c = (status & FLAG_C) ? 1 : 0;
unsigned long offset =
(bit (this_instr, 25)
- ? shifted_reg_val (this_instr, c, pc_val, status)
+ ? shifted_reg_val (frame, this_instr, c, pc_val, status)
: bits (this_instr, 0, 11));
if (bit (this_instr, 23))
@@ -1862,7 +1866,8 @@ arm_get_next_pc (CORE_ADDR pc)
{
unsigned long rn_val =
- read_register (bits (this_instr, 16, 19));
+ get_frame_register_unsigned (frame,
+ bits (this_instr, 16, 19));
nextpc =
(CORE_ADDR) read_memory_integer ((CORE_ADDR) (rn_val
+ offset),
@@ -1912,13 +1917,13 @@ arm_get_next_pc (CORE_ADDR pc)
and breakpoint it. */
int
-arm_software_single_step (struct regcache *regcache)
+arm_software_single_step (struct frame_info *frame)
{
/* NOTE: This may insert the wrong breakpoint instruction when
single-stepping over a mode-changing instruction, if the
CPSR heuristics are used. */
- CORE_ADDR next_pc = arm_get_next_pc (read_register (ARM_PC_REGNUM));
+ CORE_ADDR next_pc = arm_get_next_pc (frame, get_frame_pc (frame));
insert_single_step_breakpoint (next_pc);
return 1;
@@ -2337,13 +2342,13 @@ arm_return_value (struct gdbarch *gdbarc
static int
-arm_get_longjmp_target (CORE_ADDR *pc)
+arm_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
char buf[INT_REGISTER_SIZE];
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
- jb_addr = read_register (ARM_A1_REGNUM);
+ jb_addr = get_frame_register_unsigned (frame, ARM_A1_REGNUM);
if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
INT_REGISTER_SIZE))
@@ -2375,7 +2380,7 @@ arm_in_call_stub (CORE_ADDR pc, char *na
are r0-r9, sl, fp, ip, sp, and lr. */
CORE_ADDR
-arm_skip_stub (CORE_ADDR pc)
+arm_skip_stub (struct frame_info *frame, CORE_ADDR pc)
{
char *name;
CORE_ADDR start_addr;
@@ -2397,7 +2402,7 @@ arm_skip_stub (CORE_ADDR pc)
for (regno = 0; regno <= 14; regno++)
if (strcmp (&name[10], table[regno]) == 0)
- return read_register (regno);
+ return get_frame_register_unsigned (frame, regno);
}
return 0; /* not a stub */
@@ -2583,18 +2588,20 @@ arm_coff_make_msymbol_special(int val, s
}
static void
-arm_write_pc (CORE_ADDR pc, ptid_t ptid)
+arm_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- write_register_pid (ARM_PC_REGNUM, pc, ptid);
+ regcache_cooked_write_unsigned (regcache, ARM_PC_REGNUM, pc);
/* If necessary, set the T bit. */
if (arm_apcs_32)
{
- CORE_ADDR val = read_register_pid (ARM_PS_REGNUM, ptid);
+ ULONGEST val;
+ regcache_cooked_read_unsigned (regcache, ARM_PS_REGNUM, &val);
if (arm_pc_is_thumb (pc))
- write_register_pid (ARM_PS_REGNUM, val | 0x20, ptid);
+ regcache_cooked_write_unsigned (regcache, ARM_PS_REGNUM, val | 0x20);
else
- write_register_pid (ARM_PS_REGNUM, val & ~(CORE_ADDR) 0x20, ptid);
+ regcache_cooked_write_unsigned (regcache, ARM_PS_REGNUM,
+ val & ~(ULONGEST) 0x20);
}
}
diff -urNp gdb-orig/gdb/arm-tdep.h gdb-head/gdb/arm-tdep.h
--- gdb-orig/gdb/arm-tdep.h 2007-06-16 00:20:40.520286864 +0200
+++ gdb-head/gdb/arm-tdep.h 2007-06-16 00:18:45.894379582 +0200
@@ -182,7 +182,7 @@ struct gdbarch_tdep
#define LOWEST_PC (gdbarch_tdep (current_gdbarch)->lowest_pc)
#endif
-int arm_software_single_step (struct regcache *);
+int arm_software_single_step (struct frame_info *);
/* Functions exported from armbsd-tdep.h. */
diff -urNp gdb-orig/gdb/avr-tdep.c gdb-head/gdb/avr-tdep.c
--- gdb-orig/gdb/avr-tdep.c 2007-06-16 00:20:44.987308192 +0200
+++ gdb-head/gdb/avr-tdep.c 2007-06-16 00:20:17.653124544 +0200
@@ -312,29 +312,18 @@ avr_pointer_to_address (struct type *typ
}
static CORE_ADDR
-avr_read_pc (ptid_t ptid)
+avr_read_pc (struct regcache *regcache)
{
- ptid_t save_ptid;
ULONGEST pc;
- CORE_ADDR retval;
-
- save_ptid = inferior_ptid;
- inferior_ptid = ptid;
- regcache_cooked_read_unsigned (current_regcache, AVR_PC_REGNUM, &pc);
- inferior_ptid = save_ptid;
- retval = avr_make_iaddr (pc);
- return retval;
+ regcache_cooked_read_unsigned (regcache, AVR_PC_REGNUM, &pc);
+ return avr_make_iaddr (pc);
}
static void
-avr_write_pc (CORE_ADDR val, ptid_t ptid)
+avr_write_pc (struct regcache *regcache, CORE_ADDR val)
{
- ptid_t save_ptid;
-
- save_ptid = inferior_ptid;
- inferior_ptid = ptid;
- write_register (AVR_PC_REGNUM, avr_convert_iaddr_to_raw (val));
- inferior_ptid = save_ptid;
+ regcache_cooked_write_unsigned (regcache, AVR_PC_REGNUM,
+ avr_convert_iaddr_to_raw (val));
}
static int
@@ -1163,8 +1152,8 @@ avr_push_dummy_call (struct gdbarch *gdb
if (struct_return)
{
fprintf_unfiltered (gdb_stderr, "struct_return: 0x%lx\n", struct_addr);
- write_register (argreg--, struct_addr & 0xff);
- write_register (argreg--, (struct_addr >>8) & 0xff);
+ regcache_cooked_write_unsigned (regcache, argreg--, struct_addr & 0xff);
+ regcache_cooked_write_unsigned (regcache, argreg--, (struct_addr >>8) & 0xff);
}
#endif
diff -urNp gdb-orig/gdb/cp-abi.c gdb-head/gdb/cp-abi.c
--- gdb-orig/gdb/cp-abi.c 2007-06-16 00:20:38.051244967 +0200
+++ gdb-head/gdb/cp-abi.c 2007-06-16 00:18:49.459398798 +0200
@@ -122,11 +122,11 @@ cplus_make_method_ptr (gdb_byte *content
}
CORE_ADDR
-cplus_skip_trampoline (CORE_ADDR stop_pc)
+cplus_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
{
if (current_cp_abi.skip_trampoline == NULL)
return 0;
- return (*current_cp_abi.skip_trampoline) (stop_pc);
+ return (*current_cp_abi.skip_trampoline) (frame, stop_pc);
}
struct value *
diff -urNp gdb-orig/gdb/cp-abi.h gdb-head/gdb/cp-abi.h
--- gdb-orig/gdb/cp-abi.h 2007-06-16 00:20:38.055244391 +0200
+++ gdb-head/gdb/cp-abi.h 2007-06-16 00:18:49.463398222 +0200
@@ -31,6 +31,7 @@ struct fn_field;
struct type;
struct value;
struct ui_file;
+struct frame_info;
/* The functions here that attempt to determine what sort of thing a
mangled name refers to may well be revised in the future. It would
@@ -173,7 +174,7 @@ void cplus_make_method_ptr (gdb_byte *CO
/* Determine if we are currently in a C++ thunk. If so, get the address
of the routine we are thunking to and continue to there instead. */
-CORE_ADDR cplus_skip_trampoline (CORE_ADDR stop_pc);
+CORE_ADDR cplus_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc);
struct cp_abi_ops
{
@@ -197,7 +198,7 @@ struct cp_abi_ops
int (*method_ptr_size) (void);
void (*make_method_ptr) (gdb_byte *, CORE_ADDR, int);
struct value * (*method_ptr_to_value) (struct value **, struct value *);
- CORE_ADDR (*skip_trampoline) (CORE_ADDR);
+ CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
};
diff -urNp gdb-orig/gdb/cris-tdep.c gdb-head/gdb/cris-tdep.c
--- gdb-orig/gdb/cris-tdep.c 2007-06-16 00:21:05.635391184 +0200
+++ gdb-head/gdb/cris-tdep.c 2007-06-16 00:20:13.385075415 +0200
@@ -535,7 +535,7 @@ CORE_ADDR
cris_stopped_data_address (void)
{
CORE_ADDR eda;
- eda = read_register (EDA_REGNUM);
+ eda = get_frame_register_unsigned (get_current_frame (), EDA_REGNUM);
return eda;
}
@@ -868,7 +868,8 @@ cris_push_dummy_code (struct gdbarch *gd
CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
struct value **args, int nargs,
struct type *value_type,
- CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+ CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
+ struct regcache *regcache)
{
/* Allocate space sufficient for a breakpoint. */
sp = (sp - 4) & ~3;
@@ -2059,7 +2060,7 @@ find_cris_op (unsigned short insn, inst_
actually an internal error. */
static int
-find_step_target (inst_env_type *inst_env)
+find_step_target (struct frame_info *frame, inst_env_type *inst_env)
{
int i;
int offset;
@@ -2068,12 +2069,14 @@ find_step_target (inst_env_type *inst_en
/* Create a local register image and set the initial state. */
for (i = 0; i < NUM_GENREGS; i++)
{
- inst_env->reg[i] = (unsigned long) read_register (i);
+ inst_env->reg[i] =
+ (unsigned long) get_frame_register_unsigned (frame, i);
}
offset = NUM_GENREGS;
for (i = 0; i < NUM_SPECREGS; i++)
{
- inst_env->preg[i] = (unsigned long) read_register (offset + i);
+ inst_env->preg[i] =
+ (unsigned long) get_frame_register_unsigned (frame, offset + i);
}
inst_env->branch_found = 0;
inst_env->slot_needed = 0;
@@ -2124,13 +2127,13 @@ find_step_target (inst_env_type *inst_en
Either one ordinary target or two targets for branches may be found. */
static int
-cris_software_single_step (struct regcache *regcache)
+cris_software_single_step (struct frame_info *frame)
{
inst_env_type inst_env;
/* Analyse the present instruction environment and insert
breakpoints. */
- int status = find_step_target (&inst_env);
+ int status = find_step_target (frame, &inst_env);
if (status == -1)
{
/* Could not find a target. Things are likely to go downhill
diff -urNp gdb-orig/gdb/frv-tdep.c gdb-head/gdb/frv-tdep.c
--- gdb-orig/gdb/frv-tdep.c 2007-06-16 00:21:05.642390176 +0200
+++ gdb-head/gdb/frv-tdep.c 2007-06-16 00:20:17.660123536 +0200
@@ -1291,13 +1291,14 @@ frv_check_watch_resources (int type, int
int
frv_stopped_data_address (CORE_ADDR *addr_p)
{
+ struct frame_info *frame = get_current_frame ();
CORE_ADDR brr, dbar0, dbar1, dbar2, dbar3;
- brr = read_register (brr_regnum);
- dbar0 = read_register (dbar0_regnum);
- dbar1 = read_register (dbar1_regnum);
- dbar2 = read_register (dbar2_regnum);
- dbar3 = read_register (dbar3_regnum);
+ brr = get_frame_register_unsigned (frame, brr_regnum);
+ dbar0 = get_frame_register_unsigned (frame, dbar0_regnum);
+ dbar1 = get_frame_register_unsigned (frame, dbar1_regnum);
+ dbar2 = get_frame_register_unsigned (frame, dbar2_regnum);
+ dbar3 = get_frame_register_unsigned (frame, dbar3_regnum);
if (brr & (1<<11))
*addr_p = dbar0;
@@ -1516,8 +1517,6 @@ frv_gdbarch_init (struct gdbarch_info in
/* Settings that should be unnecessary. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
- set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-
/* Hardware watchpoint / breakpoint support. */
switch (info.bfd_arch_info->mach)
{
diff -urNp gdb-orig/gdb/gdbarch.c gdb-head/gdb/gdbarch.c
--- gdb-orig/gdb/gdbarch.c 2007-06-16 00:20:40.544283408 +0200
+++ gdb-head/gdb/gdbarch.c 2007-06-16 00:20:17.674121520 +0200
@@ -406,7 +406,6 @@ gdbarch_alloc (const struct gdbarch_info
current_gdbarch->ptr_bit = current_gdbarch->int_bit;
current_gdbarch->bfd_vma_bit = gdbarch_bfd_arch_info (current_gdbarch)->bits_per_address;
current_gdbarch->char_signed = -1;
- current_gdbarch->write_pc = generic_target_write_pc;
current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
current_gdbarch->num_regs = -1;
current_gdbarch->sp_regnum = -1;
@@ -524,7 +523,7 @@ verify_gdbarch (struct gdbarch *current_
if (current_gdbarch->char_signed == -1)
current_gdbarch->char_signed = 1;
/* Skip verify of read_pc, has predicate */
- /* Skip verify of write_pc, invalid_p == 0 */
+ /* Skip verify of write_pc, has predicate */
/* Skip verify of virtual_frame_pointer, invalid_p == 0 */
/* Skip verify of pseudo_register_read, has predicate */
/* Skip verify of pseudo_register_write, has predicate */
@@ -1006,21 +1005,9 @@ gdbarch_dump (struct gdbarch *current_gd
fprintf_unfiltered (file,
"gdbarch_dump: push_dummy_code = <0x%lx>\n",
(long) current_gdbarch->push_dummy_code);
-#ifdef TARGET_READ_PC_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "TARGET_READ_PC_P()",
- XSTRING (TARGET_READ_PC_P ()));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_read_pc_p() = %d\n",
gdbarch_read_pc_p (current_gdbarch));
-#ifdef TARGET_READ_PC
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "TARGET_READ_PC(ptid)",
- XSTRING (TARGET_READ_PC (ptid)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: read_pc = <0x%lx>\n",
(long) current_gdbarch->read_pc);
@@ -1099,8 +1086,8 @@ gdbarch_dump (struct gdbarch *current_gd
#ifdef SOFTWARE_SINGLE_STEP
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
- "SOFTWARE_SINGLE_STEP(regcache)",
- XSTRING (SOFTWARE_SINGLE_STEP (regcache)));
+ "SOFTWARE_SINGLE_STEP(frame)",
+ XSTRING (SOFTWARE_SINGLE_STEP (frame)));
#endif
fprintf_unfiltered (file,
"gdbarch_dump: software_single_step = <0x%lx>\n",
@@ -1164,12 +1151,9 @@ gdbarch_dump (struct gdbarch *current_gd
fprintf_unfiltered (file,
"gdbarch_dump: vtable_function_descriptors = %s\n",
paddr_d (current_gdbarch->vtable_function_descriptors));
-#ifdef TARGET_WRITE_PC
fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "TARGET_WRITE_PC(val, ptid)",
- XSTRING (TARGET_WRITE_PC (val, ptid)));
-#endif
+ "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
+ gdbarch_write_pc_p (current_gdbarch));
fprintf_unfiltered (file,
"gdbarch_dump: write_pc = <0x%lx>\n",
(long) current_gdbarch->write_pc);
@@ -1467,13 +1451,13 @@ gdbarch_read_pc_p (struct gdbarch *gdbar
}
CORE_ADDR
-gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
+gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->read_pc != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
- return gdbarch->read_pc (ptid);
+ return gdbarch->read_pc (regcache);
}
void
@@ -1483,14 +1467,21 @@ set_gdbarch_read_pc (struct gdbarch *gdb
gdbarch->read_pc = read_pc;
}
+int
+gdbarch_write_pc_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->write_pc != NULL;
+}
+
void
-gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
+gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->write_pc != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
- gdbarch->write_pc (val, ptid);
+ gdbarch->write_pc (regcache, val);
}
void
@@ -1900,13 +1891,13 @@ gdbarch_push_dummy_code_p (struct gdbarc
}
CORE_ADDR
-gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->push_dummy_code != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
- return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
+ return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr, regcache);
}
void
@@ -2040,13 +2031,13 @@ gdbarch_get_longjmp_target_p (struct gdb
}
int
-gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
+gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->get_longjmp_target != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
- return gdbarch->get_longjmp_target (pc);
+ return gdbarch->get_longjmp_target (frame, pc);
}
void
@@ -2711,13 +2702,13 @@ gdbarch_software_single_step_p (struct g
}
int
-gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache)
+gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->software_single_step != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
- return gdbarch->software_single_step (regcache);
+ return gdbarch->software_single_step (frame);
}
void
@@ -2769,13 +2760,13 @@ set_gdbarch_print_insn (struct gdbarch *
}
CORE_ADDR
-gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
+gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->skip_trampoline_code != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
- return gdbarch->skip_trampoline_code (pc);
+ return gdbarch->skip_trampoline_code (frame, pc);
}
void
diff -urNp gdb-orig/gdb/gdbarch.h gdb-head/gdb/gdbarch.h
--- gdb-orig/gdb/gdbarch.h 2007-06-16 00:20:40.552282256 +0200
+++ gdb-head/gdb/gdbarch.h 2007-06-16 00:20:17.683120224 +0200
@@ -151,40 +151,17 @@ extern void set_gdbarch_bfd_vma_bit (str
extern int gdbarch_char_signed (struct gdbarch *gdbarch);
extern void set_gdbarch_char_signed (struct gdbarch *gdbarch, int char_signed);
-#if defined (TARGET_READ_PC)
-/* Legacy for systems yet to multi-arch TARGET_READ_PC */
-#if !defined (TARGET_READ_PC_P)
-#define TARGET_READ_PC_P() (1)
-#endif
-#endif
-
extern int gdbarch_read_pc_p (struct gdbarch *gdbarch);
-#if !defined (GDB_TM_FILE) && defined (TARGET_READ_PC_P)
-#error "Non multi-arch definition of TARGET_READ_PC"
-#endif
-#if !defined (TARGET_READ_PC_P)
-#define TARGET_READ_PC_P() (gdbarch_read_pc_p (current_gdbarch))
-#endif
-typedef CORE_ADDR (gdbarch_read_pc_ftype) (ptid_t ptid);
-extern CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid);
+typedef CORE_ADDR (gdbarch_read_pc_ftype) (struct regcache *regcache);
+extern CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache);
extern void set_gdbarch_read_pc (struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc);
-#if !defined (GDB_TM_FILE) && defined (TARGET_READ_PC)
-#error "Non multi-arch definition of TARGET_READ_PC"
-#endif
-#if !defined (TARGET_READ_PC)
-#define TARGET_READ_PC(ptid) (gdbarch_read_pc (current_gdbarch, ptid))
-#endif
-typedef void (gdbarch_write_pc_ftype) (CORE_ADDR val, ptid_t ptid);
-extern void gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid);
+extern int gdbarch_write_pc_p (struct gdbarch *gdbarch);
+
+typedef void (gdbarch_write_pc_ftype) (struct regcache *regcache, CORE_ADDR val);
+extern void gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val);
extern void set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc);
-#if !defined (GDB_TM_FILE) && defined (TARGET_WRITE_PC)
-#error "Non multi-arch definition of TARGET_WRITE_PC"
-#endif
-#if !defined (TARGET_WRITE_PC)
-#define TARGET_WRITE_PC(val, ptid) (gdbarch_write_pc (current_gdbarch, val, ptid))
-#endif
/* Function for getting target's idea of a frame pointer. FIXME: GDB's
whole scheme for dealing with "frames" and "frame pointers" needs a
@@ -344,8 +321,8 @@ extern void set_gdbarch_call_dummy_locat
extern int gdbarch_push_dummy_code_p (struct gdbarch *gdbarch);
-typedef CORE_ADDR (gdbarch_push_dummy_code_ftype) (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr);
-extern CORE_ADDR gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr);
+typedef CORE_ADDR (gdbarch_push_dummy_code_ftype) (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache);
+extern CORE_ADDR gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache);
extern void set_gdbarch_push_dummy_code (struct gdbarch *gdbarch, gdbarch_push_dummy_code_ftype *push_dummy_code);
typedef void (gdbarch_print_registers_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all);
@@ -383,8 +360,8 @@ extern void set_gdbarch_cannot_store_reg
extern int gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch);
-typedef int (gdbarch_get_longjmp_target_ftype) (CORE_ADDR *pc);
-extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc);
+typedef int (gdbarch_get_longjmp_target_ftype) (struct frame_info *frame, CORE_ADDR *pc);
+extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc);
extern void set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target);
extern int gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch);
@@ -702,14 +679,14 @@ extern int gdbarch_software_single_step_
#define SOFTWARE_SINGLE_STEP_P() (gdbarch_software_single_step_p (current_gdbarch))
#endif
-typedef int (gdbarch_software_single_step_ftype) (struct regcache *regcache);
-extern int gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache);
+typedef int (gdbarch_software_single_step_ftype) (struct frame_info *frame);
+extern int gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame);
extern void set_gdbarch_software_single_step (struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step);
#if !defined (GDB_TM_FILE) && defined (SOFTWARE_SINGLE_STEP)
#error "Non multi-arch definition of SOFTWARE_SINGLE_STEP"
#endif
#if !defined (SOFTWARE_SINGLE_STEP)
-#define SOFTWARE_SINGLE_STEP(regcache) (gdbarch_software_single_step (current_gdbarch, regcache))
+#define SOFTWARE_SINGLE_STEP(frame) (gdbarch_software_single_step (current_gdbarch, frame))
#endif
/* Return non-zero if the processor is executing a delay slot and a
@@ -734,8 +711,8 @@ extern void set_gdbarch_print_insn (stru
#define TARGET_PRINT_INSN(vma, info) (gdbarch_print_insn (current_gdbarch, vma, info))
#endif
-typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (CORE_ADDR pc);
-extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc);
+typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (struct frame_info *frame, CORE_ADDR pc);
+extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc);
extern void set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code);
/* If IN_SOLIB_DYNSYM_RESOLVE_CODE returns true, and SKIP_SOLIB_RESOLVER
diff -urNp gdb-orig/gdb/gdbarch.sh gdb-head/gdb/gdbarch.sh
--- gdb-orig/gdb/gdbarch.sh 2007-06-16 00:20:40.562280816 +0200
+++ gdb-head/gdb/gdbarch.sh 2007-06-16 00:20:17.692118928 +0200
@@ -420,8 +420,8 @@ v::int:bfd_vma_bit:::8 * sizeof (void*):
# One if \`char' acts like \`signed char', zero if \`unsigned char'.
v::int:char_signed:::1:-1:1
#
-F:TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid
-f:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid:0:generic_target_write_pc::0
+F::CORE_ADDR:read_pc:struct regcache *regcache:regcache
+F::void:write_pc:struct regcache *regcache, CORE_ADDR val:regcache, val
# Function for getting target's idea of a frame pointer. FIXME: GDB's
# whole scheme for dealing with "frames" and "frame pointers" needs a
# serious shakedown.
@@ -472,7 +472,7 @@ M::CORE_ADDR:push_dummy_call:struct valu
# DEPRECATED_REGISTER_SIZE can be deleted.
v:=:int:deprecated_register_size
v::int:call_dummy_location::::AT_ENTRY_POINT::0
-M::CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr:sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr
+M::CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache:sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr, regcache
m::void:print_registers_info:struct ui_file *file, struct frame_info *frame, int regnum, int all:file, frame, regnum, all::default_print_registers_info::0
M::void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
@@ -483,7 +483,7 @@ f::int:register_sim_regno:int reg_nr:reg
f::int:cannot_fetch_register:int regnum:regnum::cannot_register_not::0
f::int:cannot_store_register:int regnum:regnum::cannot_register_not::0
# setjmp/longjmp support.
-F::int:get_longjmp_target:CORE_ADDR *pc:pc
+F::int:get_longjmp_target:struct frame_info *frame, CORE_ADDR *pc:frame, pc
#
v:=:int:believe_pcc_promotion:::::::
#
@@ -608,7 +608,7 @@ f::CORE_ADDR:smash_text_address:CORE_ADD
#
# A return value of 1 means that the software_single_step breakpoints
# were inserted; 0 means they were not.
-F:=:int:software_single_step:struct regcache *regcache:regcache
+F:=:int:software_single_step:struct frame_info *frame:frame
# Return non-zero if the processor is executing a delay slot and a
# further single-step is needed before the instruction finishes.
@@ -616,7 +616,7 @@ M::int:single_step_through_delay:struct
# FIXME: cagney/2003-08-28: Need to find a better way of selecting the
# disassembler. Perhaps objdump can handle it?
f:TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, struct disassemble_info *info:vma, info::0:
-f::CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc::generic_skip_trampoline_code::0
+f::CORE_ADDR:skip_trampoline_code:struct frame_info *frame, CORE_ADDR pc:frame, pc::generic_skip_trampoline_code::0
# If IN_SOLIB_DYNSYM_RESOLVE_CODE returns true, and SKIP_SOLIB_RESOLVER
diff -urNp gdb-orig/gdb/gnu-v3-abi.c gdb-head/gdb/gnu-v3-abi.c
--- gdb-orig/gdb/gnu-v3-abi.c 2007-06-16 00:20:38.092239063 +0200
+++ gdb-head/gdb/gnu-v3-abi.c 2007-06-16 00:18:49.500392894 +0200
@@ -679,14 +679,15 @@ gnuv3_method_ptr_to_value (struct value
of the routine we are thunking to and continue to there instead. */
static CORE_ADDR
-gnuv3_skip_trampoline (CORE_ADDR stop_pc)
+gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
{
CORE_ADDR real_stop_pc, method_stop_pc;
struct minimal_symbol *thunk_sym, *fn_sym;
struct obj_section *section;
char *thunk_name, *fn_name;
- real_stop_pc = gdbarch_skip_trampoline_code (current_gdbarch, stop_pc);
+ real_stop_pc = gdbarch_skip_trampoline_code
+ (current_gdbarch, frame, stop_pc);
if (real_stop_pc == 0)
real_stop_pc = stop_pc;
@@ -710,7 +711,7 @@ gnuv3_skip_trampoline (CORE_ADDR stop_pc
method_stop_pc = SYMBOL_VALUE_ADDRESS (fn_sym);
real_stop_pc = gdbarch_skip_trampoline_code
- (current_gdbarch, method_stop_pc);
+ (current_gdbarch, frame, method_stop_pc);
if (real_stop_pc == 0)
real_stop_pc = method_stop_pc;
diff -urNp gdb-orig/gdb/hppa-hpux-tdep.c gdb-head/gdb/hppa-hpux-tdep.c
--- gdb-orig/gdb/hppa-hpux-tdep.c 2007-06-16 00:20:38.098238199 +0200
+++ gdb-head/gdb/hppa-hpux-tdep.c 2007-06-16 00:20:17.701117632 +0200
@@ -299,7 +299,7 @@ hppa_hpux_in_solib_return_trampoline (CO
used in dynamic executables. */
static CORE_ADDR
-hppa_hpux_skip_trampoline_code (CORE_ADDR pc)
+hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
long orig_pc = pc;
long prev_inst, curr_inst, loc;
@@ -310,7 +310,7 @@ hppa_hpux_skip_trampoline_code (CORE_ADD
of the function. So we may have to do something special. */
if (pc == hppa_symbol_address("$$dyncall"))
{
- pc = (CORE_ADDR) read_register (22);
+ pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
/* If bit 30 (counting from the left) is on, then pc is the address of
the PLT entry for this function, not the address of the function
@@ -321,12 +321,12 @@ hppa_hpux_skip_trampoline_code (CORE_ADD
}
if (pc == hppa_symbol_address("$$dyncall_external"))
{
- pc = (CORE_ADDR) read_register (22);
+ pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
pc = (CORE_ADDR) read_memory_integer
(pc & ~0x3, gdbarch_ptr_bit (current_gdbarch) / 8);
}
else if (pc == hppa_symbol_address("_sr4export"))
- pc = (CORE_ADDR) (read_register (22));
+ pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
/* Get the unwind descriptor corresponding to PC, return zero
if no unwind was found. */
@@ -500,8 +500,11 @@ hppa_hpux_skip_trampoline_code (CORE_ADD
/* Yup. See if the previous instruction loaded
rp from sp - 8. */
if (prev_inst == 0x4bc23ff1)
- return (read_memory_integer
- (read_register (HPPA_SP_REGNUM) - 8, 4)) & ~0x3;
+ {
+ CORE_ADDR sp;
+ sp = get_frame_register_unsigned (frame, HPPA_SP_REGNUM);
+ return read_memory_integer (sp - 8, 4) & ~0x3;
+ }
else
{
warning (_("Unable to find restore of %%rp before bv (%%rp)."));
@@ -515,7 +518,7 @@ hppa_hpux_skip_trampoline_code (CORE_ADD
else if ((curr_inst & 0xffe0f000) == 0xe840d000)
{
return (read_memory_integer
- (read_register (HPPA_SP_REGNUM) - 24,
+ (get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
gdbarch_ptr_bit (current_gdbarch) / 8)) & ~0x3;
}
@@ -528,7 +531,7 @@ hppa_hpux_skip_trampoline_code (CORE_ADD
I guess we could check for the previous instruction being
mtsp %r1,%sr0 if we want to do sanity checking. */
return (read_memory_integer
- (read_register (HPPA_SP_REGNUM) - 24,
+ (get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
gdbarch_ptr_bit (current_gdbarch) / 8)) & ~0x3;
}
@@ -1094,7 +1097,8 @@ hppa_hpux_push_dummy_code (struct gdbarc
CORE_ADDR funcaddr, int using_gcc,
struct value **args, int nargs,
struct type *value_type,
- CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+ CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
+ struct regcache *regcache)
{
CORE_ADDR pc, stubaddr;
int argreg = 0;
@@ -1112,7 +1116,7 @@ hppa_hpux_push_dummy_code (struct gdbarc
/* Intraspace call. */
*bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
*real_pc = funcaddr;
- regcache_cooked_write_unsigned (current_regcache, HPPA_RP_REGNUM, *bp_addr);
+ regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, *bp_addr);
return sp;
}
@@ -1190,18 +1194,18 @@ hppa_hpux_push_dummy_code (struct gdbarc
if (stubaddr == 0)
error (_("Cannot call external function not referenced by application "
"(no import stub).\n"));
- regcache_cooked_write_unsigned (current_regcache, 22, stubaddr);
+ regcache_cooked_write_unsigned (regcache, 22, stubaddr);
write_memory (sp, (char *)&hppa32_tramp, sizeof (hppa32_tramp));
*bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
- regcache_cooked_write_unsigned (current_regcache, 31, *bp_addr);
+ regcache_cooked_write_unsigned (regcache, 31, *bp_addr);
*real_pc = hppa32_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
if (*real_pc == 0)
error (_("Cannot make interspace call from here."));
- regcache_cooked_write_unsigned (current_regcache, argreg, sp);
+ regcache_cooked_write_unsigned (regcache, argreg, sp);
sp += sizeof (hppa32_tramp);
}
@@ -1217,17 +1221,17 @@ hppa_hpux_push_dummy_code (struct gdbarc
/* for hppa64, we don't need to call through a stub; all functions
return via a bve. */
- regcache_cooked_write_unsigned (current_regcache, 22, funcaddr);
+ regcache_cooked_write_unsigned (regcache, 22, funcaddr);
write_memory (sp, (char *)&hppa64_tramp, sizeof (hppa64_tramp));
*bp_addr = pc - 4;
- regcache_cooked_write_unsigned (current_regcache, 31, *bp_addr);
+ regcache_cooked_write_unsigned (regcache, 31, *bp_addr);
*real_pc = hppa64_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
if (*real_pc == 0)
error (_("Cannot make interspace call from here."));
- regcache_cooked_write_unsigned (current_regcache, argreg, sp);
+ regcache_cooked_write_unsigned (regcache, argreg, sp);
sp += sizeof (hppa64_tramp);
}
@@ -1368,29 +1372,33 @@ hppa_hpux_regset_from_core_section (stru
#define HPPA_HPUX_SS_INSYSCALL 0x02
static CORE_ADDR
-hppa_hpux_read_pc (ptid_t ptid)
+hppa_hpux_read_pc (struct regcache *regcache)
{
ULONGEST flags;
/* If we're currently in a system call return the contents of %r31. */
- flags = read_register_pid (HPPA_FLAGS_REGNUM, ptid);
+ regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
if (flags & HPPA_HPUX_SS_INSYSCALL)
- return read_register_pid (HPPA_R31_REGNUM, ptid) & ~0x3;
+ {
+ ULONGEST pc;
+ regcache_cooked_read_unsigned (regcache, HPPA_R31_REGNUM, &pc);
+ return pc & ~0x3;
+ }
- return hppa_read_pc (ptid);
+ return hppa_read_pc (regcache);
}
static void
-hppa_hpux_write_pc (CORE_ADDR pc, ptid_t ptid)
+hppa_hpux_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
ULONGEST flags;
/* If we're currently in a system call also write PC into %r31. */
- flags = read_register_pid (HPPA_FLAGS_REGNUM, ptid);
+ regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
if (flags & HPPA_HPUX_SS_INSYSCALL)
- write_register_pid (HPPA_R31_REGNUM, pc | 0x3, ptid);
+ regcache_cooked_write_unsigned (regcache, HPPA_R31_REGNUM, pc | 0x3);
- return hppa_write_pc (pc, ptid);
+ return hppa_write_pc (regcache, pc);
}
static CORE_ADDR
diff -urNp gdb-orig/gdb/hppa-linux-tdep.c gdb-head/gdb/hppa-linux-tdep.c
--- gdb-orig/gdb/hppa-linux-tdep.c 2007-06-15 23:58:41.063927000 +0200
+++ gdb-head/gdb/hppa-linux-tdep.c 2007-06-16 00:20:17.706116912 +0200
@@ -56,11 +56,11 @@ hppa_dwarf_reg_to_regnum (int reg)
#endif
static void
-hppa_linux_target_write_pc (CORE_ADDR v, ptid_t ptid)
+hppa_linux_target_write_pc (struct regcache *regcache, CORE_ADDR v)
{
/* Probably this should be done by the kernel, but it isn't. */
- write_register_pid (HPPA_PCOQ_HEAD_REGNUM, v | 0x3, ptid);
- write_register_pid (HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3, ptid);
+ regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, v | 0x3);
+ regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3);
}
/* An instruction to match. */
diff -urNp gdb-orig/gdb/hppa-tdep.c gdb-head/gdb/hppa-tdep.c
--- gdb-orig/gdb/hppa-tdep.c 2007-06-16 00:20:44.999306464 +0200
+++ gdb-head/gdb/hppa-tdep.c 2007-06-16 00:20:17.715115616 +0200
@@ -832,12 +832,12 @@ hppa32_push_dummy_call (struct gdbarch *
/* If a structure has to be returned, set up register 28 to hold its
address */
if (struct_return)
- write_register (28, struct_addr);
+ regcache_cooked_write_unsigned (regcache, 28, struct_addr);
gp = tdep->find_global_pointer (function);
if (gp != 0)
- write_register (19, gp);
+ regcache_cooked_write_unsigned (regcache, 19, gp);
/* Set the return address. */
if (!gdbarch_push_dummy_code_p (gdbarch))
@@ -1274,13 +1274,13 @@ hppa64_frame_align (struct gdbarch *gdba
}
CORE_ADDR
-hppa_read_pc (ptid_t ptid)
+hppa_read_pc (struct regcache *regcache)
{
ULONGEST ipsw;
- CORE_ADDR pc;
+ ULONGEST pc;
- ipsw = read_register_pid (HPPA_IPSW_REGNUM, ptid);
- pc = read_register_pid (HPPA_PCOQ_HEAD_REGNUM, ptid);
+ regcache_cooked_read_unsigned (regcache, HPPA_IPSW_REGNUM, &ipsw);
+ regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, &pc);
/* If the current instruction is nullified, then we are effectively
still executing the previous instruction. Pretend we are still
@@ -1294,10 +1294,10 @@ hppa_read_pc (ptid_t ptid)
}
void
-hppa_write_pc (CORE_ADDR pc, ptid_t ptid)
+hppa_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- write_register_pid (HPPA_PCOQ_HEAD_REGNUM, pc, ptid);
- write_register_pid (HPPA_PCOQ_TAIL_REGNUM, pc + 4, ptid);
+ regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pc);
+ regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, pc + 4);
}
/* return the alignment of a type in bytes. Structures have the maximum
@@ -2941,7 +2941,7 @@ hppa_in_solib_call_trampoline (CORE_ADDR
systems: $$dyncall, import stubs and PLT stubs. */
CORE_ADDR
-hppa_skip_trampoline_code (CORE_ADDR pc)
+hppa_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
int dp_rel;
@@ -2949,7 +2949,7 @@ hppa_skip_trampoline_code (CORE_ADDR pc)
/* $$dyncall handles both PLABELs and direct addresses. */
if (hppa_in_dyncall (pc))
{
- pc = read_register (HPPA_R0_REGNUM + 22);
+ pc = get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 22);
/* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
if (pc & 0x2)
@@ -2965,9 +2965,9 @@ hppa_skip_trampoline_code (CORE_ADDR pc)
pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
if (dp_rel)
- pc += read_register (HPPA_DP_REGNUM);
+ pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM);
else
- pc += read_register (HPPA_R0_REGNUM + 19);
+ pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
/* fallthrough */
}
diff -urNp gdb-orig/gdb/hppa-tdep.h gdb-head/gdb/hppa-tdep.h
--- gdb-orig/gdb/hppa-tdep.h 2007-06-16 00:20:38.113236039 +0200
+++ gdb-head/gdb/hppa-tdep.h 2007-06-16 00:20:17.720114896 +0200
@@ -233,8 +233,8 @@ extern void
enum lval_type *lvalp, CORE_ADDR *addrp,
int *realnump, gdb_byte *valuep);
-extern CORE_ADDR hppa_read_pc (ptid_t ptid);
-extern void hppa_write_pc (CORE_ADDR pc, ptid_t ptid);
+extern CORE_ADDR hppa_read_pc (struct regcache *regcache);
+extern void hppa_write_pc (struct regcache *regcache, CORE_ADDR pc);
extern CORE_ADDR hppa_unwind_pc (struct gdbarch *gdbarch,
struct frame_info *next_frame);
@@ -246,6 +246,6 @@ extern struct hppa_objfile_private *
hppa_init_objfile_priv_data (struct objfile *objfile);
extern int hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name);
-extern CORE_ADDR hppa_skip_trampoline_code (CORE_ADDR pc);
+extern CORE_ADDR hppa_skip_trampoline_code (struct frame_info *, CORE_ADDR pc);
#endif /* hppa-tdep.h */
diff -urNp gdb-orig/gdb/i386-cygwin-tdep.c gdb-head/gdb/i386-cygwin-tdep.c
--- gdb-orig/gdb/i386-cygwin-tdep.c 2007-06-16 00:20:38.117235463 +0200
+++ gdb-head/gdb/i386-cygwin-tdep.c 2007-06-16 00:18:49.527389006 +0200
@@ -27,7 +27,7 @@
#include "i386-tdep.h"
static CORE_ADDR
-i386_cygwin_skip_trampoline_code (CORE_ADDR pc)
+i386_cygwin_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
return i386_pe_skip_trampoline_code (pc, NULL);
}
diff -urNp gdb-orig/gdb/i386-linux-tdep.c gdb-head/gdb/i386-linux-tdep.c
--- gdb-orig/gdb/i386-linux-tdep.c 2007-06-15 23:58:41.087923000 +0200
+++ gdb-head/gdb/i386-linux-tdep.c 2007-06-16 00:20:17.725114176 +0200
@@ -317,9 +317,9 @@ i386_linux_sigcontext_addr (struct frame
/* Set the program counter for process PTID to PC. */
static void
-i386_linux_write_pc (CORE_ADDR pc, ptid_t ptid)
+i386_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- write_register_pid (I386_EIP_REGNUM, pc, ptid);
+ regcache_cooked_write_unsigned (regcache, I386_EIP_REGNUM, pc);
/* We must be careful with modifying the program counter. If we
just interrupted a system call, the kernel might try to restart
@@ -335,7 +335,7 @@ i386_linux_write_pc (CORE_ADDR pc, ptid_
when we resume the inferior on return from a function call from
within GDB. In all other cases the system call will not be
restarted. */
- write_register_pid (I386_LINUX_ORIG_EAX_REGNUM, -1, ptid);
+ regcache_cooked_write_unsigned (regcache, I386_LINUX_ORIG_EAX_REGNUM, -1);
}
diff -urNp gdb-orig/gdb/i386-tdep.c gdb-head/gdb/i386-tdep.c
--- gdb-orig/gdb/i386-tdep.c 2007-06-16 00:20:32.999173592 +0200
+++ gdb-head/gdb/i386-tdep.c 2007-06-16 00:18:54.516468312 +0200
@@ -1266,11 +1266,11 @@ i386_unwind_dummy_id (struct gdbarch *gd
This function is 64-bit safe. */
static int
-i386_get_longjmp_target (CORE_ADDR *pc)
+i386_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{
gdb_byte buf[8];
CORE_ADDR sp, jb_addr;
- int jb_pc_offset = gdbarch_tdep (current_gdbarch)->jb_pc_offset;
+ int jb_pc_offset = gdbarch_tdep (get_frame_arch (frame))->jb_pc_offset;
int len = TYPE_LENGTH (builtin_type_void_func_ptr);
/* If JB_PC_OFFSET is -1, we have no way to find out where the
@@ -1280,7 +1280,7 @@ i386_get_longjmp_target (CORE_ADDR *pc)
/* Don't use I386_ESP_REGNUM here, since this function is also used
for AMD64. */
- regcache_cooked_read (current_regcache, SP_REGNUM, buf);
+ get_frame_register (frame, SP_REGNUM, buf);
sp = extract_typed_address (buf, builtin_type_void_data_ptr);
if (target_read_memory (sp + len, buf, len))
return 0;
diff -urNp gdb-orig/gdb/ia64-linux-tdep.c gdb-head/gdb/ia64-linux-tdep.c
--- gdb-orig/gdb/ia64-linux-tdep.c 2007-06-15 23:58:41.099921000 +0200
+++ gdb-head/gdb/ia64-linux-tdep.c 2007-06-16 00:20:17.729113600 +0200
@@ -100,9 +100,9 @@ ia64_linux_sigcontext_register_address (
}
static void
-ia64_linux_write_pc (CORE_ADDR pc, ptid_t ptid)
+ia64_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- ia64_write_pc (pc, ptid);
+ ia64_write_pc (regcache, pc);
/* We must be careful with modifying the instruction-pointer: if we
just interrupt a system call, the kernel would ordinarily try to
@@ -113,7 +113,7 @@ ia64_linux_write_pc (CORE_ADDR pc, ptid_
The clearing of r10 is safe as long as ia64_write_pc() is only
called as part of setting up an inferior call. */
- write_register_pid (IA64_GR10_REGNUM, 0, ptid);
+ regcache_cooked_write_unsigned (regcache, IA64_GR10_REGNUM, 0);
}
static void
diff -urNp gdb-orig/gdb/ia64-tdep.c gdb-head/gdb/ia64-tdep.c
--- gdb-orig/gdb/ia64-tdep.c 2007-06-16 00:20:45.010304880 +0200
+++ gdb-head/gdb/ia64-tdep.c 2007-06-16 00:20:17.739112160 +0200
@@ -637,27 +637,32 @@ ia64_breakpoint_from_pc (CORE_ADDR *pcpt
}
static CORE_ADDR
-ia64_read_pc (ptid_t ptid)
+ia64_read_pc (struct regcache *regcache)
{
- CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, ptid);
- CORE_ADDR pc_value = read_register_pid (IA64_IP_REGNUM, ptid);
- int slot_num = (psr_value >> 41) & 3;
+ ULONGEST psr_value, pc_value;
+ int slot_num;
+
+ regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr_value);
+ regcache_cooked_read_unsigned (regcache, IA64_IP_REGNUM, &pc_value);
+ slot_num = (psr_value >> 41) & 3;
return pc_value | (slot_num * SLOT_MULTIPLIER);
}
void
-ia64_write_pc (CORE_ADDR new_pc, ptid_t ptid)
+ia64_write_pc (struct regcache *regcache, CORE_ADDR new_pc)
{
int slot_num = (int) (new_pc & 0xf) / SLOT_MULTIPLIER;
- CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, ptid);
+ ULONGEST psr_value;
+
+ regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr_value);
psr_value &= ~(3LL << 41);
- psr_value |= (CORE_ADDR)(slot_num & 0x3) << 41;
+ psr_value |= (ULONGEST)(slot_num & 0x3) << 41;
new_pc &= ~0xfLL;
- write_register_pid (IA64_PSR_REGNUM, psr_value, ptid);
- write_register_pid (IA64_IP_REGNUM, new_pc, ptid);
+ regcache_cooked_write_unsigned (regcache, IA64_PSR_REGNUM, psr_value);
+ regcache_cooked_write_unsigned (regcache, IA64_IP_REGNUM, new_pc);
}
#define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
@@ -3198,7 +3203,7 @@ find_extant_func_descr (CORE_ADDR faddr)
stack using the address at fdaptr. */
static CORE_ADDR
-find_func_descr (CORE_ADDR faddr, CORE_ADDR *fdaptr)
+find_func_descr (struct regcache *regcache, CORE_ADDR faddr, CORE_ADDR *fdaptr)
{
CORE_ADDR fdesc;
@@ -3206,7 +3211,7 @@ find_func_descr (CORE_ADDR faddr, CORE_A
if (fdesc == 0)
{
- CORE_ADDR global_pointer;
+ ULONGEST global_pointer;
char buf[16];
fdesc = *fdaptr;
@@ -3215,7 +3220,8 @@ find_func_descr (CORE_ADDR faddr, CORE_A
global_pointer = ia64_find_global_pointer (faddr);
if (global_pointer == 0)
- global_pointer = read_register (IA64_GR1_REGNUM);
+ regcache_cooked_read_unsigned (regcache,
+ IA64_GR1_REGNUM, &global_pointer);
store_unsigned_integer (buf, 8, faddr);
store_unsigned_integer (buf + 8, 8, global_pointer);
@@ -3273,7 +3279,8 @@ ia64_push_dummy_call (struct gdbarch *gd
int len, argoffset;
int nslots, rseslots, memslots, slotnum, nfuncargs;
int floatreg;
- CORE_ADDR bsp, cfm, pfs, new_bsp, funcdescaddr, pc, global_pointer;
+ ULONGEST bsp, cfm, pfs, new_bsp;
+ CORE_ADDR funcdescaddr, pc, global_pointer;
CORE_ADDR func_addr = find_function_addr (function, NULL);
nslots = 0;
@@ -3299,20 +3306,20 @@ ia64_push_dummy_call (struct gdbarch *gd
memslots = nslots - rseslots;
/* Allocate a new RSE frame. */
- cfm = read_register (IA64_CFM_REGNUM);
+ regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
- bsp = read_register (IA64_BSP_REGNUM);
+ regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
new_bsp = rse_address_add (bsp, rseslots);
- write_register (IA64_BSP_REGNUM, new_bsp);
+ regcache_cooked_write_unsigned (regcache, IA64_BSP_REGNUM, new_bsp);
- pfs = read_register (IA64_PFS_REGNUM);
+ regcache_cooked_read_unsigned (regcache, IA64_PFS_REGNUM, &pfs);
pfs &= 0xc000000000000000LL;
pfs |= (cfm & 0xffffffffffffLL);
- write_register (IA64_PFS_REGNUM, pfs);
+ regcache_cooked_write_unsigned (regcache, IA64_PFS_REGNUM, pfs);
cfm &= 0xc000000000000000LL;
cfm |= rseslots;
- write_register (IA64_CFM_REGNUM, cfm);
+ regcache_cooked_write_unsigned (regcache, IA64_CFM_REGNUM, cfm);
/* We will attempt to find function descriptors in the .opd segment,
but if we can't we'll construct them ourselves. That being the
@@ -3346,9 +3353,9 @@ ia64_push_dummy_call (struct gdbarch *gd
&& TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
{
char val_buf[8];
-
+ ULONGEST faddr = extract_unsigned_integer (value_contents (arg), 8);
store_unsigned_integer (val_buf, 8,
- find_func_descr (extract_unsigned_integer (value_contents (arg), 8),
+ find_func_descr (regcache, faddr,
&funcdescaddr));
if (slotnum < rseslots)
write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
@@ -3410,11 +3417,11 @@ ia64_push_dummy_call (struct gdbarch *gd
global_pointer = ia64_find_global_pointer (func_addr);
if (global_pointer != 0)
- write_register (IA64_GR1_REGNUM, global_pointer);
+ regcache_cooked_write_unsigned (regcache, IA64_GR1_REGNUM, global_pointer);
- write_register (IA64_BR0_REGNUM, bp_addr);
+ regcache_cooked_write_unsigned (regcache, IA64_BR0_REGNUM, bp_addr);
- write_register (sp_regnum, sp);
+ regcache_cooked_write_unsigned (regcache, sp_regnum, sp);
return sp;
}
diff -urNp gdb-orig/gdb/ia64-tdep.h gdb-head/gdb/ia64-tdep.h
--- gdb-orig/gdb/ia64-tdep.h 2007-06-15 23:58:41.115919000 +0200
+++ gdb-head/gdb/ia64-tdep.h 2007-06-16 00:20:17.744111440 +0200
@@ -202,6 +202,6 @@ struct gdbarch_tdep
int (*pc_in_sigtramp) (CORE_ADDR);
};
-extern void ia64_write_pc (CORE_ADDR, ptid_t);
+extern void ia64_write_pc (struct regcache *, CORE_ADDR);
#endif /* ia64-tdep.h */
diff -urNp gdb-orig/gdb/infcall.c gdb-head/gdb/infcall.c
--- gdb-orig/gdb/infcall.c 2007-06-15 23:58:41.121918000 +0200
+++ gdb-head/gdb/infcall.c 2007-06-16 00:20:13.534053959 +0200
@@ -249,7 +249,8 @@ generic_push_dummy_code (struct gdbarch
CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
struct value **args, int nargs,
struct type *value_type,
- CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+ CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
+ struct regcache *regcache)
{
/* Something here to findout the size of a breakpoint and then
allocate space for it on the stack. */
@@ -288,14 +289,17 @@ push_dummy_code (struct gdbarch *gdbarch
CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
struct value **args, int nargs,
struct type *value_type,
- CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+ CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
+ struct regcache *regcache)
{
if (gdbarch_push_dummy_code_p (gdbarch))
return gdbarch_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
- args, nargs, value_type, real_pc, bp_addr);
+ args, nargs, value_type, real_pc, bp_addr,
+ regcache);
else
return generic_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
- args, nargs, value_type, real_pc, bp_addr);
+ args, nargs, value_type, real_pc, bp_addr,
+ regcache);
}
/* All this stuff with a dummy frame may seem unnecessarily complicated
@@ -465,7 +469,7 @@ call_function_by_hand (struct value *fun
{
sp = push_dummy_code (current_gdbarch, sp, funaddr,
using_gcc, args, nargs, values_type,
- &real_pc, &bp_addr);
+ &real_pc, &bp_addr, current_regcache);
dummy_addr = sp;
}
else
@@ -473,7 +477,7 @@ call_function_by_hand (struct value *fun
dummy_addr = sp;
sp = push_dummy_code (current_gdbarch, sp, funaddr,
using_gcc, args, nargs, values_type,
- &real_pc, &bp_addr);
+ &real_pc, &bp_addr, current_regcache);
}
break;
case AT_ENTRY_POINT:
diff -urNp gdb-orig/gdb/inferior.h gdb-head/gdb/inferior.h
--- gdb-orig/gdb/inferior.h 2007-06-15 23:58:41.126917000 +0200
+++ gdb-head/gdb/inferior.h 2007-06-16 00:20:17.749110720 +0200
@@ -172,8 +172,6 @@ extern void write_pc (CORE_ADDR);
extern void write_pc_pid (CORE_ADDR, ptid_t);
-extern void generic_target_write_pc (CORE_ADDR, ptid_t);
-
extern CORE_ADDR unsigned_pointer_to_address (struct type *type,
const gdb_byte *buf);
extern void unsigned_address_to_pointer (struct type *type, gdb_byte *buf,
diff -urNp gdb-orig/gdb/infrun.c gdb-head/gdb/infrun.c
--- gdb-orig/gdb/infrun.c 2007-06-16 00:20:40.576278800 +0200
+++ gdb-head/gdb/infrun.c 2007-06-16 00:18:54.530466296 +0200
@@ -539,7 +539,7 @@ a command like `return' or `jump' to con
if (SOFTWARE_SINGLE_STEP_P () && step)
{
/* Do it the hard way, w/temp breakpoints */
- if (SOFTWARE_SINGLE_STEP (current_regcache))
+ if (SOFTWARE_SINGLE_STEP (get_current_frame ()))
{
/* ...and don't ask hardware to do it. */
step = 0;
@@ -2077,7 +2077,8 @@ process_event_stop_test:
remove_breakpoints ();
breakpoints_inserted = 0;
if (!gdbarch_get_longjmp_target_p (current_gdbarch)
- || !gdbarch_get_longjmp_target (current_gdbarch, &jmp_buf_pc))
+ || !gdbarch_get_longjmp_target (current_gdbarch,
+ get_current_frame (), &jmp_buf_pc))
{
keep_going (ecs);
return;
@@ -2456,9 +2457,10 @@ process_event_stop_test:
function. That's what tells us (a) whether we want to step
into it at all, and (b) what prologue we want to run to the
end of, if we do step into it. */
- real_stop_pc = skip_language_trampoline (stop_pc);
+ real_stop_pc = skip_language_trampoline (get_current_frame (), stop_pc);
if (real_stop_pc == 0)
- real_stop_pc = gdbarch_skip_trampoline_code (current_gdbarch, stop_pc);
+ real_stop_pc = gdbarch_skip_trampoline_code
+ (current_gdbarch, get_current_frame (), stop_pc);
if (real_stop_pc != 0)
ecs->stop_func_start = real_stop_pc;
@@ -2520,8 +2522,9 @@ process_event_stop_test:
stop_pc, ecs->stop_func_name))
{
/* Determine where this trampoline returns. */
- CORE_ADDR real_stop_pc = gdbarch_skip_trampoline_code
- (current_gdbarch, stop_pc);
+ CORE_ADDR real_stop_pc;
+ real_stop_pc = gdbarch_skip_trampoline_code
+ (current_gdbarch, get_current_frame (), stop_pc);
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepped into solib return tramp\n");
diff -urNp gdb-orig/gdb/language.c gdb-head/gdb/language.c
--- gdb-orig/gdb/language.c 2007-06-16 00:20:38.138232439 +0200
+++ gdb-head/gdb/language.c 2007-06-16 00:18:49.547386126 +0200
@@ -77,7 +77,7 @@ static void unk_lang_print_type (struct
static int unk_lang_value_print (struct value *, struct ui_file *, int, enum val_prettyprint);
-static CORE_ADDR unk_lang_trampoline (CORE_ADDR pc);
+static CORE_ADDR unk_lang_trampoline (struct frame_info *, CORE_ADDR pc);
/* Forward declaration */
extern const struct language_defn unknown_language_defn;
@@ -1005,7 +1005,7 @@ add_language (const struct language_defn
Return the result from the first that returns non-zero, or 0 if all
`fail'. */
CORE_ADDR
-skip_language_trampoline (CORE_ADDR pc)
+skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
{
int i;
@@ -1013,7 +1013,7 @@ skip_language_trampoline (CORE_ADDR pc)
{
if (languages[i]->skip_trampoline)
{
- CORE_ADDR real_pc = (languages[i]->skip_trampoline) (pc);
+ CORE_ADDR real_pc = (languages[i]->skip_trampoline) (frame, pc);
if (real_pc)
return real_pc;
}
@@ -1130,7 +1130,7 @@ unk_lang_value_print (struct value *val,
error (_("internal error - unimplemented function unk_lang_value_print called."));
}
-static CORE_ADDR unk_lang_trampoline (CORE_ADDR pc)
+static CORE_ADDR unk_lang_trampoline (struct frame_info *frame, CORE_ADDR pc)
{
return 0;
}
diff -urNp gdb-orig/gdb/language.h gdb-head/gdb/language.h
--- gdb-orig/gdb/language.h 2007-06-16 00:20:38.143231719 +0200
+++ gdb-head/gdb/language.h 2007-06-16 00:18:49.552385406 +0200
@@ -29,6 +29,7 @@
/* Forward decls for prototypes */
struct value;
struct objfile;
+struct frame_info;
struct expression;
struct ui_file;
@@ -221,7 +222,7 @@ struct language_defn
If that PC falls in a trampoline belonging to this language,
return the address of the first pc in the real function, or 0
if it isn't a language tramp for this language. */
- CORE_ADDR (*skip_trampoline) (CORE_ADDR pc);
+ CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
/* Now come some hooks for lookup_symbol. */
@@ -453,7 +454,7 @@ extern enum language get_frame_language
/* Check for a language-specific trampoline. */
-extern CORE_ADDR skip_language_trampoline (CORE_ADDR pc);
+extern CORE_ADDR skip_language_trampoline (struct frame_info *, CORE_ADDR pc);
/* Return demangled language symbol, or NULL. */
extern char *language_demangle (const struct language_defn *current_language,
diff -urNp gdb-orig/gdb/m32c-tdep.c gdb-head/gdb/m32c-tdep.c
--- gdb-orig/gdb/m32c-tdep.c 2007-06-16 00:20:38.151230567 +0200
+++ gdb-head/gdb/m32c-tdep.c 2007-06-16 00:18:49.560384254 +0200
@@ -2332,7 +2332,7 @@ m32c_return_value (struct gdbarch *gdbar
code sequence seems more fragile. */
static CORE_ADDR
-m32c_skip_trampoline_code (CORE_ADDR stop_pc)
+m32c_skip_trampoline_code (struct frame_info *frame, CORE_ADDR stop_pc)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
diff -urNp gdb-orig/gdb/m32r-linux-tdep.c gdb-head/gdb/m32r-linux-tdep.c
--- gdb-orig/gdb/m32r-linux-tdep.c 2007-06-16 00:20:45.015304160 +0200
+++ gdb-head/gdb/m32r-linux-tdep.c 2007-06-16 00:18:13.829080332 +0200
@@ -383,7 +383,7 @@ m32r_linux_supply_gregset (const struct
break;
}
- regcache_raw_supply (current_regcache, i,
+ regcache_raw_supply (regcache, i,
regs + m32r_pt_regs_offset[i]);
}
}
diff -urNp gdb-orig/gdb/m32r-tdep.c gdb-head/gdb/m32r-tdep.c
--- gdb-orig/gdb/m32r-tdep.c 2007-06-15 23:58:41.169044000 +0200
+++ gdb-head/gdb/m32r-tdep.c 2007-06-16 00:20:17.754110000 +0200
@@ -643,27 +643,17 @@ m32r_frame_unwind_cache (struct frame_in
}
static CORE_ADDR
-m32r_read_pc (ptid_t ptid)
+m32r_read_pc (struct regcache *regcache)
{
- ptid_t save_ptid;
ULONGEST pc;
-
- save_ptid = inferior_ptid;
- inferior_ptid = ptid;
- regcache_cooked_read_unsigned (current_regcache, M32R_PC_REGNUM, &pc);
- inferior_ptid = save_ptid;
+ regcache_cooked_read_unsigned (regcache, M32R_PC_REGNUM, &pc);
return pc;
}
static void
-m32r_write_pc (CORE_ADDR val, ptid_t ptid)
+m32r_write_pc (struct regcache *regcache, CORE_ADDR val)
{
- ptid_t save_ptid;
-
- save_ptid = inferior_ptid;
- inferior_ptid = ptid;
- write_register (M32R_PC_REGNUM, val);
- inferior_ptid = save_ptid;
+ regcache_cooked_write_unsigned (regcache, M32R_PC_REGNUM, val);
}
static CORE_ADDR
diff -urNp gdb-orig/gdb/m68hc11-tdep.c gdb-head/gdb/m68hc11-tdep.c
--- gdb-orig/gdb/m68hc11-tdep.c 2007-06-15 23:58:41.175044000 +0200
+++ gdb-head/gdb/m68hc11-tdep.c 2007-06-16 00:20:17.760109136 +0200
@@ -1502,8 +1502,6 @@ m68hc11_gdbarch_init (struct gdbarch_inf
/* Set register info. */
set_gdbarch_fp0_regnum (gdbarch, -1);
- set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-
set_gdbarch_sp_regnum (gdbarch, HARD_SP_REGNUM);
set_gdbarch_register_name (gdbarch, m68hc11_register_name);
set_gdbarch_register_type (gdbarch, m68hc11_register_type);
diff -urNp gdb-orig/gdb/m68k-tdep.c gdb-head/gdb/m68k-tdep.c
--- gdb-orig/gdb/m68k-tdep.c 2007-06-16 00:20:33.021170424 +0200
+++ gdb-head/gdb/m68k-tdep.c 2007-06-16 00:18:54.547463848 +0200
@@ -978,11 +978,11 @@ m68k_unwind_dummy_id (struct gdbarch *gd
This routine returns true on success. */
static int
-m68k_get_longjmp_target (CORE_ADDR *pc)
+m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{
gdb_byte *buf;
CORE_ADDR sp, jb_addr;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
if (tdep->jb_pc < 0)
{
@@ -992,7 +992,7 @@ m68k_get_longjmp_target (CORE_ADDR *pc)
}
buf = alloca (gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT);
- sp = read_register (SP_REGNUM);
+ sp = get_frame_register_unsigned (frame, SP_REGNUM);
if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
buf,
diff -urNp gdb-orig/gdb/m88k-tdep.c gdb-head/gdb/m88k-tdep.c
--- gdb-orig/gdb/m88k-tdep.c 2007-06-15 23:58:41.187042000 +0200
+++ gdb-head/gdb/m88k-tdep.c 2007-06-16 00:20:17.766108271 +0200
@@ -122,7 +122,7 @@ m88k_unwind_pc (struct gdbarch *gdbarch,
}
static void
-m88k_write_pc (CORE_ADDR pc, ptid_t ptid)
+m88k_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
/* According to the MC88100 RISC Microprocessor User's Manual,
section 6.4.3.1.2:
@@ -140,9 +140,9 @@ m88k_write_pc (CORE_ADDR pc, ptid_t ptid
with it. We could even (presumably) give it a totally bogus
value. */
- write_register_pid (M88K_SXIP_REGNUM, pc, ptid);
- write_register_pid (M88K_SNIP_REGNUM, pc | 2, ptid);
- write_register_pid (M88K_SFIP_REGNUM, (pc + 4) | 2, ptid);
+ regcache_cooked_write_unsigned (regcache, M88K_SXIP_REGNUM, pc);
+ regcache_cooked_write_unsigned (regcache, M88K_SNIP_REGNUM, pc | 2);
+ regcache_cooked_write_unsigned (regcache, M88K_SFIP_REGNUM, (pc + 4) | 2);
}
diff -urNp gdb-orig/gdb/mep-tdep.c gdb-head/gdb/mep-tdep.c
--- gdb-orig/gdb/mep-tdep.c 2007-06-16 00:21:01.903398304 +0200
+++ gdb-head/gdb/mep-tdep.c 2007-06-16 00:20:17.775106975 +0200
@@ -850,7 +850,12 @@ static CONFIG_ATTR
current_me_module ()
{
if (target_has_registers)
- return read_register (MEP_MODULE_REGNUM);
+ {
+ ULONGEST regval;
+ regcache_cooked_read_unsigned (current_regcache,
+ MEP_MODULE_REGNUM, ®val);
+ return regval;
+ }
else
return gdbarch_tdep (current_gdbarch)->me_module;
}
@@ -868,7 +873,12 @@ static unsigned int
current_options ()
{
if (target_has_registers)
- return read_register (MEP_OPT_REGNUM);
+ {
+ ULONGEST regval;
+ regcache_cooked_read_unsigned (current_regcache,
+ MEP_OPT_REGNUM, ®val);
+ return regval;
+ }
else
return me_module_opt (current_me_module ());
}
@@ -1111,31 +1121,17 @@ mep_register_type (struct gdbarch *gdbar
static CORE_ADDR
-mep_read_pc (ptid_t ptid)
+mep_read_pc (struct regcache *regcache)
{
- ptid_t saved_ptid;
- CORE_ADDR pc;
-
- saved_ptid = inferior_ptid;
- inferior_ptid = ptid;
-
- pc = read_register (MEP_PC_REGNUM);
-
- inferior_ptid = saved_ptid;
+ ULONGEST pc;
+ regcache_cooked_read_unsigned (regcache, MEP_PC_REGNUM, &pc);
return pc;
}
static void
-mep_write_pc (CORE_ADDR pc, ptid_t ptid)
+mep_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- ptid_t saved_ptid;
-
- saved_ptid = inferior_ptid;
- inferior_ptid = ptid;
-
- write_register (MEP_PC_REGNUM, pc);
-
- inferior_ptid = saved_ptid;
+ regcache_cooked_write_unsigned (regcache, MEP_PC_REGNUM, pc);
}
diff -urNp gdb-orig/gdb/minsyms.c gdb-head/gdb/minsyms.c
--- gdb-orig/gdb/minsyms.c 2007-06-16 00:20:38.157229703 +0200
+++ gdb-head/gdb/minsyms.c 2007-06-16 00:18:49.567383246 +0200
@@ -1047,7 +1047,7 @@ lookup_solib_trampoline_symbol_by_pc (CO
a duplicate function in case this matters someday. */
CORE_ADDR
-find_solib_trampoline_target (CORE_ADDR pc)
+find_solib_trampoline_target (struct frame_info *frame, CORE_ADDR pc)
{
struct objfile *objfile;
struct minimal_symbol *msymbol;
diff -urNp gdb-orig/gdb/mips-linux-tdep.c gdb-head/gdb/mips-linux-tdep.c
--- gdb-orig/gdb/mips-linux-tdep.c 2007-06-16 00:20:33.028169416 +0200
+++ gdb-head/gdb/mips-linux-tdep.c 2007-06-16 00:20:17.781106111 +0200
@@ -52,12 +52,12 @@ static struct target_so_ops mips_svr4_so
#define MIPS_LINUX_JB_PC 0
static int
-mips_linux_get_longjmp_target (CORE_ADDR *pc)
+mips_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
char buf[gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT];
- jb_addr = read_register (MIPS_A0_REGNUM);
+ jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
if (target_read_memory (jb_addr
+ MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE,
@@ -254,13 +254,13 @@ mips_fill_fpregset (const struct regcach
#define MIPS64_LINUX_JB_PC 0
static int
-mips64_linux_get_longjmp_target (CORE_ADDR *pc)
+mips64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
void *buf = alloca (gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT);
int element_size = gdbarch_ptr_bit (current_gdbarch) == 32 ? 4 : 8;
- jb_addr = read_register (MIPS_A0_REGNUM);
+ jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
if (target_read_memory (jb_addr + MIPS64_LINUX_JB_PC * element_size,
buf,
@@ -1054,13 +1054,13 @@ mips_linux_n32n64_sigframe_init (const s
}
static void
-mips_linux_write_pc (CORE_ADDR pc, ptid_t ptid)
+mips_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- write_register_pid (PC_REGNUM, pc, ptid);
+ regcache_cooked_write_unsigned (regcache, PC_REGNUM, pc);
/* Clear the syscall restart flag. */
if (mips_linux_restart_reg_p (current_gdbarch))
- write_register_pid (MIPS_RESTART_REGNUM, 0, ptid);
+ regcache_cooked_write_unsigned (regcache, MIPS_RESTART_REGNUM, 0);
}
/* Return 1 if MIPS_RESTART_REGNUM is usable. */
diff -urNp gdb-orig/gdb/mipsnbsd-tdep.c gdb-head/gdb/mipsnbsd-tdep.c
--- gdb-orig/gdb/mipsnbsd-tdep.c 2007-06-16 00:20:33.034168552 +0200
+++ gdb-head/gdb/mipsnbsd-tdep.c 2007-06-16 00:18:54.558462264 +0200
@@ -284,14 +284,14 @@ mipsnbsd_sigtramp_offset (struct frame_i
NBSD_MIPS_JB_ELEMENT_SIZE)
static int
-mipsnbsd_get_longjmp_target (CORE_ADDR *pc)
+mipsnbsd_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
char *buf;
buf = alloca (NBSD_MIPS_JB_ELEMENT_SIZE);
- jb_addr = read_register (MIPS_A0_REGNUM);
+ jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
if (target_read_memory (jb_addr + NBSD_MIPS_JB_OFFSET, buf,
NBSD_MIPS_JB_ELEMENT_SIZE))
diff -urNp gdb-orig/gdb/mips-tdep.c gdb-head/gdb/mips-tdep.c
--- gdb-orig/gdb/mips-tdep.c 2007-06-16 00:20:58.648335592 +0200
+++ gdb-head/gdb/mips-tdep.c 2007-06-16 00:20:17.796103951 +0200
@@ -266,36 +266,6 @@ unmake_mips16_addr (CORE_ADDR addr)
return ((addr) & ~(CORE_ADDR) 1);
}
-/* Return the contents of register REGNUM as a signed integer. */
-
-static LONGEST
-read_signed_register (int regnum)
-{
- LONGEST val;
- regcache_cooked_read_signed (current_regcache, regnum, &val);
- return val;
-}
-
-static LONGEST
-read_signed_register_pid (int regnum, ptid_t ptid)
-{
- ptid_t save_ptid;
- LONGEST retval;
-
- if (ptid_equal (ptid, inferior_ptid))
- return read_signed_register (regnum);
-
- save_ptid = inferior_ptid;
-
- inferior_ptid = ptid;
-
- retval = read_signed_register (regnum);
-
- inferior_ptid = save_ptid;
-
- return retval;
-}
-
/* Return the MIPS ABI associated with GDBARCH. */
enum mips_abi
mips_abi (struct gdbarch *gdbarch)
@@ -427,7 +397,7 @@ mips_xfer_register (struct regcache *reg
physical 64-bit registers, but should treat them as 32-bit registers. */
static int
-mips2_fp_compat (void)
+mips2_fp_compat (struct frame_info *frame)
{
/* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not
meaningful. */
@@ -441,7 +411,7 @@ mips2_fp_compat (void)
/* Otherwise check the FR bit in the status register - it controls
the FP compatiblity mode. If it is clear we are in compatibility
mode. */
- if ((read_register (MIPS_PS_REGNUM) & ST0_FR) == 0)
+ if ((get_frame_register_unsigned (frame, MIPS_PS_REGNUM) & ST0_FR) == 0)
return 1;
#endif
@@ -452,8 +422,6 @@ mips2_fp_compat (void)
static CORE_ADDR heuristic_proc_start (CORE_ADDR);
-static CORE_ADDR read_next_frame_reg (struct frame_info *, int);
-
static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element *);
static struct type *mips_float_register_type (void);
@@ -928,9 +896,12 @@ mips_pc_is_mips16 (CORE_ADDR memaddr)
all registers should be sign extended for simplicity? */
static CORE_ADDR
-mips_read_pc (ptid_t ptid)
+mips_read_pc (struct regcache *regcache)
{
- return read_signed_register_pid (mips_regnum (current_gdbarch)->pc, ptid);
+ ULONGEST pc;
+ int regnum = mips_regnum (get_regcache_arch (regcache))->pc;
+ regcache_cooked_read_signed (regcache, regnum, &pc);
+ return pc;
}
static CORE_ADDR
@@ -965,9 +936,10 @@ mips_unwind_dummy_id (struct gdbarch *gd
}
static void
-mips_write_pc (CORE_ADDR pc, ptid_t ptid)
+mips_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- write_register_pid (mips_regnum (current_gdbarch)->pc, pc, ptid);
+ int regnum = mips_regnum (get_regcache_arch (regcache))->pc;
+ regcache_cooked_write_unsigned (regcache, regnum, pc);
}
/* Fetch and return instruction from the specified location. If the PC
@@ -1019,7 +991,7 @@ mips32_relative_offset (ULONGEST inst)
/* Determine where to set a single step breakpoint while considering
branch prediction. */
static CORE_ADDR
-mips32_next_pc (CORE_ADDR pc)
+mips32_next_pc (struct frame_info *frame, CORE_ADDR pc)
{
unsigned long inst;
int op;
@@ -1050,8 +1022,8 @@ mips32_next_pc (CORE_ADDR pc)
int tf = itype_rt (inst) & 0x01;
int cnum = itype_rt (inst) >> 2;
int fcrcs =
- read_signed_register (mips_regnum (current_gdbarch)->
- fp_control_status);
+ get_frame_register_signed (frame, mips_regnum (current_gdbarch)->
+ fp_control_status);
int cond = ((fcrcs >> 24) & 0x0e) | ((fcrcs >> 23) & 0x01);
if (((cond >> cnum) & 0x01) == tf)
@@ -1075,7 +1047,7 @@ mips32_next_pc (CORE_ADDR pc)
case 8: /* JR */
case 9: /* JALR */
/* Set PC to that address */
- pc = read_signed_register (rtype_rs (inst));
+ pc = get_frame_register_signed (frame, rtype_rs (inst));
break;
default:
pc += 4;
@@ -1092,7 +1064,7 @@ mips32_next_pc (CORE_ADDR pc)
case 16: /* BLTZAL */
case 18: /* BLTZALL */
less_branch:
- if (read_signed_register (itype_rs (inst)) < 0)
+ if (get_frame_register_signed (frame, itype_rs (inst)) < 0)
pc += mips32_relative_offset (inst) + 4;
else
pc += 8; /* after the delay slot */
@@ -1101,7 +1073,7 @@ mips32_next_pc (CORE_ADDR pc)
case 3: /* BGEZL */
case 17: /* BGEZAL */
case 19: /* BGEZALL */
- if (read_signed_register (itype_rs (inst)) >= 0)
+ if (get_frame_register_signed (frame, itype_rs (inst)) >= 0)
pc += mips32_relative_offset (inst) + 4;
else
pc += 8; /* after the delay slot */
@@ -1131,22 +1103,22 @@ mips32_next_pc (CORE_ADDR pc)
break; /* The new PC will be alternate mode */
case 4: /* BEQ, BEQL */
equal_branch:
- if (read_signed_register (itype_rs (inst)) ==
- read_signed_register (itype_rt (inst)))
+ if (get_frame_register_signed (frame, itype_rs (inst)) ==
+ get_frame_register_signed (frame, itype_rt (inst)))
pc += mips32_relative_offset (inst) + 4;
else
pc += 8;
break;
case 5: /* BNE, BNEL */
neq_branch:
- if (read_signed_register (itype_rs (inst)) !=
- read_signed_register (itype_rt (inst)))
+ if (get_frame_register_signed (frame, itype_rs (inst)) !=
+ get_frame_register_signed (frame, itype_rt (inst)))
pc += mips32_relative_offset (inst) + 4;
else
pc += 8;
break;
case 6: /* BLEZ, BLEZL */
- if (read_signed_register (itype_rs (inst)) <= 0)
+ if (get_frame_register_signed (frame, itype_rs (inst)) <= 0)
pc += mips32_relative_offset (inst) + 4;
else
pc += 8;
@@ -1154,7 +1126,7 @@ mips32_next_pc (CORE_ADDR pc)
case 7:
default:
greater_branch: /* BGTZ, BGTZL */
- if (read_signed_register (itype_rs (inst)) > 0)
+ if (get_frame_register_signed (frame, itype_rs (inst)) > 0)
pc += mips32_relative_offset (inst) + 4;
else
pc += 8;
@@ -1335,7 +1307,7 @@ add_offset_16 (CORE_ADDR pc, int offset)
}
static CORE_ADDR
-extended_mips16_next_pc (CORE_ADDR pc,
+extended_mips16_next_pc (struct frame_info *frame, CORE_ADDR pc,
unsigned int extension, unsigned int insn)
{
int op = (insn >> 11);
@@ -1371,7 +1343,7 @@ extended_mips16_next_pc (CORE_ADDR pc,
struct upk_mips16 upk;
int reg;
unpack_mips16 (pc, extension, insn, ritype, &upk);
- reg = read_signed_register (upk.regx);
+ reg = get_frame_register_signed (frame, upk.regx);
if (reg == 0)
pc += (upk.offset << 1) + 2;
else
@@ -1383,7 +1355,7 @@ extended_mips16_next_pc (CORE_ADDR pc,
struct upk_mips16 upk;
int reg;
unpack_mips16 (pc, extension, insn, ritype, &upk);
- reg = read_signed_register (upk.regx);
+ reg = get_frame_register_signed (frame, upk.regx);
if (reg != 0)
pc += (upk.offset << 1) + 2;
else
@@ -1396,7 +1368,7 @@ extended_mips16_next_pc (CORE_ADDR pc,
int reg;
unpack_mips16 (pc, extension, insn, i8type, &upk);
/* upk.regx contains the opcode */
- reg = read_signed_register (24); /* Test register is 24 */
+ reg = get_frame_register_signed (frame, 24); /* Test register is 24 */
if (((upk.regx == 0) && (reg == 0)) /* BTEZ */
|| ((upk.regx == 1) && (reg != 0))) /* BTNEZ */
/* pc = add_offset_16(pc,upk.offset) ; */
@@ -1430,7 +1402,7 @@ extended_mips16_next_pc (CORE_ADDR pc,
reg = 31;
break; /* BOGUS Guess */
}
- pc = read_signed_register (reg);
+ pc = get_frame_register_signed (frame, reg);
}
else
pc += 2;
@@ -1442,7 +1414,7 @@ extended_mips16_next_pc (CORE_ADDR pc,
that. */
{
pc += 2;
- pc = extended_mips16_next_pc (pc, insn, fetch_mips_16 (pc));
+ pc = extended_mips16_next_pc (frame, pc, insn, fetch_mips_16 (pc));
break;
}
default:
@@ -1455,10 +1427,10 @@ extended_mips16_next_pc (CORE_ADDR pc,
}
static CORE_ADDR
-mips16_next_pc (CORE_ADDR pc)
+mips16_next_pc (struct frame_info *frame, CORE_ADDR pc)
{
unsigned int insn = fetch_mips_16 (pc);
- return extended_mips16_next_pc (pc, 0, insn);
+ return extended_mips16_next_pc (frame, pc, 0, insn);
}
/* The mips_next_pc function supports single_step when the remote
@@ -1467,12 +1439,12 @@ mips16_next_pc (CORE_ADDR pc)
branch will go. This isnt hard because all the data is available.
The MIPS32 and MIPS16 variants are quite different */
static CORE_ADDR
-mips_next_pc (CORE_ADDR pc)
+mips_next_pc (struct frame_info *frame, CORE_ADDR pc)
{
if (pc & 0x01)
- return mips16_next_pc (pc);
+ return mips16_next_pc (frame, pc);
else
- return mips32_next_pc (pc);
+ return mips32_next_pc (frame, pc);
}
struct mips_frame_cache
@@ -1571,8 +1543,9 @@ mips16_scan_prologue (CORE_ADDR start_pc
/* Can be called when there's no process, and hence when there's no
NEXT_FRAME. */
if (next_frame != NULL)
- sp = read_next_frame_reg (next_frame, gdbarch_num_regs (current_gdbarch)
- + MIPS_SP_REGNUM);
+ sp = frame_unwind_register_signed (next_frame,
+ gdbarch_num_regs (current_gdbarch)
+ + MIPS_SP_REGNUM);
else
sp = 0;
@@ -1892,8 +1865,9 @@ mips32_scan_prologue (CORE_ADDR start_pc
/* Can be called when there's no process, and hence when there's no
NEXT_FRAME. */
if (next_frame != NULL)
- sp = read_next_frame_reg (next_frame, gdbarch_num_regs (current_gdbarch)
- + MIPS_SP_REGNUM);
+ sp = frame_unwind_register_signed (next_frame,
+ gdbarch_num_regs (current_gdbarch)
+ + MIPS_SP_REGNUM);
else
sp = 0;
@@ -1943,14 +1917,15 @@ restart:
/* Old gcc frame, r30 is virtual frame pointer. */
if ((long) low_word != frame_offset)
frame_addr = sp + low_word;
- else if (frame_reg == MIPS_SP_REGNUM)
+ else if (next_frame && frame_reg == MIPS_SP_REGNUM)
{
unsigned alloca_adjust;
frame_reg = 30;
- frame_addr = read_next_frame_reg (next_frame,
- gdbarch_num_regs
- (current_gdbarch) + 30);
+ frame_addr = frame_unwind_register_signed
+ (next_frame,
+ gdbarch_num_regs (current_gdbarch) + 30);
+
alloca_adjust = (unsigned) (frame_addr - (sp + low_word));
if (alloca_adjust > 0)
{
@@ -1973,14 +1948,15 @@ restart:
else if (inst == 0x03A0F021 || inst == 0x03a0f025 || inst == 0x03a0f02d)
{
/* New gcc frame, virtual frame pointer is at r30 + frame_size. */
- if (frame_reg == MIPS_SP_REGNUM)
+ if (next_frame && frame_reg == MIPS_SP_REGNUM)
{
unsigned alloca_adjust;
frame_reg = 30;
- frame_addr = read_next_frame_reg (next_frame,
- gdbarch_num_regs
- (current_gdbarch) + 30);
+ frame_addr = frame_unwind_register_signed
+ (next_frame,
+ gdbarch_num_regs (current_gdbarch) + 30);
+
alloca_adjust = (unsigned) (frame_addr - sp);
if (alloca_adjust > 0)
{
@@ -2288,22 +2264,6 @@ mips_stub_frame_base_sniffer (struct fra
return NULL;
}
-static CORE_ADDR
-read_next_frame_reg (struct frame_info *fi, int regno)
-{
- /* Always a pseudo. */
- gdb_assert (regno >= gdbarch_num_regs (current_gdbarch));
- if (fi == NULL)
- {
- LONGEST val;
- regcache_cooked_read_signed (current_regcache, regno, &val);
- return val;
- }
- else
- return frame_unwind_register_signed (fi, regno);
-
-}
-
/* mips_addr_bits_remove - remove useless address bits */
static CORE_ADDR
@@ -2337,12 +2297,12 @@ mips_addr_bits_remove (CORE_ADDR addr)
the target of the coming instruction and breakpoint it. */
int
-mips_software_single_step (struct regcache *regcache)
+mips_software_single_step (struct frame_info *frame)
{
CORE_ADDR pc, next_pc;
- pc = read_register (mips_regnum (current_gdbarch)->pc);
- next_pc = mips_next_pc (pc);
+ pc = get_frame_pc (frame);
+ next_pc = mips_next_pc (frame, pc);
insert_single_step_breakpoint (next_pc);
return 1;
@@ -2579,7 +2539,7 @@ mips_eabi_push_dummy_call (struct gdbarc
fprintf_unfiltered (gdb_stdlog,
"mips_eabi_push_dummy_call: struct_return reg=%d 0x%s\n",
argreg, paddr_nz (struct_addr));
- write_register (argreg++, struct_addr);
+ regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
}
/* Now load as many as possible of the first arguments into
@@ -2656,14 +2616,14 @@ mips_eabi_push_dummy_call (struct gdbarc
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
float_argreg, phex (regval, 4));
- write_register (float_argreg++, regval);
+ regcache_cooked_write_unsigned (regcache, float_argreg++, regval);
/* Write the high word of the double to the odd register(s). */
regval = extract_unsigned_integer (val + 4 - low_offset, 4);
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
float_argreg, phex (regval, 4));
- write_register (float_argreg++, regval);
+ regcache_cooked_write_unsigned (regcache, float_argreg++, regval);
}
else
{
@@ -2675,7 +2635,7 @@ mips_eabi_push_dummy_call (struct gdbarc
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
float_argreg, phex (regval, len));
- write_register (float_argreg++, regval);
+ regcache_cooked_write_unsigned (regcache, float_argreg++, regval);
}
}
else
@@ -2764,7 +2724,7 @@ mips_eabi_push_dummy_call (struct gdbarc
fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
argreg,
phex (regval, regsize));
- write_register (argreg, regval);
+ regcache_cooked_write_unsigned (regcache, argreg, regval);
argreg++;
}
@@ -2860,7 +2820,7 @@ mips_n32n64_push_dummy_call (struct gdba
fprintf_unfiltered (gdb_stdlog,
"mips_n32n64_push_dummy_call: struct_return reg=%d 0x%s\n",
argreg, paddr_nz (struct_addr));
- write_register (argreg++, struct_addr);
+ regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
}
/* Now load as many as possible of the first arguments into
@@ -2892,12 +2852,12 @@ mips_n32n64_push_dummy_call (struct gdba
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
float_argreg, phex (regval, len));
- write_register (float_argreg++, regval);
+ regcache_cooked_write_unsigned (regcache, float_argreg++, regval);
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
argreg, phex (regval, len));
- write_register (argreg, regval);
+ regcache_cooked_write_unsigned (regcache, argreg, regval);
argreg += 1;
}
else
@@ -2997,7 +2957,7 @@ mips_n32n64_push_dummy_call (struct gdba
fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
argreg,
phex (regval, MIPS64_REGSIZE));
- write_register (argreg, regval);
+ regcache_cooked_write_unsigned (regcache, argreg, regval);
argreg++;
}
@@ -3218,7 +3178,7 @@ mips_o32_push_dummy_call (struct gdbarch
fprintf_unfiltered (gdb_stdlog,
"mips_o32_push_dummy_call: struct_return reg=%d 0x%s\n",
argreg, paddr_nz (struct_addr));
- write_register (argreg++, struct_addr);
+ regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
stack_offset += MIPS32_REGSIZE;
}
@@ -3275,23 +3235,23 @@ mips_o32_push_dummy_call (struct gdbarch
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
float_argreg, phex (regval, 4));
- write_register (float_argreg++, regval);
+ regcache_cooked_write_unsigned (regcache, float_argreg++, regval);
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
argreg, phex (regval, 4));
- write_register (argreg++, regval);
+ regcache_cooked_write_unsigned (regcache, argreg++, regval);
/* Write the high word of the double to the odd register(s). */
regval = extract_unsigned_integer (val + 4 - low_offset, 4);
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
float_argreg, phex (regval, 4));
- write_register (float_argreg++, regval);
+ regcache_cooked_write_unsigned (regcache, float_argreg++, regval);
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
argreg, phex (regval, 4));
- write_register (argreg++, regval);
+ regcache_cooked_write_unsigned (regcache, argreg++, regval);
}
else
{
@@ -3303,7 +3263,7 @@ mips_o32_push_dummy_call (struct gdbarch
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
float_argreg, phex (regval, len));
- write_register (float_argreg++, regval);
+ regcache_cooked_write_unsigned (regcache, float_argreg++, regval);
/* CAGNEY: 32 bit MIPS ABI's always reserve two FP
registers for each argument. The below is (my
guess) to ensure that the corresponding integer
@@ -3311,7 +3271,7 @@ mips_o32_push_dummy_call (struct gdbarch
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
argreg, phex (regval, len));
- write_register (argreg, regval);
+ regcache_cooked_write_unsigned (regcache, argreg, regval);
argreg += 2;
}
/* Reserve space for the FP register. */
@@ -3429,7 +3389,7 @@ mips_o32_push_dummy_call (struct gdbarch
fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
argreg,
phex (regval, MIPS32_REGSIZE));
- write_register (argreg, regval);
+ regcache_cooked_write_unsigned (regcache, argreg, regval);
argreg++;
/* Prevent subsequent floating point arguments from
@@ -3677,7 +3637,7 @@ mips_o64_push_dummy_call (struct gdbarch
fprintf_unfiltered (gdb_stdlog,
"mips_o64_push_dummy_call: struct_return reg=%d 0x%s\n",
argreg, paddr_nz (struct_addr));
- write_register (argreg++, struct_addr);
+ regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
stack_offset += MIPS64_REGSIZE;
}
@@ -3716,11 +3676,11 @@ mips_o64_push_dummy_call (struct gdbarch
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - fpreg=%d val=%s",
float_argreg, phex (regval, len));
- write_register (float_argreg++, regval);
+ regcache_cooked_write_unsigned (regcache, float_argreg++, regval);
if (mips_debug)
fprintf_unfiltered (gdb_stdlog, " - reg=%d val=%s",
argreg, phex (regval, len));
- write_register (argreg, regval);
+ regcache_cooked_write_unsigned (regcache, argreg, regval);
argreg++;
/* Reserve space for the FP register. */
stack_offset += align_up (len, MIPS64_REGSIZE);
@@ -3818,7 +3778,7 @@ mips_o64_push_dummy_call (struct gdbarch
fprintf_filtered (gdb_stdlog, " - reg=%d val=%s",
argreg,
phex (regval, MIPS64_REGSIZE));
- write_register (argreg, regval);
+ regcache_cooked_write_unsigned (regcache, argreg, regval);
argreg++;
/* Prevent subsequent floating point arguments from
@@ -3984,7 +3944,7 @@ mips_read_fp_register_double (struct fra
{
int raw_size = register_size (current_gdbarch, regno);
- if (raw_size == 8 && !mips2_fp_compat ())
+ if (raw_size == 8 && !mips2_fp_compat (frame))
{
/* We have a 64-bit value for this register, and we should use
all 64 bits. */
@@ -4032,7 +3992,7 @@ mips_print_fp_register (struct ui_file *
(current_gdbarch, regnum)),
"");
- if (register_size (current_gdbarch, regnum) == 4 || mips2_fp_compat ())
+ if (register_size (current_gdbarch, regnum) == 4 || mips2_fp_compat (frame))
{
/* 4-byte registers: Print hex and floating. Also print even
numbered registers as doubles. */
@@ -4472,10 +4432,10 @@ void
deprecated_mips_set_processor_regs_hack (void)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- CORE_ADDR prid;
-
- prid = read_register (MIPS_PRID_REGNUM);
+ ULONGEST prid;
+ regcache_cooked_read_unsigned (current_regcache,
+ MIPS_PRID_REGNUM, &prid);
if ((prid & ~0xf) == 0x700)
tdep->mips_processor_reg_names = mips_r3041_reg_names;
}
@@ -4617,7 +4577,7 @@ mips_breakpoint_from_pc (CORE_ADDR *pcpt
gory details. */
static CORE_ADDR
-mips_skip_trampoline_code (CORE_ADDR pc)
+mips_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
char *name;
CORE_ADDR start_addr;
@@ -4630,14 +4590,14 @@ mips_skip_trampoline_code (CORE_ADDR pc)
target PC is in $31 ($ra). */
if (strcmp (name, "__mips16_ret_sf") == 0
|| strcmp (name, "__mips16_ret_df") == 0)
- return read_signed_register (MIPS_RA_REGNUM);
+ return get_frame_register_signed (frame, MIPS_RA_REGNUM);
if (strncmp (name, "__mips16_call_stub_", 19) == 0)
{
/* If the PC is in __mips16_call_stub_{1..10}, this is a call stub
and the target PC is in $2. */
if (name[19] >= '0' && name[19] <= '9')
- return read_signed_register (2);
+ return get_frame_register_signed (frame, 2);
/* If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e.
before the jal instruction, this is effectively a call stub
@@ -4659,7 +4619,7 @@ mips_skip_trampoline_code (CORE_ADDR pc)
So scan down to the lui/addi and extract the target
address from those two instructions. */
- CORE_ADDR target_pc = read_signed_register (2);
+ CORE_ADDR target_pc = get_frame_register_signed (frame, 2);
ULONGEST inst;
int i;
@@ -4690,7 +4650,7 @@ mips_skip_trampoline_code (CORE_ADDR pc)
else
/* This is the 'return' part of a call stub. The return
address is in $r18. */
- return read_signed_register (18);
+ return get_frame_register_signed (frame, 18);
}
}
return 0; /* not a stub */
diff -urNp gdb-orig/gdb/mips-tdep.h gdb-head/gdb/mips-tdep.h
--- gdb-orig/gdb/mips-tdep.h 2007-06-16 00:20:40.600275344 +0200
+++ gdb-head/gdb/mips-tdep.h 2007-06-16 00:18:45.968368926 +0200
@@ -95,7 +95,7 @@ enum
};
/* Single step based on where the current instruction will take us. */
-extern int mips_software_single_step (struct regcache *regcache);
+extern int mips_software_single_step (struct frame_info *frame);
/* Tell if the program counter value in MEMADDR is in a MIPS16
function. */
diff -urNp gdb-orig/gdb/mn10300-linux-tdep.c gdb-head/gdb/mn10300-linux-tdep.c
--- gdb-orig/gdb/mn10300-linux-tdep.c 2007-06-16 00:20:45.039300704 +0200
+++ gdb-head/gdb/mn10300-linux-tdep.c 2007-06-16 00:18:13.853076876 +0200
@@ -263,10 +263,10 @@ am33_supply_fpregset_method (const struc
E_FPCR_REGNUM, fpregs, len);
}
else if (regnum == E_FPCR_REGNUM)
- regcache_raw_supply (current_regcache, E_FPCR_REGNUM,
+ regcache_raw_supply (regcache, E_FPCR_REGNUM,
&fpregset->fpcr);
else if (E_FS0_REGNUM <= regnum && regnum < E_FS0_REGNUM + MN10300_ELF_NFPREG)
- regcache_raw_supply (current_regcache, regnum,
+ regcache_raw_supply (regcache, regnum,
&fpregset->fpregs[regnum - E_FS0_REGNUM]);
return;
@@ -441,11 +441,11 @@ am33_collect_fpregset_method (const stru
E_FPCR_REGNUM, fpregs, len);
}
else if (regnum == E_FPCR_REGNUM)
- regcache_raw_collect (current_regcache, E_FPCR_REGNUM,
+ regcache_raw_collect (regcache, E_FPCR_REGNUM,
&fpregset->fpcr);
else if (E_FS0_REGNUM <= regnum
&& regnum < E_FS0_REGNUM + MN10300_ELF_NFPREG)
- regcache_raw_collect (current_regcache, regnum,
+ regcache_raw_collect (regcache, regnum,
&fpregset->fpregs[regnum - E_FS0_REGNUM]);
return;
diff -urNp gdb-orig/gdb/mn10300-tdep.c gdb-head/gdb/mn10300-tdep.c
--- gdb-orig/gdb/mn10300-tdep.c 2007-06-16 00:20:45.045299840 +0200
+++ gdb-head/gdb/mn10300-tdep.c 2007-06-16 00:20:17.802103087 +0200
@@ -269,15 +269,17 @@ mn10300_register_type (struct gdbarch *g
}
static CORE_ADDR
-mn10300_read_pc (ptid_t ptid)
+mn10300_read_pc (struct regcache *regcache)
{
- return read_register_pid (E_PC_REGNUM, ptid);
+ ULONGEST val;
+ regcache_cooked_read_unsigned (regcache, E_PC_REGNUM, &val);
+ return val;
}
static void
-mn10300_write_pc (CORE_ADDR val, ptid_t ptid)
+mn10300_write_pc (struct regcache *regcache, CORE_ADDR val)
{
- return write_register_pid (E_PC_REGNUM, val, ptid);
+ regcache_cooked_write_unsigned (regcache, E_PC_REGNUM, val);
}
/* The breakpoint instruction must be the same size as the smallest
@@ -1008,7 +1010,7 @@ mn10300_push_dummy_call (struct gdbarch
if (struct_return)
{
regs_used = 1;
- write_register (E_D0_REGNUM, struct_addr);
+ regcache_cooked_write_unsigned (regcache, E_D0_REGNUM, struct_addr);
}
else
regs_used = 0;
@@ -1034,8 +1036,8 @@ mn10300_push_dummy_call (struct gdbarch
while (regs_used < 2 && arg_len > 0)
{
- write_register (regs_used,
- extract_unsigned_integer (val, push_size));
+ regcache_cooked_write_unsigned (regcache, regs_used,
+ extract_unsigned_integer (val, push_size));
val += push_size;
arg_len -= push_size;
regs_used++;
diff -urNp gdb-orig/gdb/objc-lang.c gdb-head/gdb/objc-lang.c
--- gdb-orig/gdb/objc-lang.c 2007-06-16 00:20:38.179226535 +0200
+++ gdb-head/gdb/objc-lang.c 2007-06-16 00:18:49.591379790 +0200
@@ -576,12 +576,13 @@ objc_create_fundamental_type (struct obj
for the user since they are only interested in stepping into the
method function anyway. */
static CORE_ADDR
-objc_skip_trampoline (CORE_ADDR stop_pc)
+objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
{
CORE_ADDR real_stop_pc;
CORE_ADDR method_stop_pc;
- real_stop_pc = gdbarch_skip_trampoline_code (current_gdbarch, stop_pc);
+ real_stop_pc = gdbarch_skip_trampoline_code
+ (current_gdbarch, frame, stop_pc);
if (real_stop_pc != 0)
find_objc_msgcall (real_stop_pc, &method_stop_pc);
@@ -591,7 +592,7 @@ objc_skip_trampoline (CORE_ADDR stop_pc)
if (method_stop_pc)
{
real_stop_pc = gdbarch_skip_trampoline_code
- (current_gdbarch, method_stop_pc);
+ (current_gdbarch, frame, method_stop_pc);
if (real_stop_pc == 0)
real_stop_pc = method_stop_pc;
}
diff -urNp gdb-orig/gdb/obsd-tdep.c gdb-head/gdb/obsd-tdep.c
--- gdb-orig/gdb/obsd-tdep.c 2007-06-16 00:20:38.183225959 +0200
+++ gdb-head/gdb/obsd-tdep.c 2007-06-16 00:18:49.595379214 +0200
@@ -34,5 +34,5 @@ obsd_skip_solib_resolver (struct gdbarch
if (msym && SYMBOL_VALUE_ADDRESS (msym) == pc)
return frame_pc_unwind (get_current_frame ());
else
- return find_solib_trampoline_target (pc);
+ return find_solib_trampoline_target (get_current_frame (), pc);
}
diff -urNp gdb-orig/gdb/ppc-linux-tdep.c gdb-head/gdb/ppc-linux-tdep.c
--- gdb-orig/gdb/ppc-linux-tdep.c 2007-06-16 00:20:38.189225095 +0200
+++ gdb-head/gdb/ppc-linux-tdep.c 2007-06-16 00:18:49.601378350 +0200
@@ -86,7 +86,7 @@
static CORE_ADDR
-ppc_linux_skip_trampoline_code (CORE_ADDR pc)
+ppc_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
gdb_byte buf[4];
struct obj_section *sect;
@@ -557,14 +557,16 @@ static struct insn_pattern ppc64_standar
standard linkage function will send them. (This doesn't deal with
dynamic linker lazy symbol resolution stubs.) */
static CORE_ADDR
-ppc64_standard_linkage_target (CORE_ADDR pc, unsigned int *insn)
+ppc64_standard_linkage_target (struct frame_info *frame,
+ CORE_ADDR pc, unsigned int *insn)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
/* The address of the function descriptor this linkage function
references. */
CORE_ADDR desc
- = ((CORE_ADDR) read_register (tdep->ppc_gp0_regnum + 2)
+ = ((CORE_ADDR) get_frame_register_unsigned (frame,
+ tdep->ppc_gp0_regnum + 2)
+ (insn_d_field (insn[0]) << 16)
+ insn_ds_field (insn[2]));
@@ -576,13 +578,14 @@ ppc64_standard_linkage_target (CORE_ADDR
/* Given that we've begun executing a call trampoline at PC, return
the entry point of the function the trampoline will go to. */
static CORE_ADDR
-ppc64_skip_trampoline_code (CORE_ADDR pc)
+ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
unsigned int ppc64_standard_linkage_insn[PPC64_STANDARD_LINKAGE_LEN];
if (insns_match_pattern (pc, ppc64_standard_linkage,
ppc64_standard_linkage_insn))
- return ppc64_standard_linkage_target (pc, ppc64_standard_linkage_insn);
+ return ppc64_standard_linkage_target (frame, pc,
+ ppc64_standard_linkage_insn);
else
return 0;
}
diff -urNp gdb-orig/gdb/ppc-sysv-tdep.c gdb-head/gdb/ppc-sysv-tdep.c
--- gdb-orig/gdb/ppc-sysv-tdep.c 2007-06-16 00:20:45.051298976 +0200
+++ gdb-head/gdb/ppc-sysv-tdep.c 2007-06-16 00:18:13.865075148 +0200
@@ -191,7 +191,7 @@ ppc_sysv_abi_push_dummy_call (struct gdb
if (vreg <= 13)
{
if (write_pass)
- regcache_cooked_write (current_regcache,
+ regcache_cooked_write (regcache,
tdep->ppc_vr0_regnum + vreg, val);
vreg++;
}
@@ -217,7 +217,7 @@ ppc_sysv_abi_push_dummy_call (struct gdb
if (greg <= 10)
{
if (write_pass)
- regcache_cooked_write (current_regcache,
+ regcache_cooked_write (regcache,
tdep->ppc_ev0_regnum + greg, val);
greg++;
}
diff -urNp gdb-orig/gdb/regcache.c gdb-head/gdb/regcache.c
--- gdb-orig/gdb/regcache.c 2007-06-15 23:58:41.275029000 +0200
+++ gdb-head/gdb/regcache.c 2007-06-16 00:20:21.652080120 +0200
@@ -754,73 +754,6 @@ register_offset_hack (struct gdbarch *gd
return descr->register_offset[regnum];
}
-/* Return the contents of register REGNUM as an unsigned integer. */
-
-ULONGEST
-read_register (int regnum)
-{
- gdb_byte *buf = alloca (register_size (current_gdbarch, regnum));
- gdb_assert (current_regcache != NULL);
- gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
- regcache_cooked_read (current_regcache, regnum, buf);
- return (extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)));
-}
-
-ULONGEST
-read_register_pid (int regnum, ptid_t ptid)
-{
- ptid_t save_ptid;
- int save_pid;
- CORE_ADDR retval;
-
- if (ptid_equal (ptid, inferior_ptid))
- return read_register (regnum);
-
- save_ptid = inferior_ptid;
-
- inferior_ptid = ptid;
-
- retval = read_register (regnum);
-
- inferior_ptid = save_ptid;
-
- return retval;
-}
-
-/* Store VALUE into the raw contents of register number REGNUM. */
-
-void
-write_register (int regnum, LONGEST val)
-{
- void *buf;
- int size;
- size = register_size (current_gdbarch, regnum);
- buf = alloca (size);
- store_signed_integer (buf, size, (LONGEST) val);
- gdb_assert (current_regcache != NULL);
- gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
- regcache_cooked_write (current_regcache, regnum, buf);
-}
-
-void
-write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid)
-{
- ptid_t save_ptid;
-
- if (ptid_equal (ptid, inferior_ptid))
- {
- write_register (regnum, val);
- return;
- }
-
- save_ptid = inferior_ptid;
-
- inferior_ptid = ptid;
-
- write_register (regnum, val);
-
- inferior_ptid = save_ptid;
-}
/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
@@ -887,6 +820,9 @@ regcache_raw_collect (const struct regca
CORE_ADDR
read_pc_pid (ptid_t ptid)
{
+ struct regcache *regcache = current_regcache;
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+
ptid_t saved_inferior_ptid;
CORE_ADDR pc_val;
@@ -894,12 +830,13 @@ read_pc_pid (ptid_t ptid)
saved_inferior_ptid = inferior_ptid;
inferior_ptid = ptid;
- if (TARGET_READ_PC_P ())
- pc_val = TARGET_READ_PC (ptid);
+ if (gdbarch_read_pc_p (gdbarch))
+ pc_val = gdbarch_read_pc (gdbarch, regcache);
/* Else use per-frame method on get_current_frame. */
else if (PC_REGNUM >= 0)
{
- CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
+ ULONGEST raw_val;
+ regcache_cooked_read_unsigned (regcache, PC_REGNUM, &raw_val);
pc_val = gdbarch_addr_bits_remove (current_gdbarch, raw_val);
}
else
@@ -916,25 +853,24 @@ read_pc (void)
}
void
-generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
-{
- if (PC_REGNUM >= 0)
- write_register_pid (PC_REGNUM, pc, ptid);
- else
- internal_error (__FILE__, __LINE__,
- _("generic_target_write_pc"));
-}
-
-void
write_pc_pid (CORE_ADDR pc, ptid_t ptid)
{
+ struct regcache *regcache = current_regcache;
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+
ptid_t saved_inferior_ptid;
/* In case ptid != inferior_ptid. */
saved_inferior_ptid = inferior_ptid;
inferior_ptid = ptid;
- TARGET_WRITE_PC (pc, ptid);
+ if (gdbarch_write_pc_p (gdbarch))
+ gdbarch_write_pc (gdbarch, regcache, pc);
+ else if (PC_REGNUM >= 0)
+ regcache_cooked_write_unsigned (regcache, PC_REGNUM, pc);
+ else
+ internal_error (__FILE__, __LINE__,
+ _("write_pc_pid: Unable to update PC"));
inferior_ptid = saved_inferior_ptid;
}
diff -urNp gdb-orig/gdb/regcache.h gdb-head/gdb/regcache.h
--- gdb-orig/gdb/regcache.h 2007-06-15 23:58:41.279029000 +0200
+++ gdb-head/gdb/regcache.h 2007-06-16 00:20:21.656079544 +0200
@@ -161,15 +161,4 @@ extern void regcache_cpy_no_passthrough
extern void registers_changed (void);
-
-/* Rename to read_unsigned_register()? */
-extern ULONGEST read_register (int regnum);
-
-/* Rename to read_unsigned_register_pid()? */
-extern ULONGEST read_register_pid (int regnum, ptid_t ptid);
-
-extern void write_register (int regnum, LONGEST val);
-
-extern void write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid);
-
#endif /* REGCACHE_H */
diff -urNp gdb-orig/gdb/rs6000-tdep.c gdb-head/gdb/rs6000-tdep.c
--- gdb-orig/gdb/rs6000-tdep.c 2007-06-16 00:20:40.614273328 +0200
+++ gdb-head/gdb/rs6000-tdep.c 2007-06-16 00:20:17.819100639 +0200
@@ -118,8 +118,8 @@ CORE_ADDR (*rs6000_find_toc_address_hook
/* Static function prototypes */
-static CORE_ADDR branch_dest (int opcode, int instr, CORE_ADDR pc,
- CORE_ADDR safety);
+static CORE_ADDR branch_dest (struct frame_info *frame, int opcode,
+ int instr, CORE_ADDR pc, CORE_ADDR safety);
static CORE_ADDR skip_prologue (CORE_ADDR, CORE_ADDR,
struct rs6000_framedata *);
@@ -624,8 +624,10 @@ rs6000_fetch_pointer_argument (struct fr
/* Calculate the destination of a branch/jump. Return -1 if not a branch. */
static CORE_ADDR
-branch_dest (int opcode, int instr, CORE_ADDR pc, CORE_ADDR safety)
+branch_dest (struct frame_info *frame, int opcode, int instr,
+ CORE_ADDR pc, CORE_ADDR safety)
{
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
CORE_ADDR dest;
int immediate;
int absolute;
@@ -656,32 +658,26 @@ branch_dest (int opcode, int instr, CORE
if (ext_op == 16) /* br conditional register */
{
- dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum) & ~3;
+ dest = get_frame_register_unsigned (frame, tdep->ppc_lr_regnum) & ~3;
/* If we are about to return from a signal handler, dest is
something like 0x3c90. The current frame is a signal handler
caller frame, upon completion of the sigreturn system call
execution will return to the saved PC in the frame. */
- if (dest < gdbarch_tdep (current_gdbarch)->text_segment_base)
- {
- struct frame_info *fi;
-
- fi = get_current_frame ();
- if (fi != NULL)
- dest = read_memory_addr (get_frame_base (fi) + SIG_FRAME_PC_OFFSET,
- gdbarch_tdep (current_gdbarch)->wordsize);
- }
+ if (dest < tdep->text_segment_base)
+ dest = read_memory_addr (get_frame_base (frame) + SIG_FRAME_PC_OFFSET,
+ tdep->wordsize);
}
else if (ext_op == 528) /* br cond to count reg */
{
- dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum) & ~3;
+ dest = get_frame_register_unsigned (frame, tdep->ppc_ctr_regnum) & ~3;
/* If we are about to execute a system call, dest is something
like 0x22fc or 0x3b00. Upon completion the system call
will return to the address in the link register. */
- if (dest < gdbarch_tdep (current_gdbarch)->text_segment_base)
- dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum) & ~3;
+ if (dest < tdep->text_segment_base)
+ dest = get_frame_register_unsigned (frame, tdep->ppc_lr_regnum) & ~3;
}
else
return -1;
@@ -690,7 +686,7 @@ branch_dest (int opcode, int instr, CORE
default:
return -1;
}
- return (dest < gdbarch_tdep (current_gdbarch)->text_segment_base) ? safety : dest;
+ return (dest < tdep->text_segment_base) ? safety : dest;
}
@@ -725,9 +721,9 @@ rs6000_breakpoint_from_pc (CORE_ADDR *bp
the sequence. */
static int
-deal_with_atomic_sequence (struct regcache *regcache)
+deal_with_atomic_sequence (struct frame_info *frame)
{
- CORE_ADDR pc = read_pc ();
+ CORE_ADDR pc = get_frame_pc (frame);
CORE_ADDR breaks[2] = {-1, -1};
CORE_ADDR loc = pc;
CORE_ADDR branch_bp; /* Breakpoint at branch instruction's destination. */
@@ -762,7 +758,7 @@ deal_with_atomic_sequence (struct regcac
to the standard single-step code. */
opcode = insn >> 26;
- branch_bp = branch_dest (opcode, insn, pc, breaks[0]);
+ branch_bp = branch_dest (frame, opcode, insn, pc, breaks[0]);
if (branch_bp != -1)
{
@@ -807,7 +803,7 @@ deal_with_atomic_sequence (struct regcac
/* AIX does not support PT_STEP. Simulate it. */
int
-rs6000_software_single_step (struct regcache *regcache)
+rs6000_software_single_step (struct frame_info *frame)
{
CORE_ADDR dummy;
int breakp_sz;
@@ -817,16 +813,16 @@ rs6000_software_single_step (struct regc
CORE_ADDR breaks[2];
int opcode;
- loc = read_pc ();
+ loc = get_frame_pc (frame);
insn = read_memory_integer (loc, 4);
- if (deal_with_atomic_sequence (regcache))
+ if (deal_with_atomic_sequence (frame))
return 1;
breaks[0] = loc + breakp_sz;
opcode = insn >> 26;
- breaks[1] = branch_dest (opcode, insn, loc, breaks[0]);
+ breaks[1] = branch_dest (frame, opcode, insn, loc, breaks[0]);
/* Don't put two breakpoints on the same address. */
if (breaks[1] == breaks[0])
@@ -961,13 +957,18 @@ store_param_on_stack_p (unsigned long op
static int
bl_to_blrl_insn_p (CORE_ADDR pc, int insn)
{
- const int opcode = 18;
- const CORE_ADDR dest = branch_dest (opcode, insn, pc, -1);
+ CORE_ADDR dest;
+ int immediate;
+ int absolute;
int dest_insn;
- if (dest == -1)
- return 0; /* Should never happen, but just return zero to be safe. */
-
+ absolute = (int) ((insn >> 1) & 1);
+ immediate = ((insn & ~3) << 6) >> 6;
+ if (absolute)
+ dest = immediate;
+ else
+ dest = pc + immediate;
+
dest_insn = read_memory_integer (dest, 4);
if ((dest_insn & 0xfc00ffff) == 0x4c000021) /* blrl */
return 1;
@@ -1971,7 +1972,7 @@ rs6000_in_solib_return_trampoline (CORE_
code that should be skipped. */
CORE_ADDR
-rs6000_skip_trampoline_code (CORE_ADDR pc)
+rs6000_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
unsigned int ii, op;
int rel;
@@ -2008,7 +2009,7 @@ rs6000_skip_trampoline_code (CORE_ADDR p
}
/* If pc is in a shared library trampoline, return its target. */
- solib_target_pc = find_solib_trampoline_target (pc);
+ solib_target_pc = find_solib_trampoline_target (frame, pc);
if (solib_target_pc)
return solib_target_pc;
@@ -2018,7 +2019,7 @@ rs6000_skip_trampoline_code (CORE_ADDR p
if (op != trampoline_code[ii])
return 0;
}
- ii = read_register (11); /* r11 holds destination addr */
+ ii = get_frame_register_unsigned (frame, 11); /* r11 holds destination addr */
pc = read_memory_addr (ii, gdbarch_tdep (current_gdbarch)->wordsize); /* (r11) value */
return pc;
}
@@ -3497,8 +3498,6 @@ rs6000_gdbarch_init (struct gdbarch_info
else
set_gdbarch_print_insn (gdbarch, gdb_print_insn_powerpc);
- set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-
set_gdbarch_num_regs (gdbarch, v->nregs);
set_gdbarch_num_pseudo_regs (gdbarch, v->npregs);
set_gdbarch_register_name (gdbarch, rs6000_register_name);
diff -urNp gdb-orig/gdb/rs6000-tdep.h gdb-head/gdb/rs6000-tdep.h
--- gdb-orig/gdb/rs6000-tdep.h 2007-06-16 00:20:40.618272752 +0200
+++ gdb-head/gdb/rs6000-tdep.h 2007-06-16 00:18:45.984366622 +0200
@@ -21,7 +21,7 @@
#include "defs.h"
-extern int rs6000_software_single_step (struct regcache *regcache);
+extern int rs6000_software_single_step (struct frame_info *frame);
/* Hook in rs6000-tdep.c for determining the TOC address when
calling functions in the inferior. */
diff -urNp gdb-orig/gdb/sh64-tdep.c gdb-head/gdb/sh64-tdep.c
--- gdb-orig/gdb/sh64-tdep.c 2007-06-16 00:20:54.578390240 +0200
+++ gdb-head/gdb/sh64-tdep.c 2007-06-16 00:20:17.828099343 +0200
@@ -1324,93 +1324,103 @@ sh64_return_value (struct gdbarch *gdbar
}
static void
-sh64_show_media_regs (void)
+sh64_show_media_regs (struct frame_info *frame)
{
int i;
- printf_filtered ("PC=%s SR=%016llx \n",
- paddr (read_register (PC_REGNUM)),
- (long long) read_register (SR_REGNUM));
-
- printf_filtered ("SSR=%016llx SPC=%016llx \n",
- (long long) read_register (SSR_REGNUM),
- (long long) read_register (SPC_REGNUM));
- printf_filtered ("FPSCR=%016lx\n ",
- (long) read_register (FPSCR_REGNUM));
+ printf_filtered
+ ("PC=%s SR=%016llx \n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long long) get_frame_register_unsigned (frame, SR_REGNUM));
+
+ printf_filtered
+ ("SSR=%016llx SPC=%016llx \n",
+ (long long) get_frame_register_unsigned (frame, SSR_REGNUM),
+ (long long) get_frame_register_unsigned (frame, SPC_REGNUM));
+ printf_filtered
+ ("FPSCR=%016lx\n ",
+ (long) get_frame_register_unsigned (frame, FPSCR_REGNUM));
for (i = 0; i < 64; i = i + 4)
- printf_filtered ("\nR%d-R%d %016llx %016llx %016llx %016llx\n",
- i, i + 3,
- (long long) read_register (i + 0),
- (long long) read_register (i + 1),
- (long long) read_register (i + 2),
- (long long) read_register (i + 3));
+ printf_filtered
+ ("\nR%d-R%d %016llx %016llx %016llx %016llx\n",
+ i, i + 3,
+ (long long) get_frame_register_unsigned (frame, i + 0),
+ (long long) get_frame_register_unsigned (frame, i + 1),
+ (long long) get_frame_register_unsigned (frame, i + 2),
+ (long long) get_frame_register_unsigned (frame, i + 3));
printf_filtered ("\n");
for (i = 0; i < 64; i = i + 8)
- printf_filtered ("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- i, i + 7,
- (long) read_register (FP0_REGNUM + i + 0),
- (long) read_register (FP0_REGNUM + i + 1),
- (long) read_register (FP0_REGNUM + i + 2),
- (long) read_register (FP0_REGNUM + i + 3),
- (long) read_register (FP0_REGNUM + i + 4),
- (long) read_register (FP0_REGNUM + i + 5),
- (long) read_register (FP0_REGNUM + i + 6),
- (long) read_register (FP0_REGNUM + i + 7));
+ printf_filtered
+ ("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ i, i + 7,
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 0),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 1),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 2),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 3),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 4),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 5),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 6),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 7));
}
static void
-sh64_show_compact_regs (void)
+sh64_show_compact_regs (struct frame_info *frame)
{
int i;
- printf_filtered ("PC=%s \n",
- paddr (read_register (PC_C_REGNUM)));
-
- printf_filtered ("GBR=%08lx MACH=%08lx MACL=%08lx PR=%08lx T=%08lx\n",
- (long) read_register (GBR_C_REGNUM),
- (long) read_register (MACH_C_REGNUM),
- (long) read_register (MACL_C_REGNUM),
- (long) read_register (PR_C_REGNUM),
- (long) read_register (T_C_REGNUM));
- printf_filtered ("FPSCR=%08lx FPUL=%08lx\n",
- (long) read_register (FPSCR_C_REGNUM),
- (long) read_register (FPUL_C_REGNUM));
+ printf_filtered
+ ("PC=%s \n",
+ paddr (get_frame_register_unsigned (frame, PC_C_REGNUM)));
+
+ printf_filtered
+ ("GBR=%08lx MACH=%08lx MACL=%08lx PR=%08lx T=%08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_C_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_C_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_C_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_C_REGNUM),
+ (long) get_frame_register_unsigned (frame, T_C_REGNUM));
+ printf_filtered
+ ("FPSCR=%08lx FPUL=%08lx\n",
+ (long) get_frame_register_unsigned (frame, FPSCR_C_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPUL_C_REGNUM));
for (i = 0; i < 16; i = i + 4)
- printf_filtered ("\nR%d-R%d %08lx %08lx %08lx %08lx\n",
- i, i + 3,
- (long) read_register (i + 0),
- (long) read_register (i + 1),
- (long) read_register (i + 2),
- (long) read_register (i + 3));
+ printf_filtered
+ ("\nR%d-R%d %08lx %08lx %08lx %08lx\n",
+ i, i + 3,
+ (long) get_frame_register_unsigned (frame, i + 0),
+ (long) get_frame_register_unsigned (frame, i + 1),
+ (long) get_frame_register_unsigned (frame, i + 2),
+ (long) get_frame_register_unsigned (frame, i + 3));
printf_filtered ("\n");
for (i = 0; i < 16; i = i + 8)
- printf_filtered ("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- i, i + 7,
- (long) read_register (FP0_REGNUM + i + 0),
- (long) read_register (FP0_REGNUM + i + 1),
- (long) read_register (FP0_REGNUM + i + 2),
- (long) read_register (FP0_REGNUM + i + 3),
- (long) read_register (FP0_REGNUM + i + 4),
- (long) read_register (FP0_REGNUM + i + 5),
- (long) read_register (FP0_REGNUM + i + 6),
- (long) read_register (FP0_REGNUM + i + 7));
+ printf_filtered
+ ("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ i, i + 7,
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 0),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 1),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 2),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 3),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 4),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 5),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 6),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 7));
}
/* FIXME!!! This only shows the registers for shmedia, excluding the
pseudo registers. */
void
-sh64_show_regs (void)
+sh64_show_regs (struct frame_info *frame)
{
- if (pc_is_isa32 (get_frame_pc (get_selected_frame (NULL))))
- sh64_show_media_regs ();
+ if (pc_is_isa32 (get_frame_pc (frame)))
+ sh64_show_media_regs (frame);
else
- sh64_show_compact_regs ();
+ sh64_show_compact_regs (frame);
}
/* *INDENT-OFF* */
@@ -2476,8 +2486,6 @@ sh64_gdbarch_init (struct gdbarch_info i
set_gdbarch_print_insn (gdbarch, gdb_print_insn_sh64);
set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno);
- set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-
set_gdbarch_return_value (gdbarch, sh64_return_value);
set_gdbarch_deprecated_extract_struct_value_address (gdbarch,
sh64_extract_struct_value_address);
diff -urNp gdb-orig/gdb/sh-tdep.c gdb-head/gdb/sh-tdep.c
--- gdb-orig/gdb/sh-tdep.c 2007-06-16 00:20:54.638381600 +0200
+++ gdb-head/gdb/sh-tdep.c 2007-06-16 00:20:17.837098047 +0200
@@ -56,7 +56,7 @@
/* registers numbers shared with the simulator */
#include "gdb/sim-sh.h"
-static void (*sh_show_regs) (void);
+static void (*sh_show_regs) (struct frame_info *);
#define SH_NUM_REGS 67
@@ -508,7 +508,7 @@ gdb_print_insn_sh (bfd_vma memaddr, disa
static CORE_ADDR
sh_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
- struct sh_frame_cache *cache)
+ struct sh_frame_cache *cache, ULONGEST fpscr)
{
ULONGEST inst;
CORE_ADDR opc;
@@ -615,7 +615,7 @@ sh_analyze_prologue (CORE_ADDR pc, CORE_
}
else if (IS_FPUSH (inst))
{
- if (read_register (FPSCR_REGNUM) & FPSCR_SZ)
+ if (fpscr & FPSCR_SZ)
{
cache->sp_offset += 8;
}
@@ -728,7 +728,7 @@ sh_skip_prologue (CORE_ADDR start_pc)
return max (pc, start_pc);
cache.sp_offset = -4;
- pc = sh_analyze_prologue (start_pc, (CORE_ADDR) -1, &cache);
+ pc = sh_analyze_prologue (start_pc, (CORE_ADDR) -1, &cache, 0);
if (!cache.uses_fp)
return start_pc;
@@ -1332,501 +1332,625 @@ sh_return_value_fpu (struct gdbarch *gdb
/* Print the registers in a form similar to the E7000 */
static void
-sh_generic_show_regs (void)
+sh_generic_show_regs (struct frame_info *frame)
{
- printf_filtered (" PC %s SR %08lx PR %08lx MACH %08lx\n",
- paddr (read_register (PC_REGNUM)),
- (long) read_register (SR_REGNUM),
- (long) read_register (PR_REGNUM),
- (long) read_register (MACH_REGNUM));
-
- printf_filtered (
- " GBR %08lx VBR %08lx MACL %08lx\n",
- (long) read_register (GBR_REGNUM),
- (long) read_register (VBR_REGNUM),
- (long) read_register (MACL_REGNUM));
+ printf_filtered
+ (" PC %s SR %08lx PR %08lx MACH %08lx\n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long) get_frame_register_unsigned (frame, SR_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_REGNUM));
+
+ printf_filtered
+ (" GBR %08lx VBR %08lx MACL %08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, VBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_REGNUM));
printf_filtered
("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (0), (long) read_register (1),
- (long) read_register (2), (long) read_register (3),
- (long) read_register (4), (long) read_register (5),
- (long) read_register (6), (long) read_register (7));
- printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (8), (long) read_register (9),
- (long) read_register (10), (long) read_register (11),
- (long) read_register (12), (long) read_register (13),
- (long) read_register (14), (long) read_register (15));
+ (long) get_frame_register_unsigned (frame, 0),
+ (long) get_frame_register_unsigned (frame, 1),
+ (long) get_frame_register_unsigned (frame, 2),
+ (long) get_frame_register_unsigned (frame, 3),
+ (long) get_frame_register_unsigned (frame, 4),
+ (long) get_frame_register_unsigned (frame, 5),
+ (long) get_frame_register_unsigned (frame, 6),
+ (long) get_frame_register_unsigned (frame, 7));
+ printf_filtered
+ ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 8),
+ (long) get_frame_register_unsigned (frame, 9),
+ (long) get_frame_register_unsigned (frame, 10),
+ (long) get_frame_register_unsigned (frame, 11),
+ (long) get_frame_register_unsigned (frame, 12),
+ (long) get_frame_register_unsigned (frame, 13),
+ (long) get_frame_register_unsigned (frame, 14),
+ (long) get_frame_register_unsigned (frame, 15));
}
static void
-sh3_show_regs (void)
-{
- printf_filtered (" PC %s SR %08lx PR %08lx MACH %08lx\n",
- paddr (read_register (PC_REGNUM)),
- (long) read_register (SR_REGNUM),
- (long) read_register (PR_REGNUM),
- (long) read_register (MACH_REGNUM));
-
- printf_filtered (
- " GBR %08lx VBR %08lx MACL %08lx\n",
- (long) read_register (GBR_REGNUM),
- (long) read_register (VBR_REGNUM),
- (long) read_register (MACL_REGNUM));
- printf_filtered (" SSR %08lx SPC %08lx\n",
- (long) read_register (SSR_REGNUM),
- (long) read_register (SPC_REGNUM));
+sh3_show_regs (struct frame_info *frame)
+{
+ printf_filtered
+ (" PC %s SR %08lx PR %08lx MACH %08lx\n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long) get_frame_register_unsigned (frame, SR_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_REGNUM));
+
+ printf_filtered
+ (" GBR %08lx VBR %08lx MACL %08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, VBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_REGNUM));
+ printf_filtered
+ (" SSR %08lx SPC %08lx\n",
+ (long) get_frame_register_unsigned (frame, SSR_REGNUM),
+ (long) get_frame_register_unsigned (frame, SPC_REGNUM));
printf_filtered
("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (0), (long) read_register (1),
- (long) read_register (2), (long) read_register (3),
- (long) read_register (4), (long) read_register (5),
- (long) read_register (6), (long) read_register (7));
- printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (8), (long) read_register (9),
- (long) read_register (10), (long) read_register (11),
- (long) read_register (12), (long) read_register (13),
- (long) read_register (14), (long) read_register (15));
+ (long) get_frame_register_unsigned (frame, 0),
+ (long) get_frame_register_unsigned (frame, 1),
+ (long) get_frame_register_unsigned (frame, 2),
+ (long) get_frame_register_unsigned (frame, 3),
+ (long) get_frame_register_unsigned (frame, 4),
+ (long) get_frame_register_unsigned (frame, 5),
+ (long) get_frame_register_unsigned (frame, 6),
+ (long) get_frame_register_unsigned (frame, 7));
+ printf_filtered
+ ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 8),
+ (long) get_frame_register_unsigned (frame, 9),
+ (long) get_frame_register_unsigned (frame, 10),
+ (long) get_frame_register_unsigned (frame, 11),
+ (long) get_frame_register_unsigned (frame, 12),
+ (long) get_frame_register_unsigned (frame, 13),
+ (long) get_frame_register_unsigned (frame, 14),
+ (long) get_frame_register_unsigned (frame, 15));
}
+static void
+sh2e_show_regs (struct frame_info *frame)
+{
+ printf_filtered
+ (" PC %s SR %08lx PR %08lx MACH %08lx\n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long) get_frame_register_unsigned (frame, SR_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_REGNUM));
+
+ printf_filtered
+ (" GBR %08lx VBR %08lx MACL %08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, VBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_REGNUM));
+ printf_filtered
+ (" SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
+ (long) get_frame_register_unsigned (frame, SSR_REGNUM),
+ (long) get_frame_register_unsigned (frame, SPC_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPUL_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPSCR_REGNUM));
+
+ printf_filtered
+ ("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 0),
+ (long) get_frame_register_unsigned (frame, 1),
+ (long) get_frame_register_unsigned (frame, 2),
+ (long) get_frame_register_unsigned (frame, 3),
+ (long) get_frame_register_unsigned (frame, 4),
+ (long) get_frame_register_unsigned (frame, 5),
+ (long) get_frame_register_unsigned (frame, 6),
+ (long) get_frame_register_unsigned (frame, 7));
+ printf_filtered
+ ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 8),
+ (long) get_frame_register_unsigned (frame, 9),
+ (long) get_frame_register_unsigned (frame, 10),
+ (long) get_frame_register_unsigned (frame, 11),
+ (long) get_frame_register_unsigned (frame, 12),
+ (long) get_frame_register_unsigned (frame, 13),
+ (long) get_frame_register_unsigned (frame, 14),
+ (long) get_frame_register_unsigned (frame, 15));
+
+ printf_filtered
+ ("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 0),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 1),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 2),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 3),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 4),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 5),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 6),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 7));
+ printf_filtered
+ ("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 8),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 9),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 10),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 11),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 12),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 13),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 14),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 15));
+}
+
+static void
+sh2a_show_regs (struct frame_info *frame)
+{
+ int pr = get_frame_register_unsigned (frame, FPSCR_REGNUM) & 0x80000;
+
+ printf_filtered
+ (" PC %s SR %08lx PR %08lx MACH %08lx\n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long) get_frame_register_unsigned (frame, SR_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_REGNUM));
+
+ printf_filtered
+ (" GBR %08lx VBR %08lx TBR %08lx MACL %08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, VBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, TBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_REGNUM));
+ printf_filtered
+ (" SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
+ (long) get_frame_register_unsigned (frame, SSR_REGNUM),
+ (long) get_frame_register_unsigned (frame, SPC_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPUL_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPSCR_REGNUM));
+
+ printf_filtered
+ ("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 0),
+ (long) get_frame_register_unsigned (frame, 1),
+ (long) get_frame_register_unsigned (frame, 2),
+ (long) get_frame_register_unsigned (frame, 3),
+ (long) get_frame_register_unsigned (frame, 4),
+ (long) get_frame_register_unsigned (frame, 5),
+ (long) get_frame_register_unsigned (frame, 6),
+ (long) get_frame_register_unsigned (frame, 7));
+ printf_filtered
+ ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 8),
+ (long) get_frame_register_unsigned (frame, 9),
+ (long) get_frame_register_unsigned (frame, 10),
+ (long) get_frame_register_unsigned (frame, 11),
+ (long) get_frame_register_unsigned (frame, 12),
+ (long) get_frame_register_unsigned (frame, 13),
+ (long) get_frame_register_unsigned (frame, 14),
+ (long) get_frame_register_unsigned (frame, 15));
+
+ printf_filtered
+ (pr ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
+ : "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 0),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 1),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 2),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 3),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 4),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 5),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 6),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 7));
+ printf_filtered
+ (pr ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
+ : "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 8),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 9),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 10),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 11),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 12),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 13),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 14),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 15));
+ printf_filtered
+ ("BANK=%-3d\n", (int) get_frame_register_unsigned (frame, BANK_REGNUM));
+ printf_filtered
+ ("R0b-R7b %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 0),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 1),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 2),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 3),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 4),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 5),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 6),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 7));
+ printf_filtered
+ ("R8b-R14b %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 8),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 9),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 10),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 11),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 12),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 13),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 14));
+ printf_filtered
+ ("MACHb=%08lx IVNb=%08lx PRb=%08lx GBRb=%08lx MACLb=%08lx\n",
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 15),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 16),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 17),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 18),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 19));
+}
static void
-sh2e_show_regs (void)
-{
- printf_filtered (" PC %s SR %08lx PR %08lx MACH %08lx\n",
- paddr (read_register (PC_REGNUM)),
- (long) read_register (SR_REGNUM),
- (long) read_register (PR_REGNUM),
- (long) read_register (MACH_REGNUM));
-
- printf_filtered (
- " GBR %08lx VBR %08lx MACL %08lx\n",
- (long) read_register (GBR_REGNUM),
- (long) read_register (VBR_REGNUM),
- (long) read_register (MACL_REGNUM));
- printf_filtered (
- " SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
- (long) read_register (SSR_REGNUM),
- (long) read_register (SPC_REGNUM),
- (long) read_register (FPUL_REGNUM),
- (long) read_register (FPSCR_REGNUM));
+sh2a_nofpu_show_regs (struct frame_info *frame)
+{
+ int pr = get_frame_register_unsigned (frame, FPSCR_REGNUM) & 0x80000;
+
+ printf_filtered
+ (" PC %s SR %08lx PR %08lx MACH %08lx\n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long) get_frame_register_unsigned (frame, SR_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_REGNUM));
+
+ printf_filtered
+ (" GBR %08lx VBR %08lx TBR %08lx MACL %08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, VBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, TBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_REGNUM));
+ printf_filtered
+ (" SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
+ (long) get_frame_register_unsigned (frame, SSR_REGNUM),
+ (long) get_frame_register_unsigned (frame, SPC_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPUL_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPSCR_REGNUM));
printf_filtered
("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (0), (long) read_register (1),
- (long) read_register (2), (long) read_register (3),
- (long) read_register (4), (long) read_register (5),
- (long) read_register (6), (long) read_register (7));
- printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (8), (long) read_register (9),
- (long) read_register (10), (long) read_register (11),
- (long) read_register (12), (long) read_register (13),
- (long) read_register (14), (long) read_register (15));
-
- printf_filtered ("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (FP0_REGNUM + 0),
- (long) read_register (FP0_REGNUM + 1),
- (long) read_register (FP0_REGNUM + 2),
- (long) read_register (FP0_REGNUM + 3),
- (long) read_register (FP0_REGNUM + 4),
- (long) read_register (FP0_REGNUM + 5),
- (long) read_register (FP0_REGNUM + 6),
- (long) read_register (FP0_REGNUM + 7));
- printf_filtered ("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (FP0_REGNUM + 8),
- (long) read_register (FP0_REGNUM + 9),
- (long) read_register (FP0_REGNUM + 10),
- (long) read_register (FP0_REGNUM + 11),
- (long) read_register (FP0_REGNUM + 12),
- (long) read_register (FP0_REGNUM + 13),
- (long) read_register (FP0_REGNUM + 14),
- (long) read_register (FP0_REGNUM + 15));
-}
-
-static void
-sh2a_show_regs (void)
-{
- int pr = read_register (FPSCR_REGNUM) & 0x80000;
- printf_filtered (" PC %s SR %08lx PR %08lx MACH %08lx\n",
- paddr (read_register (PC_REGNUM)),
- (long) read_register (SR_REGNUM),
- (long) read_register (PR_REGNUM),
- (long) read_register (MACH_REGNUM));
-
- printf_filtered (
- " GBR %08lx VBR %08lx TBR %08lx MACL %08lx\n",
- (long) read_register (GBR_REGNUM),
- (long) read_register (VBR_REGNUM),
- (long) read_register (TBR_REGNUM),
- (long) read_register (MACL_REGNUM));
- printf_filtered (
- " SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
- (long) read_register (SSR_REGNUM),
- (long) read_register (SPC_REGNUM),
- (long) read_register (FPUL_REGNUM),
- (long) read_register (FPSCR_REGNUM));
-
- printf_filtered ("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (0), (long) read_register (1),
- (long) read_register (2), (long) read_register (3),
- (long) read_register (4), (long) read_register (5),
- (long) read_register (6), (long) read_register (7));
- printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (8), (long) read_register (9),
- (long) read_register (10), (long) read_register (11),
- (long) read_register (12), (long) read_register (13),
- (long) read_register (14), (long) read_register (15));
-
- printf_filtered (
- (pr ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
- : "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
- (long) read_register (FP0_REGNUM + 0),
- (long) read_register (FP0_REGNUM + 1),
- (long) read_register (FP0_REGNUM + 2),
- (long) read_register (FP0_REGNUM + 3),
- (long) read_register (FP0_REGNUM + 4),
- (long) read_register (FP0_REGNUM + 5),
- (long) read_register (FP0_REGNUM + 6),
- (long) read_register (FP0_REGNUM + 7));
- printf_filtered (
- (pr ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
- : "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
- (long) read_register (FP0_REGNUM + 8),
- (long) read_register (FP0_REGNUM + 9),
- (long) read_register (FP0_REGNUM + 10),
- (long) read_register (FP0_REGNUM + 11),
- (long) read_register (FP0_REGNUM + 12),
- (long) read_register (FP0_REGNUM + 13),
- (long) read_register (FP0_REGNUM + 14),
- (long) read_register (FP0_REGNUM + 15));
- printf_filtered ("BANK=%-3d\n", (int) read_register (BANK_REGNUM));
- printf_filtered (
- "R0b-R7b %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (R0_BANK0_REGNUM + 0),
- (long) read_register (R0_BANK0_REGNUM + 1),
- (long) read_register (R0_BANK0_REGNUM + 2),
- (long) read_register (R0_BANK0_REGNUM + 3),
- (long) read_register (R0_BANK0_REGNUM + 4),
- (long) read_register (R0_BANK0_REGNUM + 5),
- (long) read_register (R0_BANK0_REGNUM + 6),
- (long) read_register (R0_BANK0_REGNUM + 7));
- printf_filtered ("R8b-R14b %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (R0_BANK0_REGNUM + 8),
- (long) read_register (R0_BANK0_REGNUM + 9),
- (long) read_register (R0_BANK0_REGNUM + 10),
- (long) read_register (R0_BANK0_REGNUM + 11),
- (long) read_register (R0_BANK0_REGNUM + 12),
- (long) read_register (R0_BANK0_REGNUM + 13),
- (long) read_register (R0_BANK0_REGNUM + 14));
- printf_filtered ("MACHb=%08lx IVNb=%08lx PRb=%08lx GBRb=%08lx MACLb=%08lx\n",
- (long) read_register (R0_BANK0_REGNUM + 15),
- (long) read_register (R0_BANK0_REGNUM + 16),
- (long) read_register (R0_BANK0_REGNUM + 17),
- (long) read_register (R0_BANK0_REGNUM + 18),
- (long) read_register (R0_BANK0_REGNUM + 19));
-}
-
-static void
-sh2a_nofpu_show_regs (void)
-{
- int pr = read_register (FPSCR_REGNUM) & 0x80000;
- printf_filtered (" PC %s SR %08lx PR %08lx MACH %08lx\n",
- paddr (read_register (PC_REGNUM)),
- (long) read_register (SR_REGNUM),
- (long) read_register (PR_REGNUM),
- (long) read_register (MACH_REGNUM));
-
- printf_filtered (
- " GBR %08lx VBR %08lx TBR %08lx MACL %08lx\n",
- (long) read_register (GBR_REGNUM),
- (long) read_register (VBR_REGNUM),
- (long) read_register (TBR_REGNUM),
- (long) read_register (MACL_REGNUM));
- printf_filtered (
- " SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
- (long) read_register (SSR_REGNUM),
- (long) read_register (SPC_REGNUM),
- (long) read_register (FPUL_REGNUM),
- (long) read_register (FPSCR_REGNUM));
-
- printf_filtered ("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (0), (long) read_register (1),
- (long) read_register (2), (long) read_register (3),
- (long) read_register (4), (long) read_register (5),
- (long) read_register (6), (long) read_register (7));
- printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (8), (long) read_register (9),
- (long) read_register (10), (long) read_register (11),
- (long) read_register (12), (long) read_register (13),
- (long) read_register (14), (long) read_register (15));
-
- printf_filtered ("BANK=%-3d\n", (int) read_register (BANK_REGNUM));
- printf_filtered (
- "R0b-R7b %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (R0_BANK0_REGNUM + 0),
- (long) read_register (R0_BANK0_REGNUM + 1),
- (long) read_register (R0_BANK0_REGNUM + 2),
- (long) read_register (R0_BANK0_REGNUM + 3),
- (long) read_register (R0_BANK0_REGNUM + 4),
- (long) read_register (R0_BANK0_REGNUM + 5),
- (long) read_register (R0_BANK0_REGNUM + 6),
- (long) read_register (R0_BANK0_REGNUM + 7));
- printf_filtered ("R8b-R14b %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (R0_BANK0_REGNUM + 8),
- (long) read_register (R0_BANK0_REGNUM + 9),
- (long) read_register (R0_BANK0_REGNUM + 10),
- (long) read_register (R0_BANK0_REGNUM + 11),
- (long) read_register (R0_BANK0_REGNUM + 12),
- (long) read_register (R0_BANK0_REGNUM + 13),
- (long) read_register (R0_BANK0_REGNUM + 14));
- printf_filtered ("MACHb=%08lx IVNb=%08lx PRb=%08lx GBRb=%08lx MACLb=%08lx\n",
- (long) read_register (R0_BANK0_REGNUM + 15),
- (long) read_register (R0_BANK0_REGNUM + 16),
- (long) read_register (R0_BANK0_REGNUM + 17),
- (long) read_register (R0_BANK0_REGNUM + 18),
- (long) read_register (R0_BANK0_REGNUM + 19));
-}
-
-static void
-sh3e_show_regs (void)
-{
- printf_filtered (" PC %s SR %08lx PR %08lx MACH %08lx\n",
- paddr (read_register (PC_REGNUM)),
- (long) read_register (SR_REGNUM),
- (long) read_register (PR_REGNUM),
- (long) read_register (MACH_REGNUM));
-
- printf_filtered (
- " GBR %08lx VBR %08lx MACL %08lx\n",
- (long) read_register (GBR_REGNUM),
- (long) read_register (VBR_REGNUM),
- (long) read_register (MACL_REGNUM));
- printf_filtered (
- " SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
- (long) read_register (SSR_REGNUM),
- (long) read_register (SPC_REGNUM),
- (long) read_register (FPUL_REGNUM),
- (long) read_register (FPSCR_REGNUM));
+ (long) get_frame_register_unsigned (frame, 0),
+ (long) get_frame_register_unsigned (frame, 1),
+ (long) get_frame_register_unsigned (frame, 2),
+ (long) get_frame_register_unsigned (frame, 3),
+ (long) get_frame_register_unsigned (frame, 4),
+ (long) get_frame_register_unsigned (frame, 5),
+ (long) get_frame_register_unsigned (frame, 6),
+ (long) get_frame_register_unsigned (frame, 7));
+ printf_filtered
+ ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 8),
+ (long) get_frame_register_unsigned (frame, 9),
+ (long) get_frame_register_unsigned (frame, 10),
+ (long) get_frame_register_unsigned (frame, 11),
+ (long) get_frame_register_unsigned (frame, 12),
+ (long) get_frame_register_unsigned (frame, 13),
+ (long) get_frame_register_unsigned (frame, 14),
+ (long) get_frame_register_unsigned (frame, 15));
+
+ printf_filtered
+ ("BANK=%-3d\n", (int) get_frame_register_unsigned (frame, BANK_REGNUM));
+ printf_filtered
+ ("R0b-R7b %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 0),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 1),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 2),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 3),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 4),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 5),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 6),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 7));
+ printf_filtered
+ ("R8b-R14b %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 8),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 9),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 10),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 11),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 12),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 13),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 14));
+ printf_filtered
+ ("MACHb=%08lx IVNb=%08lx PRb=%08lx GBRb=%08lx MACLb=%08lx\n",
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 15),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 16),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 17),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 18),
+ (long) get_frame_register_unsigned (frame, R0_BANK0_REGNUM + 19));
+}
+
+static void
+sh3e_show_regs (struct frame_info *frame)
+{
+ printf_filtered
+ (" PC %s SR %08lx PR %08lx MACH %08lx\n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long) get_frame_register_unsigned (frame, SR_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_REGNUM));
+
+ printf_filtered
+ (" GBR %08lx VBR %08lx MACL %08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, VBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_REGNUM));
+ printf_filtered
+ (" SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
+ (long) get_frame_register_unsigned (frame, SSR_REGNUM),
+ (long) get_frame_register_unsigned (frame, SPC_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPUL_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPSCR_REGNUM));
printf_filtered
("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (0), (long) read_register (1),
- (long) read_register (2), (long) read_register (3),
- (long) read_register (4), (long) read_register (5),
- (long) read_register (6), (long) read_register (7));
- printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (8), (long) read_register (9),
- (long) read_register (10), (long) read_register (11),
- (long) read_register (12), (long) read_register (13),
- (long) read_register (14), (long) read_register (15));
-
- printf_filtered ("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (FP0_REGNUM + 0),
- (long) read_register (FP0_REGNUM + 1),
- (long) read_register (FP0_REGNUM + 2),
- (long) read_register (FP0_REGNUM + 3),
- (long) read_register (FP0_REGNUM + 4),
- (long) read_register (FP0_REGNUM + 5),
- (long) read_register (FP0_REGNUM + 6),
- (long) read_register (FP0_REGNUM + 7));
- printf_filtered ("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (FP0_REGNUM + 8),
- (long) read_register (FP0_REGNUM + 9),
- (long) read_register (FP0_REGNUM + 10),
- (long) read_register (FP0_REGNUM + 11),
- (long) read_register (FP0_REGNUM + 12),
- (long) read_register (FP0_REGNUM + 13),
- (long) read_register (FP0_REGNUM + 14),
- (long) read_register (FP0_REGNUM + 15));
+ (long) get_frame_register_unsigned (frame, 0),
+ (long) get_frame_register_unsigned (frame, 1),
+ (long) get_frame_register_unsigned (frame, 2),
+ (long) get_frame_register_unsigned (frame, 3),
+ (long) get_frame_register_unsigned (frame, 4),
+ (long) get_frame_register_unsigned (frame, 5),
+ (long) get_frame_register_unsigned (frame, 6),
+ (long) get_frame_register_unsigned (frame, 7));
+ printf_filtered
+ ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 8),
+ (long) get_frame_register_unsigned (frame, 9),
+ (long) get_frame_register_unsigned (frame, 10),
+ (long) get_frame_register_unsigned (frame, 11),
+ (long) get_frame_register_unsigned (frame, 12),
+ (long) get_frame_register_unsigned (frame, 13),
+ (long) get_frame_register_unsigned (frame, 14),
+ (long) get_frame_register_unsigned (frame, 15));
+
+ printf_filtered
+ ("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 0),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 1),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 2),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 3),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 4),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 5),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 6),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 7));
+ printf_filtered
+ ("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 8),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 9),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 10),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 11),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 12),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 13),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 14),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 15));
}
static void
-sh3_dsp_show_regs (void)
-{
- printf_filtered (" PC %s SR %08lx PR %08lx MACH %08lx\n",
- paddr (read_register (PC_REGNUM)),
- (long) read_register (SR_REGNUM),
- (long) read_register (PR_REGNUM),
- (long) read_register (MACH_REGNUM));
-
- printf_filtered (
- " GBR %08lx VBR %08lx MACL %08lx\n",
- (long) read_register (GBR_REGNUM),
- (long) read_register (VBR_REGNUM),
- (long) read_register (MACL_REGNUM));
-
- printf_filtered (" SSR %08lx SPC %08lx DSR %08lx\n",
- (long) read_register (SSR_REGNUM),
- (long) read_register (SPC_REGNUM),
- (long) read_register (DSR_REGNUM));
+sh3_dsp_show_regs (struct frame_info *frame)
+{
+ printf_filtered
+ (" PC %s SR %08lx PR %08lx MACH %08lx\n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long) get_frame_register_unsigned (frame, SR_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_REGNUM));
+
+ printf_filtered
+ (" GBR %08lx VBR %08lx MACL %08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, VBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_REGNUM));
+
+ printf_filtered
+ (" SSR %08lx SPC %08lx DSR %08lx\n",
+ (long) get_frame_register_unsigned (frame, SSR_REGNUM),
+ (long) get_frame_register_unsigned (frame, SPC_REGNUM),
+ (long) get_frame_register_unsigned (frame, DSR_REGNUM));
printf_filtered
("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (0), (long) read_register (1),
- (long) read_register (2), (long) read_register (3),
- (long) read_register (4), (long) read_register (5),
- (long) read_register (6), (long) read_register (7));
- printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (8), (long) read_register (9),
- (long) read_register (10), (long) read_register (11),
- (long) read_register (12), (long) read_register (13),
- (long) read_register (14), (long) read_register (15));
+ (long) get_frame_register_unsigned (frame, 0),
+ (long) get_frame_register_unsigned (frame, 1),
+ (long) get_frame_register_unsigned (frame, 2),
+ (long) get_frame_register_unsigned (frame, 3),
+ (long) get_frame_register_unsigned (frame, 4),
+ (long) get_frame_register_unsigned (frame, 5),
+ (long) get_frame_register_unsigned (frame, 6),
+ (long) get_frame_register_unsigned (frame, 7));
+ printf_filtered
+ ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 8),
+ (long) get_frame_register_unsigned (frame, 9),
+ (long) get_frame_register_unsigned (frame, 10),
+ (long) get_frame_register_unsigned (frame, 11),
+ (long) get_frame_register_unsigned (frame, 12),
+ (long) get_frame_register_unsigned (frame, 13),
+ (long) get_frame_register_unsigned (frame, 14),
+ (long) get_frame_register_unsigned (frame, 15));
printf_filtered
("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
- (long) read_register (A0G_REGNUM) & 0xff,
- (long) read_register (A0_REGNUM), (long) read_register (M0_REGNUM),
- (long) read_register (X0_REGNUM), (long) read_register (Y0_REGNUM),
- (long) read_register (RS_REGNUM), (long) read_register (MOD_REGNUM));
- printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
- (long) read_register (A1G_REGNUM) & 0xff,
- (long) read_register (A1_REGNUM),
- (long) read_register (M1_REGNUM),
- (long) read_register (X1_REGNUM),
- (long) read_register (Y1_REGNUM),
- (long) read_register (RE_REGNUM));
-}
-
-static void
-sh4_show_regs (void)
-{
- int pr = read_register (FPSCR_REGNUM) & 0x80000;
- printf_filtered (" PC %s SR %08lx PR %08lx MACH %08lx\n",
- paddr (read_register (PC_REGNUM)),
- (long) read_register (SR_REGNUM),
- (long) read_register (PR_REGNUM),
- (long) read_register (MACH_REGNUM));
-
- printf_filtered (
- " GBR %08lx VBR %08lx MACL %08lx\n",
- (long) read_register (GBR_REGNUM),
- (long) read_register (VBR_REGNUM),
- (long) read_register (MACL_REGNUM));
- printf_filtered (
- " SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
- (long) read_register (SSR_REGNUM),
- (long) read_register (SPC_REGNUM),
- (long) read_register (FPUL_REGNUM),
- (long) read_register (FPSCR_REGNUM));
-
- printf_filtered ("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (0), (long) read_register (1),
- (long) read_register (2), (long) read_register (3),
- (long) read_register (4), (long) read_register (5),
- (long) read_register (6), (long) read_register (7));
- printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (8), (long) read_register (9),
- (long) read_register (10), (long) read_register (11),
- (long) read_register (12), (long) read_register (13),
- (long) read_register (14), (long) read_register (15));
-
- printf_filtered (
- (pr ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
- : "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
- (long) read_register (FP0_REGNUM + 0),
- (long) read_register (FP0_REGNUM + 1),
- (long) read_register (FP0_REGNUM + 2),
- (long) read_register (FP0_REGNUM + 3),
- (long) read_register (FP0_REGNUM + 4),
- (long) read_register (FP0_REGNUM + 5),
- (long) read_register (FP0_REGNUM + 6),
- (long) read_register (FP0_REGNUM + 7));
- printf_filtered (
- (pr ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
- : "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
- (long) read_register (FP0_REGNUM + 8),
- (long) read_register (FP0_REGNUM + 9),
- (long) read_register (FP0_REGNUM + 10),
- (long) read_register (FP0_REGNUM + 11),
- (long) read_register (FP0_REGNUM + 12),
- (long) read_register (FP0_REGNUM + 13),
- (long) read_register (FP0_REGNUM + 14),
- (long) read_register (FP0_REGNUM + 15));
-}
-
-static void
-sh4_nofpu_show_regs (void)
-{
- printf_filtered (" PC %s SR %08lx PR %08lx MACH %08lx\n",
- paddr (read_register (PC_REGNUM)),
- (long) read_register (SR_REGNUM),
- (long) read_register (PR_REGNUM),
- (long) read_register (MACH_REGNUM));
-
- printf_filtered (
- " GBR %08lx VBR %08lx MACL %08lx\n",
- (long) read_register (GBR_REGNUM),
- (long) read_register (VBR_REGNUM),
- (long) read_register (MACL_REGNUM));
- printf_filtered (
- " SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
- (long) read_register (SSR_REGNUM),
- (long) read_register (SPC_REGNUM),
- (long) read_register (FPUL_REGNUM),
- (long) read_register (FPSCR_REGNUM));
-
- printf_filtered ("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (0), (long) read_register (1),
- (long) read_register (2), (long) read_register (3),
- (long) read_register (4), (long) read_register (5),
- (long) read_register (6), (long) read_register (7));
- printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (8), (long) read_register (9),
- (long) read_register (10), (long) read_register (11),
- (long) read_register (12), (long) read_register (13),
- (long) read_register (14), (long) read_register (15));
-}
-
-static void
-sh_dsp_show_regs (void)
-{
-
- printf_filtered (" PC %s SR %08lx PR %08lx MACH %08lx\n",
- paddr (read_register (PC_REGNUM)),
- (long) read_register (SR_REGNUM),
- (long) read_register (PR_REGNUM),
- (long) read_register (MACH_REGNUM));
-
- printf_filtered (
- " GBR %08lx VBR %08lx DSR %08lx MACL %08lx\n",
- (long) read_register (GBR_REGNUM),
- (long) read_register (VBR_REGNUM),
- (long) read_register (DSR_REGNUM),
- (long) read_register (MACL_REGNUM));
+ (long) get_frame_register_unsigned (frame, A0G_REGNUM) & 0xff,
+ (long) get_frame_register_unsigned (frame, A0_REGNUM),
+ (long) get_frame_register_unsigned (frame, M0_REGNUM),
+ (long) get_frame_register_unsigned (frame, X0_REGNUM),
+ (long) get_frame_register_unsigned (frame, Y0_REGNUM),
+ (long) get_frame_register_unsigned (frame, RS_REGNUM),
+ (long) get_frame_register_unsigned (frame, MOD_REGNUM));
+ printf_filtered
+ ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
+ (long) get_frame_register_unsigned (frame, A1G_REGNUM) & 0xff,
+ (long) get_frame_register_unsigned (frame, A1_REGNUM),
+ (long) get_frame_register_unsigned (frame, M1_REGNUM),
+ (long) get_frame_register_unsigned (frame, X1_REGNUM),
+ (long) get_frame_register_unsigned (frame, Y1_REGNUM),
+ (long) get_frame_register_unsigned (frame, RE_REGNUM));
+}
+
+static void
+sh4_show_regs (struct frame_info *frame)
+{
+ int pr = get_frame_register_unsigned (frame, FPSCR_REGNUM) & 0x80000;
+
+ printf_filtered
+ (" PC %s SR %08lx PR %08lx MACH %08lx\n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long) get_frame_register_unsigned (frame, SR_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_REGNUM));
+
+ printf_filtered
+ (" GBR %08lx VBR %08lx MACL %08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, VBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_REGNUM));
+ printf_filtered
+ (" SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
+ (long) get_frame_register_unsigned (frame, SSR_REGNUM),
+ (long) get_frame_register_unsigned (frame, SPC_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPUL_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPSCR_REGNUM));
+
+ printf_filtered
+ ("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 0),
+ (long) get_frame_register_unsigned (frame, 1),
+ (long) get_frame_register_unsigned (frame, 2),
+ (long) get_frame_register_unsigned (frame, 3),
+ (long) get_frame_register_unsigned (frame, 4),
+ (long) get_frame_register_unsigned (frame, 5),
+ (long) get_frame_register_unsigned (frame, 6),
+ (long) get_frame_register_unsigned (frame, 7));
+ printf_filtered
+ ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 8),
+ (long) get_frame_register_unsigned (frame, 9),
+ (long) get_frame_register_unsigned (frame, 10),
+ (long) get_frame_register_unsigned (frame, 11),
+ (long) get_frame_register_unsigned (frame, 12),
+ (long) get_frame_register_unsigned (frame, 13),
+ (long) get_frame_register_unsigned (frame, 14),
+ (long) get_frame_register_unsigned (frame, 15));
+
+ printf_filtered
+ (pr ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
+ : "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 0),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 1),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 2),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 3),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 4),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 5),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 6),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 7));
+ printf_filtered
+ (pr ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
+ : "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 8),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 9),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 10),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 11),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 12),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 13),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 14),
+ (long) get_frame_register_unsigned (frame, FP0_REGNUM + 15));
+}
+
+static void
+sh4_nofpu_show_regs (struct frame_info *frame)
+{
+ printf_filtered
+ (" PC %s SR %08lx PR %08lx MACH %08lx\n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long) get_frame_register_unsigned (frame, SR_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_REGNUM));
+
+ printf_filtered
+ (" GBR %08lx VBR %08lx MACL %08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, VBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_REGNUM));
+ printf_filtered
+ (" SSR %08lx SPC %08lx FPUL %08lx FPSCR %08lx\n",
+ (long) get_frame_register_unsigned (frame, SSR_REGNUM),
+ (long) get_frame_register_unsigned (frame, SPC_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPUL_REGNUM),
+ (long) get_frame_register_unsigned (frame, FPSCR_REGNUM));
printf_filtered
("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (0), (long) read_register (1),
- (long) read_register (2), (long) read_register (3),
- (long) read_register (4), (long) read_register (5),
- (long) read_register (6), (long) read_register (7));
- printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
- (long) read_register (8), (long) read_register (9),
- (long) read_register (10), (long) read_register (11),
- (long) read_register (12), (long) read_register (13),
- (long) read_register (14), (long) read_register (15));
+ (long) get_frame_register_unsigned (frame, 0),
+ (long) get_frame_register_unsigned (frame, 1),
+ (long) get_frame_register_unsigned (frame, 2),
+ (long) get_frame_register_unsigned (frame, 3),
+ (long) get_frame_register_unsigned (frame, 4),
+ (long) get_frame_register_unsigned (frame, 5),
+ (long) get_frame_register_unsigned (frame, 6),
+ (long) get_frame_register_unsigned (frame, 7));
+ printf_filtered
+ ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 8),
+ (long) get_frame_register_unsigned (frame, 9),
+ (long) get_frame_register_unsigned (frame, 10),
+ (long) get_frame_register_unsigned (frame, 11),
+ (long) get_frame_register_unsigned (frame, 12),
+ (long) get_frame_register_unsigned (frame, 13),
+ (long) get_frame_register_unsigned (frame, 14),
+ (long) get_frame_register_unsigned (frame, 15));
+}
+
+static void
+sh_dsp_show_regs (struct frame_info *frame)
+{
+ printf_filtered
+ (" PC %s SR %08lx PR %08lx MACH %08lx\n",
+ paddr (get_frame_register_unsigned (frame, PC_REGNUM)),
+ (long) get_frame_register_unsigned (frame, SR_REGNUM),
+ (long) get_frame_register_unsigned (frame, PR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACH_REGNUM));
+
+ printf_filtered
+ (" GBR %08lx VBR %08lx DSR %08lx MACL %08lx\n",
+ (long) get_frame_register_unsigned (frame, GBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, VBR_REGNUM),
+ (long) get_frame_register_unsigned (frame, DSR_REGNUM),
+ (long) get_frame_register_unsigned (frame, MACL_REGNUM));
+
+ printf_filtered
+ ("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 0),
+ (long) get_frame_register_unsigned (frame, 1),
+ (long) get_frame_register_unsigned (frame, 2),
+ (long) get_frame_register_unsigned (frame, 3),
+ (long) get_frame_register_unsigned (frame, 4),
+ (long) get_frame_register_unsigned (frame, 5),
+ (long) get_frame_register_unsigned (frame, 6),
+ (long) get_frame_register_unsigned (frame, 7));
+ printf_filtered
+ ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
+ (long) get_frame_register_unsigned (frame, 8),
+ (long) get_frame_register_unsigned (frame, 9),
+ (long) get_frame_register_unsigned (frame, 10),
+ (long) get_frame_register_unsigned (frame, 11),
+ (long) get_frame_register_unsigned (frame, 12),
+ (long) get_frame_register_unsigned (frame, 13),
+ (long) get_frame_register_unsigned (frame, 14),
+ (long) get_frame_register_unsigned (frame, 15));
printf_filtered
("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
- (long) read_register (A0G_REGNUM) & 0xff,
- (long) read_register (A0_REGNUM), (long) read_register (M0_REGNUM),
- (long) read_register (X0_REGNUM), (long) read_register (Y0_REGNUM),
- (long) read_register (RS_REGNUM), (long) read_register (MOD_REGNUM));
+ (long) get_frame_register_unsigned (frame, A0G_REGNUM) & 0xff,
+ (long) get_frame_register_unsigned (frame, A0_REGNUM),
+ (long) get_frame_register_unsigned (frame, M0_REGNUM),
+ (long) get_frame_register_unsigned (frame, X0_REGNUM),
+ (long) get_frame_register_unsigned (frame, Y0_REGNUM),
+ (long) get_frame_register_unsigned (frame, RS_REGNUM),
+ (long) get_frame_register_unsigned (frame, MOD_REGNUM));
printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
- (long) read_register (A1G_REGNUM) & 0xff,
- (long) read_register (A1_REGNUM),
- (long) read_register (M1_REGNUM),
- (long) read_register (X1_REGNUM),
- (long) read_register (Y1_REGNUM),
- (long) read_register (RE_REGNUM));
+ (long) get_frame_register_unsigned (frame, A1G_REGNUM) & 0xff,
+ (long) get_frame_register_unsigned (frame, A1_REGNUM),
+ (long) get_frame_register_unsigned (frame, M1_REGNUM),
+ (long) get_frame_register_unsigned (frame, X1_REGNUM),
+ (long) get_frame_register_unsigned (frame, Y1_REGNUM),
+ (long) get_frame_register_unsigned (frame, RE_REGNUM));
}
static void
sh_show_regs_command (char *args, int from_tty)
{
if (sh_show_regs)
- (*sh_show_regs) ();
+ (*sh_show_regs) (get_current_frame ());
}
static struct type *
@@ -2236,7 +2360,11 @@ sh_frame_cache (struct frame_info *next_
cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME);
current_pc = frame_pc_unwind (next_frame);
if (cache->pc != 0)
- sh_analyze_prologue (cache->pc, current_pc, cache);
+ {
+ ULONGEST fpscr;
+ fpscr = frame_unwind_register_unsigned (next_frame, FPSCR_REGNUM);
+ sh_analyze_prologue (cache->pc, current_pc, cache, fpscr);
+ }
if (!cache->uses_fp)
{
@@ -2541,8 +2669,6 @@ sh_gdbarch_init (struct gdbarch_info inf
set_gdbarch_print_insn (gdbarch, gdb_print_insn_sh);
set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno);
- set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-
set_gdbarch_return_value (gdbarch, sh_return_value_nofpu);
set_gdbarch_deprecated_extract_struct_value_address (gdbarch,
sh_extract_struct_value_address);
diff -urNp gdb-orig/gdb/sh-tdep.h gdb-head/gdb/sh-tdep.h
--- gdb-orig/gdb/sh-tdep.h 2007-06-16 00:20:54.642381024 +0200
+++ gdb-head/gdb/sh-tdep.h 2007-06-16 00:18:06.769032964 +0200
@@ -85,6 +85,6 @@ enum
};
extern gdbarch_init_ftype sh64_gdbarch_init;
-extern void sh64_show_regs (void);
+extern void sh64_show_regs (struct frame_info *);
#endif /* SH_TDEP_H */
diff -urNp gdb-orig/gdb/solib-sunos.c gdb-head/gdb/solib-sunos.c
--- gdb-orig/gdb/solib-sunos.c 2007-06-16 00:21:07.851470512 +0200
+++ gdb-head/gdb/solib-sunos.c 2007-06-16 00:16:40.322455376 +0200
@@ -786,7 +786,7 @@ sunos_solib_create_inferior_hook (void)
if (gdbarch_decr_pc_after_break (current_gdbarch))
{
stop_pc -= gdbarch_decr_pc_after_break (current_gdbarch);
- write_register (PC_REGNUM, stop_pc);
+ write_pc (stop_pc);
}
if (!disable_break ())
diff -urNp gdb-orig/gdb/sparc64-linux-tdep.c gdb-head/gdb/sparc64-linux-tdep.c
--- gdb-orig/gdb/sparc64-linux-tdep.c 2007-06-16 00:20:40.622272176 +0200
+++ gdb-head/gdb/sparc64-linux-tdep.c 2007-06-16 00:18:45.988366046 +0200
@@ -106,14 +106,11 @@ sparc64_linux_sigframe_init (const struc
address. */
static CORE_ADDR
-sparc64_linux_step_trap (unsigned long insn)
+sparc64_linux_step_trap (struct frame_info *frame, unsigned long insn)
{
if (insn == 0x91d0206d)
{
- ULONGEST sp;
-
- regcache_cooked_read_unsigned (current_regcache,
- SPARC_SP_REGNUM, &sp);
+ ULONGEST sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM);
if (sp & 1)
sp += BIAS;
diff -urNp gdb-orig/gdb/sparc-linux-tdep.c gdb-head/gdb/sparc-linux-tdep.c
--- gdb-orig/gdb/sparc-linux-tdep.c 2007-06-16 00:20:40.626271600 +0200
+++ gdb-head/gdb/sparc-linux-tdep.c 2007-06-16 00:18:45.992365470 +0200
@@ -131,22 +131,18 @@ sparc32_linux_sigframe_init (const struc
address. */
static CORE_ADDR
-sparc32_linux_step_trap (unsigned long insn)
+sparc32_linux_step_trap (struct frame_info *frame, unsigned long insn)
{
if (insn == 0x91d02010)
{
- ULONGEST sc_num;
-
- regcache_cooked_read_unsigned (current_regcache,
- SPARC_G1_REGNUM, &sc_num);
+ ULONGEST sc_num = get_frame_register_unsigned (frame, SPARC_G1_REGNUM);
/* __NR_rt_sigreturn is 101 and __NR_sigreturn is 216 */
if (sc_num == 101 || sc_num == 216)
{
ULONGEST sp, pc_offset;
- regcache_cooked_read_unsigned (current_regcache,
- SPARC_SP_REGNUM, &sp);
+ sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM);
/* The kernel puts the sigreturn registers on the stack,
and this is where the signal unwinding state is take from
diff -urNp gdb-orig/gdb/sparcnbsd-tdep.c gdb-head/gdb/sparcnbsd-tdep.c
--- gdb-orig/gdb/sparcnbsd-tdep.c 2007-06-16 00:20:40.631270880 +0200
+++ gdb-head/gdb/sparcnbsd-tdep.c 2007-06-16 00:18:45.997364750 +0200
@@ -265,21 +265,18 @@ sparc32nbsd_sigtramp_frame_sniffer (stru
address. */
CORE_ADDR
-sparcnbsd_step_trap (unsigned long insn)
+sparcnbsd_step_trap (struct frame_info *frame, unsigned long insn)
{
if ((X_I (insn) == 0 && X_RS1 (insn) == 0 && X_RS2 (insn) == 0)
|| (X_I (insn) == 1 && X_RS1 (insn) == 0 && (insn & 0x7f) == 0))
{
/* "New" system call. */
- ULONGEST number;
-
- regcache_cooked_read_unsigned (current_regcache,
- SPARC_G1_REGNUM, &number);
+ ULONGEST number = get_frame_register_unsigned (frame, SPARC_G1_REGNUM);
if (number & 0x400)
- return sparc_address_from_register (SPARC_G2_REGNUM);
+ return get_frame_register_unsigned (frame, SPARC_G2_REGNUM);
if (number & 0x800)
- return sparc_address_from_register (SPARC_G7_REGNUM);
+ return get_frame_register_unsigned (frame, SPARC_G7_REGNUM);
}
return 0;
diff -urNp gdb-orig/gdb/sparc-tdep.c gdb-head/gdb/sparc-tdep.c
--- gdb-orig/gdb/sparc-tdep.c 2007-06-16 00:20:40.638269872 +0200
+++ gdb-head/gdb/sparc-tdep.c 2007-06-16 00:20:17.846096751 +0200
@@ -170,18 +170,6 @@ sparc_fetch_wcookie (void)
}
-/* Return the contents if register REGNUM as an address. */
-
-CORE_ADDR
-sparc_address_from_register (int regnum)
-{
- ULONGEST addr;
-
- regcache_cooked_read_unsigned (current_regcache, regnum, &addr);
- return addr;
-}
-
-
/* The functions on this page are intended to be used to classify
function arguments. */
@@ -395,7 +383,8 @@ sparc32_push_dummy_code (struct gdbarch
CORE_ADDR funcaddr, int using_gcc,
struct value **args, int nargs,
struct type *value_type,
- CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+ CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
+ struct regcache *regcache)
{
*bp_addr = sp - 4;
*real_pc = funcaddr;
@@ -1249,7 +1238,7 @@ sparc32_dwarf2_frame_init_reg (struct gd
software single-step mechanism. */
static CORE_ADDR
-sparc_analyze_control_transfer (struct gdbarch *arch,
+sparc_analyze_control_transfer (struct frame_info *frame,
CORE_ADDR pc, CORE_ADDR *npc)
{
unsigned long insn = sparc_fetch_instruction (pc);
@@ -1291,7 +1280,7 @@ sparc_analyze_control_transfer (struct g
else if (X_OP (insn) == 2 && X_OP3 (insn) == 0x3a)
{
/* Trap instruction (TRAP). */
- return gdbarch_tdep (arch)->step_trap (insn);
+ return gdbarch_tdep (get_frame_arch (frame))->step_trap (frame, insn);
}
/* FIXME: Handle DONE and RETRY instructions. */
@@ -1324,25 +1313,25 @@ sparc_analyze_control_transfer (struct g
}
static CORE_ADDR
-sparc_step_trap (unsigned long insn)
+sparc_step_trap (struct frame_info *frame, unsigned long insn)
{
return 0;
}
int
-sparc_software_single_step (struct regcache *regcache)
+sparc_software_single_step (struct frame_info *frame)
{
- struct gdbarch *arch = current_gdbarch;
+ struct gdbarch *arch = get_frame_arch (frame);
struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
CORE_ADDR npc, nnpc;
CORE_ADDR pc, orig_npc;
- pc = sparc_address_from_register (tdep->pc_regnum);
- orig_npc = npc = sparc_address_from_register (tdep->npc_regnum);
+ pc = get_frame_register_unsigned (frame, tdep->pc_regnum);
+ orig_npc = npc = get_frame_register_unsigned (frame, tdep->npc_regnum);
/* Analyze the instruction at PC. */
- nnpc = sparc_analyze_control_transfer (arch, pc, &npc);
+ nnpc = sparc_analyze_control_transfer (frame, pc, &npc);
if (npc != 0)
insert_single_step_breakpoint (npc);
@@ -1359,12 +1348,12 @@ sparc_software_single_step (struct regca
}
static void
-sparc_write_pc (CORE_ADDR pc, ptid_t ptid)
+sparc_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
- write_register_pid (tdep->pc_regnum, pc, ptid);
- write_register_pid (tdep->npc_regnum, pc + 4, ptid);
+ regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
+ regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4);
}
/* Unglobalize NAME. */
diff -urNp gdb-orig/gdb/sparc-tdep.h gdb-head/gdb/sparc-tdep.h
--- gdb-orig/gdb/sparc-tdep.h 2007-06-16 00:20:40.643269152 +0200
+++ gdb-head/gdb/sparc-tdep.h 2007-06-16 00:18:46.009363022 +0200
@@ -67,7 +67,7 @@ struct gdbarch_tdep
size_t plt_entry_size;
/* Alternative location for trap return. Used for single-stepping. */
- CORE_ADDR (*step_trap) (unsigned long insn);
+ CORE_ADDR (*step_trap) (struct frame_info *frame, unsigned long insn);
};
/* Register numbers of various important registers. */
@@ -150,9 +150,6 @@ struct sparc_frame_cache
/* Fetch the instruction at PC. */
extern unsigned long sparc_fetch_instruction (CORE_ADDR pc);
-/* Return the contents if register REGNUM as an address. */
-extern CORE_ADDR sparc_address_from_register (int regnum);
-
/* Fetch StackGhost Per-Process XOR cookie. */
extern ULONGEST sparc_fetch_wcookie (void);
@@ -167,7 +164,7 @@ extern struct sparc_frame_cache *
-extern int sparc_software_single_step (struct regcache *regcache);
+extern int sparc_software_single_step (struct frame_info *frame);
extern void sparc_supply_rwindow (struct regcache *regcache,
CORE_ADDR sp, int regnum);
@@ -205,7 +202,8 @@ extern const struct sparc_gregset sparc3
/* Return the address of a system call's alternative return
address. */
-extern CORE_ADDR sparcnbsd_step_trap (unsigned long insn);
+extern CORE_ADDR sparcnbsd_step_trap (struct frame_info *frame,
+ unsigned long insn);
extern void sparc32nbsd_elf_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch);
diff -urNp gdb-orig/gdb/spu-tdep.c gdb-head/gdb/spu-tdep.c
--- gdb-orig/gdb/spu-tdep.c 2007-06-16 00:20:40.650268144 +0200
+++ gdb-head/gdb/spu-tdep.c 2007-06-16 00:20:17.853095743 +0200
@@ -938,19 +938,22 @@ spu_unwind_sp (struct gdbarch *gdbarch,
}
static CORE_ADDR
-spu_read_pc (ptid_t ptid)
+spu_read_pc (struct regcache *regcache)
{
- CORE_ADDR pc = read_register_pid (SPU_PC_REGNUM, ptid);
+ ULONGEST pc;
+ regcache_cooked_read_unsigned (regcache, SPU_PC_REGNUM, &pc);
/* Mask off interrupt enable bit. */
return pc & -4;
}
static void
-spu_write_pc (CORE_ADDR pc, ptid_t ptid)
+spu_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
/* Keep interrupt enabled state unchanged. */
- CORE_ADDR old_pc = read_register_pid (SPU_PC_REGNUM, ptid);
- write_register_pid (SPU_PC_REGNUM, (pc & -4) | (old_pc & 3), ptid);
+ ULONGEST old_pc;
+ regcache_cooked_read_unsigned (regcache, SPU_PC_REGNUM, &old_pc);
+ regcache_cooked_write_unsigned (regcache, SPU_PC_REGNUM,
+ (pc & -4) | (old_pc & 3));
}
@@ -1188,16 +1191,14 @@ spu_breakpoint_from_pc (CORE_ADDR * pcpt
/* Software single-stepping support. */
int
-spu_software_single_step (struct regcache *regcache)
+spu_software_single_step (struct frame_info *frame)
{
CORE_ADDR pc, next_pc;
unsigned int insn;
int offset, reg;
gdb_byte buf[4];
- regcache_cooked_read (regcache, SPU_PC_REGNUM, buf);
- /* Mask off interrupt enable bit. */
- pc = extract_unsigned_integer (buf, 4) & -4;
+ pc = get_frame_pc (frame);
if (target_read_memory (pc, buf, 4))
return 1;
@@ -1221,7 +1222,7 @@ spu_software_single_step (struct regcach
target += pc;
else if (reg != -1)
{
- regcache_cooked_read_part (regcache, reg, 0, 4, buf);
+ get_frame_register_bytes (frame, reg, 0, 4, buf);
target += extract_unsigned_integer (buf, 4) & -4;
}
diff -urNp gdb-orig/gdb/symtab.h gdb-head/gdb/symtab.h
--- gdb-orig/gdb/symtab.h 2007-06-16 00:20:38.206222647 +0200
+++ gdb-head/gdb/symtab.h 2007-06-16 00:18:49.621375469 +0200
@@ -1191,7 +1191,7 @@ extern struct minimal_symbol *lookup_min
extern struct minimal_symbol
*lookup_solib_trampoline_symbol_by_pc (CORE_ADDR);
-extern CORE_ADDR find_solib_trampoline_target (CORE_ADDR);
+extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
extern void init_minimal_symbol_collection (void);
diff -urNp gdb-orig/gdb/v850-tdep.c gdb-head/gdb/v850-tdep.c
--- gdb-orig/gdb/v850-tdep.c 2007-06-16 00:20:50.444320104 +0200
+++ gdb-head/gdb/v850-tdep.c 2007-06-16 00:18:10.197070909 +0200
@@ -456,7 +456,7 @@ v850_is_save_register (int reg)
static CORE_ADDR
v850_analyze_prologue (CORE_ADDR func_addr, CORE_ADDR pc,
- struct v850_frame_cache *pi)
+ struct v850_frame_cache *pi, ULONGEST ctbp)
{
CORE_ADDR prologue_end, current_pc;
struct pifsr pifsrs[E_NUM_REGS + 1];
@@ -517,7 +517,6 @@ v850_analyze_prologue (CORE_ADDR func_ad
}
else if ((insn & 0xffc0) == 0x0200 && !regsave_func_p)
{ /* callt <imm6> */
- long ctbp = read_register (E_CTBP_REGNUM);
long adr = ctbp + ((insn & 0x3f) << 1);
save_pc = current_pc;
@@ -859,7 +858,11 @@ v850_frame_cache (struct frame_info *nex
cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME);
current_pc = frame_pc_unwind (next_frame);
if (cache->pc != 0)
- v850_analyze_prologue (cache->pc, current_pc, cache);
+ {
+ ULONGEST ctbp;
+ ctbp = frame_unwind_register_unsigned (next_frame, E_CTBP_REGNUM);
+ v850_analyze_prologue (cache->pc, current_pc, cache, ctbp);
+ }
if (!cache->uses_fp)
{
diff -urNp gdb-orig/gdb/xstormy16-tdep.c gdb-head/gdb/xstormy16-tdep.c
--- gdb-orig/gdb/xstormy16-tdep.c 2007-06-16 00:20:38.212221783 +0200
+++ gdb-head/gdb/xstormy16-tdep.c 2007-06-16 00:20:17.859094879 +0200
@@ -573,7 +573,7 @@ xstormy16_find_jmp_table_entry (CORE_ADD
}
static CORE_ADDR
-xstormy16_skip_trampoline_code (CORE_ADDR pc)
+xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (pc);
@@ -825,8 +825,6 @@ xstormy16_gdbarch_init (struct gdbarch_i
set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
- set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-
/* Stack grows up. */
set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
diff -urNp gdb-orig/gdb/xtensa-tdep.c gdb-head/gdb/xtensa-tdep.c
--- gdb-orig/gdb/xtensa-tdep.c 2007-06-16 00:20:45.059297824 +0200
+++ gdb-head/gdb/xtensa-tdep.c 2007-06-16 00:18:13.872074140 +0200
@@ -314,7 +314,8 @@ xtensa_reg_to_regnum (int regnum)
(Note: The size of masked registers is always less or equal 32 bits.) */
static void
-xtensa_register_write_masked (xtensa_register_t *reg, unsigned char *buffer)
+xtensa_register_write_masked (struct regcache *regcache,
+ xtensa_register_t *reg, const gdb_byte *buffer)
{
unsigned int value[(MAX_REGISTER_SIZE + 3) / 4];
@@ -383,10 +384,12 @@ xtensa_register_write_masked (xtensa_reg
if (r >= 0 && size > 0)
{
/* Don't overwrite the unmasked areas. */
+ ULONGEST old_val;
+ regcache_cooked_read_unsigned (regcache, r, &old_val);
m = 0xffffffff >> (32 - size) << start;
regval <<= start;
- regval = (regval & m) | (read_register (r) & ~m);
- write_register (r, regval);
+ regval = (regval & m) | (old_val & ~m);
+ regcache_cooked_write_unsigned (regcache, r, regval);
}
}
}
@@ -396,7 +399,8 @@ xtensa_register_write_masked (xtensa_reg
register. */
static void
-xtensa_register_read_masked (xtensa_register_t *reg, unsigned char *buffer)
+xtensa_register_read_masked (struct regcache *regcache,
+ xtensa_register_t *reg, gdb_byte *buffer)
{
unsigned int value[(MAX_REGISTER_SIZE + 3) / 4];
@@ -419,7 +423,15 @@ xtensa_register_read_masked (xtensa_regi
for (i = 0; i < mask->count; i++)
{
int r = mask->mask[i].reg_num;
- regval = (r >= 0) ? read_register (r) : 0;
+ if (r >= 0)
+ {
+ ULONGEST val;
+ regcache_cooked_read_unsigned (regcache, r, &val);
+ regval = (unsigned int) val;
+ }
+ else
+ regval = 0;
+
start = mask->mask[i].bit_start;
size = mask->mask[i].bit_size;
@@ -541,7 +553,7 @@ xtensa_pseudo_register_read (struct gdba
/* We can always read mapped registers. */
else if (type == xtRegisterTypeMapped || type == xtRegisterTypeTieState)
{
- xtensa_register_read_masked (reg, (unsigned char *) buffer);
+ xtensa_register_read_masked (regcache, reg, buffer);
return;
}
@@ -629,7 +641,7 @@ xtensa_pseudo_register_write (struct gdb
/* We can always write mapped registers. */
else if (type == xtRegisterTypeMapped || type == xtRegisterTypeTieState)
{
- xtensa_register_write_masked (reg, (unsigned char *) buffer);
+ xtensa_register_write_masked (regcache, reg, buffer);
return;
}
@@ -910,10 +922,9 @@ xtensa_frame_cache (struct frame_info *n
pc = frame_unwind_register_unsigned (next_frame, PC_REGNUM);
op1 = read_memory_integer (pc, 1);
- if (XTENSA_IS_ENTRY (op1) || !windowing_enabled (read_register (PS_REGNUM)))
+ if (XTENSA_IS_ENTRY (op1) || !windowing_enabled (ps))
{
- int callinc = CALLINC (frame_unwind_register_unsigned (next_frame,
- PS_REGNUM));
+ int callinc = CALLINC (ps);
ra = frame_unwind_register_unsigned (next_frame,
A0_REGNUM + callinc * 4);
@@ -924,7 +935,7 @@ xtensa_frame_cache (struct frame_info *n
cache->callsize = 0;
cache->wb = wb;
cache->ws = ws;
- cache->prev_sp = read_register (A1_REGNUM);
+ cache->prev_sp = frame_unwind_register_unsigned (next_frame, A1_REGNUM);
}
else
{
@@ -987,7 +998,7 @@ xtensa_frame_cache (struct frame_info *n
int regnum = AREG_NUMBER (A1_REGNUM, cache->wb);
- cache->prev_sp = read_register (regnum);
+ cache->prev_sp = frame_unwind_register_unsigned (next_frame, regnum);
}
}
@@ -1467,7 +1478,7 @@ xtensa_push_dummy_call (struct gdbarch *
/* ULONGEST v = extract_unsigned_integer (cp, REGISTER_SIZE);*/
regcache_cooked_write (regcache, r, cp);
- /* write_register (r, v); */
+ /* regcache_cooked_write_unsigned (regcache, r, v); */
cp += REGISTER_SIZE;
n -= REGISTER_SIZE;
r++;
--
Dr. Ulrich Weigand
GNU Toolchain for Linux on System z and Cell BE
Ulrich.Weigand@de.ibm.com