This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
[patch, arm] Use cached dsc->is_thumb instead of re-computing
- From: Yao Qi <yao at codesourcery dot com>
- To: gdb-patches at sourceware dot org
- Cc: Ulrich Weigand <uweigand at de dot ibm dot com>
- Date: Fri, 04 Mar 2011 21:29:36 +0800
- Subject: [patch, arm] Use cached dsc->is_thumb instead of re-computing
On 03/01/2011 05:01 PM, Yao Qi wrote:
>>>> >> > + if (displaced_in_arm_mode (regs))
>> > It would be somewhat nicer here to use dsc->is_thumb instead of
re-computing
>> > its value. However, the displaced_read_reg function doesn't have
the dsc
>> > argument, which is annoying (and asymmetrical to
displaced_write_reg ...).
>> >
>> > So if you want to make the effort to change all call sites to pass
in dsc,
>> > this would be nice, but I guess I'm also OK with doing it as above.
>> >
> Let us move this change to another patch.
>
During writing thumb displaced stepping, we find that displaced_read_reg
can be refactored to avoid calling displaced_in_arm_mode every time.
OK to apply?
--
Yao (éå)
2011-03-03 Yao Qi <yao@codesourcery.com>
* arm-tdep.c (displaced_read_reg): Add `dsc' parameter. Use cached
result instead of calling displaced_in_arm_mode again.
(branch_write_pc, alu_write_pc, load_write_pc): Add `dsc' parameter.
(displaced_write_reg, copy_preload, copy_preload_reg): Callers update.
(cleanup_copro_load_store, copy_copro_load_store): Likewise.
(cleanup_branch, copy_bx_blx_reg, copy_alu_imm): Likewise.
(cleanup_alu_reg, copy_alu_reg, cleanup_alu_shifted_reg): Likewise.
(copy_alu_shifted_reg, cleanup_load, cleanup_store): Likewise.
(copy_extra_ld_st, copy_ldr_str_ldrb_strb): Likewise.
(cleanup_block_load_all, cleanup_block_store_pc): Likewise.
(cleanup_block_load_pc, copy_block_xfer): Likewise.
* arm-linux-tdep.c (arm_linux_copy_svc): Callers update.
(arm_catch_kernel_helper_return): Likewise.
* gdb/arm-tdep.h : Update function declarations.
diff --git a/gdb/arm-linux-tdep.c b/gdb/arm-linux-tdep.c
index f60ecc3..6e49cb1 100644
--- a/gdb/arm-linux-tdep.c
+++ b/gdb/arm-linux-tdep.c
@@ -805,7 +805,7 @@ arm_linux_copy_svc (struct gdbarch *gdbarch, uint32_t insn, CORE_ADDR to,
CORE_ADDR return_to = 0;
struct frame_info *frame;
- unsigned int svc_number = displaced_read_reg (regs, from, 7);
+ unsigned int svc_number = displaced_read_reg (regs, dsc, from, 7);
int is_sigreturn = 0;
if (debug_displaced)
@@ -918,7 +918,7 @@ arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from,
Insn: ldr pc, [r14, #4]
Cleanup: r14 <- tmp[0], pc <- tmp[0]. */
- dsc->tmp[0] = displaced_read_reg (regs, from, ARM_LR_REGNUM);
+ dsc->tmp[0] = displaced_read_reg (regs, dsc, from, ARM_LR_REGNUM);
displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
CANNOT_WRITE_PC);
write_memory_unsigned_integer (to + 8, 4, byte_order, from);
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index 2cf2eec..b277faf 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -5118,7 +5118,8 @@ static int displaced_in_arm_mode (struct regcache *regs);
location. */
ULONGEST
-displaced_read_reg (struct regcache *regs, CORE_ADDR from, int regno)
+displaced_read_reg (struct regcache *regs, struct displaced_step_closure *dsc,
+ CORE_ADDR from, int regno)
{
ULONGEST ret;
@@ -5130,7 +5131,7 @@ displaced_read_reg (struct regcache *regs, CORE_ADDR from, int regno)
- When executing a Thumb instruction, PC reads as the address of the
current instruction plus 4. */
- if (displaced_in_arm_mode (regs))
+ if (!dsc->is_thumb)
from += 8;
else
from += 4;
@@ -5164,9 +5165,10 @@ displaced_in_arm_mode (struct regcache *regs)
/* Write to the PC as from a branch instruction. */
static void
-branch_write_pc (struct regcache *regs, ULONGEST val)
+branch_write_pc (struct regcache *regs, struct displaced_step_closure *dsc,
+ ULONGEST val)
{
- if (displaced_in_arm_mode (regs))
+ if (!dsc->is_thumb)
/* Note: If bits 0/1 are set, this branch would be unpredictable for
architecture versions < 6. */
regcache_cooked_write_unsigned (regs, ARM_PC_REGNUM,
@@ -5209,23 +5211,25 @@ bx_write_pc (struct regcache *regs, ULONGEST val)
/* Write to the PC as if from a load instruction. */
static void
-load_write_pc (struct regcache *regs, ULONGEST val)
+load_write_pc (struct regcache *regs, struct displaced_step_closure *dsc,
+ ULONGEST val)
{
if (DISPLACED_STEPPING_ARCH_VERSION >= 5)
bx_write_pc (regs, val);
else
- branch_write_pc (regs, val);
+ branch_write_pc (regs, dsc, val);
}
/* Write to the PC as if from an ALU instruction. */
static void
-alu_write_pc (struct regcache *regs, ULONGEST val)
+alu_write_pc (struct regcache *regs, struct displaced_step_closure *dsc,
+ ULONGEST val)
{
- if (DISPLACED_STEPPING_ARCH_VERSION >= 7 && displaced_in_arm_mode (regs))
+ if (DISPLACED_STEPPING_ARCH_VERSION >= 7 && !dsc->is_thumb)
bx_write_pc (regs, val);
else
- branch_write_pc (regs, val);
+ branch_write_pc (regs, dsc, val);
}
/* Helper for writing to registers for displaced stepping. Writing to the PC
@@ -5244,7 +5248,7 @@ displaced_write_reg (struct regcache *regs, struct displaced_step_closure *dsc,
switch (write_pc)
{
case BRANCH_WRITE_PC:
- branch_write_pc (regs, val);
+ branch_write_pc (regs, dsc, val);
break;
case BX_WRITE_PC:
@@ -5252,11 +5256,11 @@ displaced_write_reg (struct regcache *regs, struct displaced_step_closure *dsc,
break;
case LOAD_WRITE_PC:
- load_write_pc (regs, val);
+ load_write_pc (regs, dsc, val);
break;
case ALU_WRITE_PC:
- alu_write_pc (regs, val);
+ alu_write_pc (regs, dsc, val);
break;
case CANNOT_WRITE_PC:
@@ -5361,8 +5365,8 @@ copy_preload (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
->
{pli/pld} [r0, #+/-imm]. */
- dsc->tmp[0] = displaced_read_reg (regs, from, 0);
- rn_val = displaced_read_reg (regs, from, rn);
+ dsc->tmp[0] = displaced_read_reg (regs, dsc, from, 0);
+ rn_val = displaced_read_reg (regs, dsc, from, rn);
displaced_write_reg (regs, dsc, 0, rn_val, CANNOT_WRITE_PC);
dsc->u.preload.immed = 1;
@@ -5399,10 +5403,10 @@ copy_preload_reg (struct gdbarch *gdbarch, uint32_t insn,
->
{pli/pld} [r0, r1 {, shift}]. */
- dsc->tmp[0] = displaced_read_reg (regs, from, 0);
- dsc->tmp[1] = displaced_read_reg (regs, from, 1);
- rn_val = displaced_read_reg (regs, from, rn);
- rm_val = displaced_read_reg (regs, from, rm);
+ dsc->tmp[0] = displaced_read_reg (regs, dsc, from, 0);
+ dsc->tmp[1] = displaced_read_reg (regs, dsc, from, 1);
+ rn_val = displaced_read_reg (regs, dsc, from, rn);
+ rm_val = displaced_read_reg (regs, dsc, from, rm);
displaced_write_reg (regs, dsc, 0, rn_val, CANNOT_WRITE_PC);
displaced_write_reg (regs, dsc, 1, rm_val, CANNOT_WRITE_PC);
@@ -5422,7 +5426,7 @@ cleanup_copro_load_store (struct gdbarch *gdbarch,
struct regcache *regs,
struct displaced_step_closure *dsc)
{
- ULONGEST rn_val = displaced_read_reg (regs, dsc->insn_addr, 0);
+ ULONGEST rn_val = displaced_read_reg (regs, dsc, dsc->insn_addr, 0);
displaced_write_reg (regs, dsc, 0, dsc->tmp[0], CANNOT_WRITE_PC);
@@ -5454,8 +5458,8 @@ copy_copro_load_store (struct gdbarch *gdbarch, uint32_t insn,
ldc/ldc2 are handled identically. */
- dsc->tmp[0] = displaced_read_reg (regs, from, 0);
- rn_val = displaced_read_reg (regs, from, rn);
+ dsc->tmp[0] = displaced_read_reg (regs, dsc, from, 0);
+ rn_val = displaced_read_reg (regs, dsc, from, rn);
displaced_write_reg (regs, dsc, 0, rn_val, CANNOT_WRITE_PC);
dsc->u.ldst.writeback = bit (insn, 25);
@@ -5476,7 +5480,7 @@ cleanup_branch (struct gdbarch *gdbarch, struct regcache *regs,
struct displaced_step_closure *dsc)
{
ULONGEST from = dsc->insn_addr;
- uint32_t status = displaced_read_reg (regs, from, ARM_PS_REGNUM);
+ uint32_t status = displaced_read_reg (regs, dsc, from, ARM_PS_REGNUM);
int branch_taken = condition_true (dsc->u.branch.cond, status);
enum pc_write_style write_pc = dsc->u.branch.exchange
? BX_WRITE_PC : BRANCH_WRITE_PC;
@@ -5486,7 +5490,7 @@ cleanup_branch (struct gdbarch *gdbarch, struct regcache *regs,
if (dsc->u.branch.link)
{
- ULONGEST pc = displaced_read_reg (regs, from, ARM_PC_REGNUM);
+ ULONGEST pc = displaced_read_reg (regs, dsc, from, ARM_PC_REGNUM);
displaced_write_reg (regs, dsc, ARM_LR_REGNUM, pc - 4, CANNOT_WRITE_PC);
}
@@ -5566,7 +5570,7 @@ copy_bx_blx_reg (struct gdbarch *gdbarch, uint32_t insn,
Don't set r14 in cleanup for BX. */
- dsc->u.branch.dest = displaced_read_reg (regs, from, rm);
+ dsc->u.branch.dest = displaced_read_reg (regs, dsc, from, rm);
dsc->u.branch.cond = cond;
dsc->u.branch.link = link;
@@ -5585,7 +5589,7 @@ static void
cleanup_alu_imm (struct gdbarch *gdbarch,
struct regcache *regs, struct displaced_step_closure *dsc)
{
- ULONGEST rd_val = displaced_read_reg (regs, dsc->insn_addr, 0);
+ ULONGEST rd_val = displaced_read_reg (regs, dsc, dsc->insn_addr, 0);
displaced_write_reg (regs, dsc, 0, dsc->tmp[0], CANNOT_WRITE_PC);
displaced_write_reg (regs, dsc, 1, dsc->tmp[1], CANNOT_WRITE_PC);
displaced_write_reg (regs, dsc, dsc->rd, rd_val, ALU_WRITE_PC);
@@ -5622,10 +5626,10 @@ copy_alu_imm (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
Cleanup: rd <- r0; r0 <- tmp1; r1 <- tmp2
*/
- dsc->tmp[0] = displaced_read_reg (regs, from, 0);
- dsc->tmp[1] = displaced_read_reg (regs, from, 1);
- rn_val = displaced_read_reg (regs, from, rn);
- rd_val = displaced_read_reg (regs, from, rd);
+ dsc->tmp[0] = displaced_read_reg (regs, dsc, from, 0);
+ dsc->tmp[1] = displaced_read_reg (regs, dsc, from, 1);
+ rn_val = displaced_read_reg (regs, dsc, from, rn);
+ rd_val = displaced_read_reg (regs, dsc, from, rd);
displaced_write_reg (regs, dsc, 0, rd_val, CANNOT_WRITE_PC);
displaced_write_reg (regs, dsc, 1, rn_val, CANNOT_WRITE_PC);
dsc->rd = rd;
@@ -5649,7 +5653,7 @@ cleanup_alu_reg (struct gdbarch *gdbarch,
ULONGEST rd_val;
int i;
- rd_val = displaced_read_reg (regs, dsc->insn_addr, 0);
+ rd_val = displaced_read_reg (regs, dsc, dsc->insn_addr, 0);
for (i = 0; i < 3; i++)
displaced_write_reg (regs, dsc, i, dsc->tmp[i], CANNOT_WRITE_PC);
@@ -5688,12 +5692,12 @@ copy_alu_reg (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
Cleanup: rd <- r0; r0, r1, r2 <- tmp1, tmp2, tmp3
*/
- dsc->tmp[0] = displaced_read_reg (regs, from, 0);
- dsc->tmp[1] = displaced_read_reg (regs, from, 1);
- dsc->tmp[2] = displaced_read_reg (regs, from, 2);
- rd_val = displaced_read_reg (regs, from, rd);
- rn_val = displaced_read_reg (regs, from, rn);
- rm_val = displaced_read_reg (regs, from, rm);
+ dsc->tmp[0] = displaced_read_reg (regs, dsc, from, 0);
+ dsc->tmp[1] = displaced_read_reg (regs, dsc, from, 1);
+ dsc->tmp[2] = displaced_read_reg (regs, dsc, from, 2);
+ rd_val = displaced_read_reg (regs, dsc, from, rd);
+ rn_val = displaced_read_reg (regs, dsc, from, rn);
+ rm_val = displaced_read_reg (regs, dsc, from, rm);
displaced_write_reg (regs, dsc, 0, rd_val, CANNOT_WRITE_PC);
displaced_write_reg (regs, dsc, 1, rn_val, CANNOT_WRITE_PC);
displaced_write_reg (regs, dsc, 2, rm_val, CANNOT_WRITE_PC);
@@ -5716,7 +5720,7 @@ cleanup_alu_shifted_reg (struct gdbarch *gdbarch,
struct regcache *regs,
struct displaced_step_closure *dsc)
{
- ULONGEST rd_val = displaced_read_reg (regs, dsc->insn_addr, 0);
+ ULONGEST rd_val = displaced_read_reg (regs, dsc, dsc->insn_addr, 0);
int i;
for (i = 0; i < 4; i++)
@@ -5762,12 +5766,12 @@ copy_alu_shifted_reg (struct gdbarch *gdbarch, uint32_t insn,
*/
for (i = 0; i < 4; i++)
- dsc->tmp[i] = displaced_read_reg (regs, from, i);
+ dsc->tmp[i] = displaced_read_reg (regs, dsc, from, i);
- rd_val = displaced_read_reg (regs, from, rd);
- rn_val = displaced_read_reg (regs, from, rn);
- rm_val = displaced_read_reg (regs, from, rm);
- rs_val = displaced_read_reg (regs, from, rs);
+ rd_val = displaced_read_reg (regs, dsc, from, rd);
+ rn_val = displaced_read_reg (regs, dsc, from, rn);
+ rm_val = displaced_read_reg (regs, dsc, from, rm);
+ rs_val = displaced_read_reg (regs, dsc, from, rs);
displaced_write_reg (regs, dsc, 0, rd_val, CANNOT_WRITE_PC);
displaced_write_reg (regs, dsc, 1, rn_val, CANNOT_WRITE_PC);
displaced_write_reg (regs, dsc, 2, rm_val, CANNOT_WRITE_PC);
@@ -5793,10 +5797,10 @@ cleanup_load (struct gdbarch *gdbarch, struct regcache *regs,
ULONGEST rt_val, rt_val2 = 0, rn_val;
CORE_ADDR from = dsc->insn_addr;
- rt_val = displaced_read_reg (regs, from, 0);
+ rt_val = displaced_read_reg (regs, dsc, from, 0);
if (dsc->u.ldst.xfersize == 8)
- rt_val2 = displaced_read_reg (regs, from, 1);
- rn_val = displaced_read_reg (regs, from, 2);
+ rt_val2 = displaced_read_reg (regs, dsc, from, 1);
+ rn_val = displaced_read_reg (regs, dsc, from, 2);
displaced_write_reg (regs, dsc, 0, dsc->tmp[0], CANNOT_WRITE_PC);
if (dsc->u.ldst.xfersize > 4)
@@ -5821,7 +5825,7 @@ cleanup_store (struct gdbarch *gdbarch, struct regcache *regs,
struct displaced_step_closure *dsc)
{
CORE_ADDR from = dsc->insn_addr;
- ULONGEST rn_val = displaced_read_reg (regs, from, 2);
+ ULONGEST rn_val = displaced_read_reg (regs, dsc, from, 2);
displaced_write_reg (regs, dsc, 0, dsc->tmp[0], CANNOT_WRITE_PC);
if (dsc->u.ldst.xfersize > 4)
@@ -5870,18 +5874,18 @@ copy_extra_ld_st (struct gdbarch *gdbarch, uint32_t insn, int unpriveleged,
internal_error (__FILE__, __LINE__,
_("copy_extra_ld_st: instruction decode error"));
- dsc->tmp[0] = displaced_read_reg (regs, from, 0);
- dsc->tmp[1] = displaced_read_reg (regs, from, 1);
- dsc->tmp[2] = displaced_read_reg (regs, from, 2);
+ dsc->tmp[0] = displaced_read_reg (regs, dsc, from, 0);
+ dsc->tmp[1] = displaced_read_reg (regs, dsc, from, 1);
+ dsc->tmp[2] = displaced_read_reg (regs, dsc, from, 2);
if (!immed)
- dsc->tmp[3] = displaced_read_reg (regs, from, 3);
+ dsc->tmp[3] = displaced_read_reg (regs, dsc, from, 3);
- rt_val = displaced_read_reg (regs, from, rt);
+ rt_val = displaced_read_reg (regs, dsc, from, rt);
if (bytesize[opcode] == 8)
- rt_val2 = displaced_read_reg (regs, from, rt + 1);
- rn_val = displaced_read_reg (regs, from, rn);
+ rt_val2 = displaced_read_reg (regs, dsc, from, rt + 1);
+ rn_val = displaced_read_reg (regs, dsc, from, rn);
if (!immed)
- rm_val = displaced_read_reg (regs, from, rm);
+ rm_val = displaced_read_reg (regs, dsc, from, rm);
displaced_write_reg (regs, dsc, 0, rt_val, CANNOT_WRITE_PC);
if (bytesize[opcode] == 8)
@@ -5937,17 +5941,17 @@ copy_ldr_str_ldrb_strb (struct gdbarch *gdbarch, uint32_t insn,
: (byte ? "strb" : "str"), usermode ? "t" : "",
(unsigned long) insn);
- dsc->tmp[0] = displaced_read_reg (regs, from, 0);
- dsc->tmp[2] = displaced_read_reg (regs, from, 2);
+ dsc->tmp[0] = displaced_read_reg (regs, dsc, from, 0);
+ dsc->tmp[2] = displaced_read_reg (regs, dsc, from, 2);
if (!immed)
- dsc->tmp[3] = displaced_read_reg (regs, from, 3);
+ dsc->tmp[3] = displaced_read_reg (regs, dsc, from, 3);
if (!load)
- dsc->tmp[4] = displaced_read_reg (regs, from, 4);
+ dsc->tmp[4] = displaced_read_reg (regs, dsc, from, 4);
- rt_val = displaced_read_reg (regs, from, rt);
- rn_val = displaced_read_reg (regs, from, rn);
+ rt_val = displaced_read_reg (regs, dsc, from, rt);
+ rn_val = displaced_read_reg (regs, dsc, from, rn);
if (!immed)
- rm_val = displaced_read_reg (regs, from, rm);
+ rm_val = displaced_read_reg (regs, dsc, from, rm);
displaced_write_reg (regs, dsc, 0, rt_val, CANNOT_WRITE_PC);
displaced_write_reg (regs, dsc, 2, rn_val, CANNOT_WRITE_PC);
@@ -6056,7 +6060,7 @@ cleanup_block_load_all (struct gdbarch *gdbarch, struct regcache *regs,
CORE_ADDR xfer_addr = dsc->u.block.xfer_addr;
int exception_return = dsc->u.block.load && dsc->u.block.user
&& (regmask & 0x8000) != 0;
- uint32_t status = displaced_read_reg (regs, from, ARM_PS_REGNUM);
+ uint32_t status = displaced_read_reg (regs, dsc, from, ARM_PS_REGNUM);
int do_transfer = condition_true (dsc->u.block.cond, status);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
@@ -6110,7 +6114,7 @@ cleanup_block_store_pc (struct gdbarch *gdbarch, struct regcache *regs,
struct displaced_step_closure *dsc)
{
ULONGEST from = dsc->insn_addr;
- uint32_t status = displaced_read_reg (regs, from, ARM_PS_REGNUM);
+ uint32_t status = displaced_read_reg (regs, dsc, from, ARM_PS_REGNUM);
int store_executed = condition_true (dsc->u.block.cond, status);
CORE_ADDR pc_stored_at, transferred_regs = bitcount (dsc->u.block.regmask);
CORE_ADDR stm_insn_addr;
@@ -6162,7 +6166,7 @@ cleanup_block_load_pc (struct gdbarch *gdbarch,
struct displaced_step_closure *dsc)
{
ULONGEST from = dsc->insn_addr;
- uint32_t status = displaced_read_reg (regs, from, ARM_PS_REGNUM);
+ uint32_t status = displaced_read_reg (regs, dsc, from, ARM_PS_REGNUM);
int load_executed = condition_true (dsc->u.block.cond, status), i;
unsigned int mask = dsc->u.block.regmask, write_reg = ARM_PC_REGNUM;
unsigned int regs_loaded = bitcount (mask);
@@ -6185,7 +6189,7 @@ cleanup_block_load_pc (struct gdbarch *gdbarch,
if (read_reg != write_reg)
{
- ULONGEST rval = displaced_read_reg (regs, from, read_reg);
+ ULONGEST rval = displaced_read_reg (regs, dsc, from, read_reg);
displaced_write_reg (regs, dsc, write_reg, rval, LOAD_WRITE_PC);
if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, _("displaced: LDM: move "
@@ -6265,7 +6269,7 @@ copy_block_xfer (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
fprintf_unfiltered (gdb_stdlog, "displaced: copying block transfer insn "
"%.8lx\n", (unsigned long) insn);
- dsc->u.block.xfer_addr = displaced_read_reg (regs, from, rn);
+ dsc->u.block.xfer_addr = displaced_read_reg (regs, dsc, from, rn);
dsc->u.block.rn = rn;
dsc->u.block.load = load;
@@ -6301,7 +6305,7 @@ copy_block_xfer (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
unsigned int to = 0, from = 0, i, new_rn;
for (i = 0; i < num_in_list; i++)
- dsc->tmp[i] = displaced_read_reg (regs, from, i);
+ dsc->tmp[i] = displaced_read_reg (regs, dsc, from, i);
/* Writeback makes things complicated. We need to avoid clobbering
the base register with one of the registers in our modified
diff --git a/gdb/arm-tdep.h b/gdb/arm-tdep.h
index 362be2e..e77d99a 100644
--- a/gdb/arm-tdep.h
+++ b/gdb/arm-tdep.h
@@ -302,7 +302,8 @@ extern void
arm_displaced_init_closure (struct gdbarch *gdbarch, CORE_ADDR from,
CORE_ADDR to, struct displaced_step_closure *dsc);
extern ULONGEST
- displaced_read_reg (struct regcache *regs, CORE_ADDR from, int regno);
+ displaced_read_reg (struct regcache *regs, struct displaced_step_closure *dsc,
+ CORE_ADDR from, int regno);
extern void
displaced_write_reg (struct regcache *regs,
struct displaced_step_closure *dsc, int regno,