mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-21 01:12:32 +08:00
gdb: introduce displaced_debug_printf
Move all debug prints of the "displaced" category to use a new
displaced_debug_printf macro, like what was done for infrun and others
earlier.
The debug output for one displaced step one amd64 looks like:
[displaced] displaced_step_prepare_throw: stepping process 3367044 now
[displaced] displaced_step_prepare_throw: saved 0x555555555042: 1e fa 31 ed 49 89 d1 5e 48 89 e2 48 83 e4 f0 50
[displaced] amd64_displaced_step_copy_insn: copy 0x555555555131->0x555555555042: b8 00 00 00 00 5d c3 0f 1f 84 00 00 00 00 00 f3
[displaced] displaced_step_prepare_throw: displaced pc to 0x555555555042
[displaced] resume_1: run 0x555555555042: b8 00 00 00
[displaced] displaced_step_restore: restored process 3367044 0x555555555042
[displaced] amd64_displaced_step_fixup: fixup (0x555555555131, 0x555555555042), insn = 0xb8 0x00 ...
[displaced] amd64_displaced_step_fixup: relocated %rip from 0x555555555047 to 0x555555555136
On test case needed to be updated because it relied on the specific
formatting of the message.
gdb/ChangeLog:
* infrun.h (displaced_debug_printf): New macro. Replace
displaced debug prints throughout to use it.
(displaced_debug_printf_1): New declaration.
(displaced_step_dump_bytes): Return string, remove ui_file
parameter, update all callers.
* infrun.c (displaced_debug_printf_1): New function.
(displaced_step_dump_bytes): Return string, remove ui_file
parameter
gdb/testsuite/ChangeLog:
* gdb.arch/amd64-disp-step-avx.exp: Update displaced step debug
expected output.
Change-Id: Ie78837f56431f6f98378790ba1e6051337bf6533
This commit is contained in:
Simon Marchi
parent
aa2045e7fa
commit
136821d9f6
@ -1,3 +1,14 @@
|
||||
2020-10-30 Simon Marchi <simon.marchi@efficios.com>
|
||||
|
||||
* infrun.h (displaced_debug_printf): New macro. Replace
|
||||
displaced debug prints throughout to use it.
|
||||
(displaced_debug_printf_1): New declaration.
|
||||
(displaced_step_dump_bytes): Return string, remove ui_file
|
||||
parameter, update all callers.
|
||||
* infrun.c (displaced_debug_printf_1): New function.
|
||||
(displaced_step_dump_bytes): Return string, remove ui_file
|
||||
parameter
|
||||
|
||||
2020-10-30 Simon Marchi <simon.marchi@polymtl.ca>
|
||||
|
||||
* rs6000-tdep.c (rs6000_dwarf2_reg_to_regnum): Return -1 for
|
||||
|
||||
@ -3177,12 +3177,10 @@ aarch64_displaced_step_copy_insn (struct gdbarch *gdbarch,
|
||||
relocated instruction(s) there. */
|
||||
for (i = 0; i < dsd.insn_count; i++)
|
||||
{
|
||||
if (debug_displaced)
|
||||
{
|
||||
debug_printf ("displaced: writing insn ");
|
||||
debug_printf ("%.8x", dsd.insn_buf[i]);
|
||||
debug_printf (" at %s\n", paddress (gdbarch, to + i * 4));
|
||||
}
|
||||
displaced_debug_printf ("writing insn %.8x at %s",
|
||||
dsd.insn_buf[i],
|
||||
paddress (gdbarch, to + i * 4));
|
||||
|
||||
write_memory_unsigned_integer (to + i * 4, 4, byte_order_for_code,
|
||||
(ULONGEST) dsd.insn_buf[i]);
|
||||
}
|
||||
@ -3210,15 +3208,13 @@ aarch64_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
|
||||
regcache_cooked_read_unsigned (regs, AARCH64_PC_REGNUM, &pc);
|
||||
|
||||
if (debug_displaced)
|
||||
debug_printf ("Displaced: PC after stepping: %s (was %s).\n",
|
||||
paddress (gdbarch, pc), paddress (gdbarch, to));
|
||||
displaced_debug_printf ("PC after stepping: %s (was %s).",
|
||||
paddress (gdbarch, pc), paddress (gdbarch, to));
|
||||
|
||||
if (dsc->cond)
|
||||
{
|
||||
if (debug_displaced)
|
||||
debug_printf ("Displaced: [Conditional] pc_adjust before: %d\n",
|
||||
dsc->pc_adjust);
|
||||
displaced_debug_printf ("[Conditional] pc_adjust before: %d",
|
||||
dsc->pc_adjust);
|
||||
|
||||
if (pc - to == 8)
|
||||
{
|
||||
@ -3232,16 +3228,13 @@ aarch64_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
else
|
||||
gdb_assert_not_reached ("Unexpected PC value after displaced stepping");
|
||||
|
||||
if (debug_displaced)
|
||||
debug_printf ("Displaced: [Conditional] pc_adjust after: %d\n",
|
||||
dsc->pc_adjust);
|
||||
displaced_debug_printf ("[Conditional] pc_adjust after: %d",
|
||||
dsc->pc_adjust);
|
||||
}
|
||||
|
||||
if (debug_displaced)
|
||||
debug_printf ("Displaced: %s PC by %d\n",
|
||||
dsc->pc_adjust? "adjusting" : "not adjusting",
|
||||
dsc->pc_adjust);
|
||||
|
||||
displaced_debug_printf ("%s PC by %d",
|
||||
dsc->pc_adjust ? "adjusting" : "not adjusting",
|
||||
dsc->pc_adjust);
|
||||
|
||||
if (dsc->pc_adjust != 0)
|
||||
{
|
||||
@ -3251,17 +3244,13 @@ aarch64_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
took place. */
|
||||
if ((pc - to) == 0)
|
||||
{
|
||||
if (debug_displaced)
|
||||
debug_printf ("Displaced: PC did not move. Discarding PC "
|
||||
"adjustment.\n");
|
||||
displaced_debug_printf ("PC did not move. Discarding PC adjustment.");
|
||||
dsc->pc_adjust = 0;
|
||||
}
|
||||
|
||||
if (debug_displaced)
|
||||
{
|
||||
debug_printf ("Displaced: fixup: set PC to %s:%d\n",
|
||||
paddress (gdbarch, from), dsc->pc_adjust);
|
||||
}
|
||||
displaced_debug_printf ("fixup: set PC to %s:%d",
|
||||
paddress (gdbarch, from), dsc->pc_adjust);
|
||||
|
||||
regcache_cooked_write_unsigned (regs, AARCH64_PC_REGNUM,
|
||||
from + dsc->pc_adjust);
|
||||
}
|
||||
|
||||
@ -1438,11 +1438,10 @@ fixup_riprel (struct gdbarch *gdbarch, amd64_displaced_step_closure *dsc,
|
||||
|
||||
regcache_cooked_write_unsigned (regs, tmp_regno, rip_base);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: %%rip-relative addressing used.\n"
|
||||
"displaced: using temp reg %d, old value %s, new value %s\n",
|
||||
dsc->tmp_regno, paddress (gdbarch, dsc->tmp_save),
|
||||
paddress (gdbarch, rip_base));
|
||||
displaced_debug_printf ("%%rip-relative addressing used.");
|
||||
displaced_debug_printf ("using temp reg %d, old value %s, new value %s",
|
||||
dsc->tmp_regno, paddress (gdbarch, dsc->tmp_save),
|
||||
paddress (gdbarch, rip_base));
|
||||
}
|
||||
|
||||
static void
|
||||
@ -1504,12 +1503,9 @@ amd64_displaced_step_copy_insn (struct gdbarch *gdbarch,
|
||||
|
||||
write_memory (to, buf, len);
|
||||
|
||||
if (debug_displaced)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to));
|
||||
displaced_step_dump_bytes (gdb_stdlog, buf, len);
|
||||
}
|
||||
displaced_debug_printf ("copy %s->%s: %s",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to),
|
||||
displaced_step_dump_bytes (buf, len).c_str ());
|
||||
|
||||
/* This is a work around for a problem with g++ 4.8. */
|
||||
return displaced_step_closure_up (dsc.release ());
|
||||
@ -1685,20 +1681,16 @@ amd64_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
gdb_byte *insn = dsc->insn_buf.data ();
|
||||
const struct amd64_insn *insn_details = &dsc->insn_details;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: fixup (%s, %s), "
|
||||
"insn = 0x%02x 0x%02x ...\n",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to),
|
||||
insn[0], insn[1]);
|
||||
displaced_debug_printf ("fixup (%s, %s), insn = 0x%02x 0x%02x ...",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to),
|
||||
insn[0], insn[1]);
|
||||
|
||||
/* If we used a tmp reg, restore it. */
|
||||
|
||||
if (dsc->tmp_used)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: restoring reg %d to %s\n",
|
||||
dsc->tmp_regno, paddress (gdbarch, dsc->tmp_save));
|
||||
displaced_debug_printf ("restoring reg %d to %s",
|
||||
dsc->tmp_regno, paddress (gdbarch, dsc->tmp_save));
|
||||
regcache_cooked_write_unsigned (regs, dsc->tmp_regno, dsc->tmp_save);
|
||||
}
|
||||
|
||||
@ -1743,12 +1735,7 @@ amd64_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
Presumably this is a kernel bug.
|
||||
Fixup ensures its a nop, we add one to the length for it. */
|
||||
&& orig_rip != to + insn_len + 1)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: syscall changed %%rip; "
|
||||
"not relocating\n");
|
||||
}
|
||||
displaced_debug_printf ("syscall changed %%rip; not relocating");
|
||||
else
|
||||
{
|
||||
ULONGEST rip = orig_rip - insn_offset;
|
||||
@ -1759,12 +1746,9 @@ amd64_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
|
||||
regcache_cooked_write_unsigned (regs, AMD64_RIP_REGNUM, rip);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: "
|
||||
"relocated %%rip from %s to %s\n",
|
||||
paddress (gdbarch, orig_rip),
|
||||
paddress (gdbarch, rip));
|
||||
displaced_debug_printf ("relocated %%rip from %s to %s",
|
||||
paddress (gdbarch, orig_rip),
|
||||
paddress (gdbarch, rip));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1787,12 +1771,9 @@ amd64_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
retaddr = (retaddr - insn_offset) & 0xffffffffffffffffULL;
|
||||
write_memory_unsigned_integer (rsp, retaddr_len, byte_order, retaddr);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: relocated return addr at %s "
|
||||
"to %s\n",
|
||||
paddress (gdbarch, rsp),
|
||||
paddress (gdbarch, retaddr));
|
||||
displaced_debug_printf ("relocated return addr at %s to %s",
|
||||
paddress (gdbarch, rsp),
|
||||
paddress (gdbarch, retaddr));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1910,12 +1891,9 @@ amd64_relocate_instruction (struct gdbarch *gdbarch,
|
||||
newrel = (oldloc - *to) + rel32;
|
||||
store_signed_integer (insn + 1, 4, byte_order, newrel);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"Adjusted insn rel32=%s at %s to"
|
||||
" rel32=%s at %s\n",
|
||||
hex_string (rel32), paddress (gdbarch, oldloc),
|
||||
hex_string (newrel), paddress (gdbarch, *to));
|
||||
displaced_debug_printf ("adjusted insn rel32=%s at %s to rel32=%s at %s",
|
||||
hex_string (rel32), paddress (gdbarch, oldloc),
|
||||
hex_string (newrel), paddress (gdbarch, *to));
|
||||
|
||||
/* Write the adjusted jump into its displaced location. */
|
||||
append_insns (to, 5, insn);
|
||||
@ -1939,12 +1917,9 @@ amd64_relocate_instruction (struct gdbarch *gdbarch,
|
||||
rel32 = extract_signed_integer (insn + offset, 4, byte_order);
|
||||
newrel = (oldloc - *to) + rel32;
|
||||
store_signed_integer (insn + offset, 4, byte_order, newrel);
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"Adjusted insn rel32=%s at %s to"
|
||||
" rel32=%s at %s\n",
|
||||
hex_string (rel32), paddress (gdbarch, oldloc),
|
||||
hex_string (newrel), paddress (gdbarch, *to));
|
||||
displaced_debug_printf ("adjusted insn rel32=%s at %s to rel32=%s at %s",
|
||||
hex_string (rel32), paddress (gdbarch, oldloc),
|
||||
hex_string (newrel), paddress (gdbarch, *to));
|
||||
}
|
||||
|
||||
/* Write the adjusted instruction into its displaced location. */
|
||||
|
||||
@ -957,15 +957,11 @@ arm_linux_cleanup_svc (struct gdbarch *gdbarch,
|
||||
&& apparent_pc < (dsc->scratch_base
|
||||
+ ARM_DISPLACED_MODIFIED_INSNS * 4 + 4));
|
||||
|
||||
if (debug_displaced)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after "
|
||||
"SVC step ", (unsigned long) apparent_pc);
|
||||
if (within_scratch)
|
||||
fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n");
|
||||
else
|
||||
fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n");
|
||||
}
|
||||
displaced_debug_printf ("PC is apparently %.8lx after SVC step %s",
|
||||
(unsigned long) apparent_pc,
|
||||
(within_scratch
|
||||
? "(within scratch space)"
|
||||
: "(outside scratch space)"));
|
||||
|
||||
if (within_scratch)
|
||||
displaced_write_reg (regs, dsc, ARM_PC_REGNUM,
|
||||
@ -991,16 +987,12 @@ arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs,
|
||||
{
|
||||
struct symtab_and_line sal;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: found "
|
||||
"sigreturn/rt_sigreturn SVC call. PC in "
|
||||
"frame = %lx\n",
|
||||
(unsigned long) get_frame_pc (frame));
|
||||
displaced_debug_printf ("found sigreturn/rt_sigreturn SVC call. "
|
||||
"PC in frame = %lx",
|
||||
(unsigned long) get_frame_pc (frame));
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx. "
|
||||
"Setting momentary breakpoint.\n",
|
||||
(unsigned long) return_to);
|
||||
displaced_debug_printf ("unwind pc = %lx. Setting momentary breakpoint.",
|
||||
(unsigned long) return_to);
|
||||
|
||||
gdb_assert (inferior_thread ()->control.step_resume_breakpoint
|
||||
== NULL);
|
||||
@ -1025,13 +1017,12 @@ arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs,
|
||||
breakpoint set above. */
|
||||
insert_breakpoints ();
|
||||
}
|
||||
else if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
|
||||
"frame to set momentary breakpoint for "
|
||||
"sigreturn/rt_sigreturn\n");
|
||||
else
|
||||
displaced_debug_printf ("couldn't find previous frame to set momentary "
|
||||
"breakpoint for sigreturn/rt_sigreturn");
|
||||
}
|
||||
else if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: found SVC call\n");
|
||||
else
|
||||
displaced_debug_printf ("found SVC call");
|
||||
|
||||
/* Preparation: If we detect sigreturn, set momentary breakpoint at resume
|
||||
location, else nothing.
|
||||
@ -1115,9 +1106,8 @@ arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
|
||||
stop at the return location. */
|
||||
if (from > 0xffff0000)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper "
|
||||
"at %.8lx\n", (unsigned long) from);
|
||||
displaced_debug_printf ("detected kernel helper at %.8lx",
|
||||
(unsigned long) from);
|
||||
|
||||
arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc.get ());
|
||||
}
|
||||
|
||||
339
gdb/arm-tdep.c
339
gdb/arm-tdep.c
@ -418,11 +418,9 @@ arm_pc_is_thumb (struct gdbarch *gdbarch, CORE_ADDR memaddr)
|
||||
should be determined by instruction on the original address. */
|
||||
if (dsc)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: check mode of %.8lx instead of %.8lx\n",
|
||||
(unsigned long) dsc->insn_addr,
|
||||
(unsigned long) memaddr);
|
||||
displaced_debug_printf ("check mode of %.8lx instead of %.8lx",
|
||||
(unsigned long) dsc->insn_addr,
|
||||
(unsigned long) memaddr);
|
||||
memaddr = dsc->insn_addr;
|
||||
}
|
||||
|
||||
@ -4457,17 +4455,17 @@ displaced_read_reg (struct regcache *regs, arm_displaced_step_closure *dsc,
|
||||
else
|
||||
from += 4;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: read pc value %.8lx\n",
|
||||
(unsigned long) from);
|
||||
displaced_debug_printf ("read pc value %.8lx",
|
||||
(unsigned long) from);
|
||||
return (ULONGEST) from;
|
||||
}
|
||||
else
|
||||
{
|
||||
regcache_cooked_read_unsigned (regs, regno, &ret);
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: read r%d value %.8lx\n",
|
||||
regno, (unsigned long) ret);
|
||||
|
||||
displaced_debug_printf ("read r%d value %.8lx",
|
||||
regno, (unsigned long) ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
@ -4563,9 +4561,8 @@ displaced_write_reg (struct regcache *regs, arm_displaced_step_closure *dsc,
|
||||
{
|
||||
if (regno == ARM_PC_REGNUM)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: writing pc %.8lx\n",
|
||||
(unsigned long) val);
|
||||
displaced_debug_printf ("writing pc %.8lx", (unsigned long) val);
|
||||
|
||||
switch (write_pc)
|
||||
{
|
||||
case BRANCH_WRITE_PC:
|
||||
@ -4598,9 +4595,8 @@ displaced_write_reg (struct regcache *regs, arm_displaced_step_closure *dsc,
|
||||
}
|
||||
else
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: writing r%d value %.8lx\n",
|
||||
regno, (unsigned long) val);
|
||||
displaced_debug_printf ("writing r%d value %.8lx",
|
||||
regno, (unsigned long) val);
|
||||
regcache_cooked_write_unsigned (regs, regno, val);
|
||||
}
|
||||
}
|
||||
@ -4644,10 +4640,8 @@ static int
|
||||
arm_copy_unmodified (struct gdbarch *gdbarch, uint32_t insn,
|
||||
const char *iname, arm_displaced_step_closure *dsc)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying insn %.8lx, "
|
||||
"opcode/class '%s' unmodified\n", (unsigned long) insn,
|
||||
iname);
|
||||
displaced_debug_printf ("copying insn %.8lx, opcode/class '%s' unmodified",
|
||||
(unsigned long) insn, iname);
|
||||
|
||||
dsc->modinsn[0] = insn;
|
||||
|
||||
@ -4659,10 +4653,8 @@ thumb_copy_unmodified_32bit (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
uint16_t insn2, const char *iname,
|
||||
arm_displaced_step_closure *dsc)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying insn %.4x %.4x, "
|
||||
"opcode/class '%s' unmodified\n", insn1, insn2,
|
||||
iname);
|
||||
displaced_debug_printf ("copying insn %.4x %.4x, opcode/class '%s' "
|
||||
"unmodified", insn1, insn2, iname);
|
||||
|
||||
dsc->modinsn[0] = insn1;
|
||||
dsc->modinsn[1] = insn2;
|
||||
@ -4678,10 +4670,8 @@ thumb_copy_unmodified_16bit (struct gdbarch *gdbarch, uint16_t insn,
|
||||
const char *iname,
|
||||
arm_displaced_step_closure *dsc)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying insn %.4x, "
|
||||
"opcode/class '%s' unmodified\n", insn,
|
||||
iname);
|
||||
displaced_debug_printf ("copying insn %.4x, opcode/class '%s' unmodified",
|
||||
insn, iname);
|
||||
|
||||
dsc->modinsn[0] = insn;
|
||||
|
||||
@ -4727,9 +4717,7 @@ arm_copy_preload (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
|
||||
if (!insn_references_pc (insn, 0x000f0000ul))
|
||||
return arm_copy_unmodified (gdbarch, insn, "preload", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying preload insn %.8lx\n",
|
||||
(unsigned long) insn);
|
||||
displaced_debug_printf ("copying preload insn %.8lx", (unsigned long) insn);
|
||||
|
||||
dsc->modinsn[0] = insn & 0xfff0ffff;
|
||||
|
||||
@ -4752,11 +4740,9 @@ thumb2_copy_preload (struct gdbarch *gdbarch, uint16_t insn1, uint16_t insn2,
|
||||
|
||||
/* PC is only allowed to use in PLI (immediate,literal) Encoding T3, and
|
||||
PLD (literal) Encoding T1. */
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: copying pld/pli pc (0x%x) %c imm12 %.4x\n",
|
||||
(unsigned int) dsc->insn_addr, u_bit ? '+' : '-',
|
||||
imm12);
|
||||
displaced_debug_printf ("copying pld/pli pc (0x%x) %c imm12 %.4x",
|
||||
(unsigned int) dsc->insn_addr, u_bit ? '+' : '-',
|
||||
imm12);
|
||||
|
||||
if (!u_bit)
|
||||
imm12 = -1 * imm12;
|
||||
@ -4824,9 +4810,8 @@ arm_copy_preload_reg (struct gdbarch *gdbarch, uint32_t insn,
|
||||
if (!insn_references_pc (insn, 0x000f000ful))
|
||||
return arm_copy_unmodified (gdbarch, insn, "preload reg", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying preload insn %.8lx\n",
|
||||
(unsigned long) insn);
|
||||
displaced_debug_printf ("copying preload insn %.8lx",
|
||||
(unsigned long) insn);
|
||||
|
||||
dsc->modinsn[0] = (insn & 0xfff0fff0) | 0x1;
|
||||
|
||||
@ -4886,9 +4871,8 @@ arm_copy_copro_load_store (struct gdbarch *gdbarch, uint32_t insn,
|
||||
if (!insn_references_pc (insn, 0x000f0000ul))
|
||||
return arm_copy_unmodified (gdbarch, insn, "copro load/store", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying coprocessor "
|
||||
"load/store insn %.8lx\n", (unsigned long) insn);
|
||||
displaced_debug_printf ("copying coprocessor load/store insn %.8lx",
|
||||
(unsigned long) insn);
|
||||
|
||||
dsc->modinsn[0] = insn & 0xfff0ffff;
|
||||
|
||||
@ -4908,9 +4892,8 @@ thumb2_copy_copro_load_store (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
|
||||
"copro load/store", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying coprocessor "
|
||||
"load/store insn %.4x%.4x\n", insn1, insn2);
|
||||
displaced_debug_printf ("copying coprocessor load/store insn %.4x%.4x",
|
||||
insn1, insn2);
|
||||
|
||||
dsc->modinsn[0] = insn1 & 0xfff0;
|
||||
dsc->modinsn[1] = insn2;
|
||||
@ -4995,10 +4978,9 @@ arm_copy_b_bl_blx (struct gdbarch *gdbarch, uint32_t insn,
|
||||
int link = exchange || bit (insn, 24);
|
||||
long offset;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying %s immediate insn "
|
||||
"%.8lx\n", (exchange) ? "blx" : (link) ? "bl" : "b",
|
||||
(unsigned long) insn);
|
||||
displaced_debug_printf ("copying %s immediate insn %.8lx",
|
||||
(exchange) ? "blx" : (link) ? "bl" : "b",
|
||||
(unsigned long) insn);
|
||||
if (exchange)
|
||||
/* For BLX, set bit 0 of the destination. The cleanup_branch function will
|
||||
then arrange the switch into Thumb mode. */
|
||||
@ -5058,11 +5040,9 @@ thumb2_copy_b_bl_blx (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
(bits (insn2, 1, 10) << 2) : (bits (insn2, 0, 10) << 1);
|
||||
}
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying %s insn "
|
||||
"%.4x %.4x with offset %.8lx\n",
|
||||
link ? (exchange) ? "blx" : "bl" : "b",
|
||||
insn1, insn2, offset);
|
||||
displaced_debug_printf ("copying %s insn %.4x %.4x with offset %.8lx",
|
||||
link ? (exchange) ? "blx" : "bl" : "b",
|
||||
insn1, insn2, offset);
|
||||
|
||||
dsc->modinsn[0] = THUMB_NOP;
|
||||
|
||||
@ -5092,10 +5072,8 @@ thumb_copy_b (struct gdbarch *gdbarch, uint16_t insn,
|
||||
cond = INST_AL;
|
||||
}
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: copying b immediate insn %.4x "
|
||||
"with offset %d\n", insn, offset);
|
||||
displaced_debug_printf ("copying b immediate insn %.4x with offset %d",
|
||||
insn, offset);
|
||||
|
||||
dsc->u.branch.cond = cond;
|
||||
dsc->u.branch.link = 0;
|
||||
@ -5144,9 +5122,7 @@ arm_copy_bx_blx_reg (struct gdbarch *gdbarch, uint32_t insn,
|
||||
int link = bit (insn, 5);
|
||||
unsigned int rm = bits (insn, 0, 3);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying insn %.8lx",
|
||||
(unsigned long) insn);
|
||||
displaced_debug_printf ("copying insn %.8lx", (unsigned long) insn);
|
||||
|
||||
dsc->modinsn[0] = ARM_NOP;
|
||||
|
||||
@ -5162,9 +5138,7 @@ thumb_copy_bx_blx_reg (struct gdbarch *gdbarch, uint16_t insn,
|
||||
int link = bit (insn, 7);
|
||||
unsigned int rm = bits (insn, 3, 6);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying insn %.4x",
|
||||
(unsigned short) insn);
|
||||
displaced_debug_printf ("copying insn %.4x", (unsigned short) insn);
|
||||
|
||||
dsc->modinsn[0] = THUMB_NOP;
|
||||
|
||||
@ -5199,10 +5173,9 @@ arm_copy_alu_imm (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
|
||||
if (!insn_references_pc (insn, 0x000ff000ul))
|
||||
return arm_copy_unmodified (gdbarch, insn, "ALU immediate", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying immediate %s insn "
|
||||
"%.8lx\n", is_mov ? "move" : "ALU",
|
||||
(unsigned long) insn);
|
||||
displaced_debug_printf ("copying immediate %s insn %.8lx",
|
||||
is_mov ? "move" : "ALU",
|
||||
(unsigned long) insn);
|
||||
|
||||
/* Instruction is of form:
|
||||
|
||||
@ -5253,9 +5226,7 @@ thumb2_copy_alu_imm (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
if (rm != ARM_PC_REGNUM && rd != ARM_PC_REGNUM)
|
||||
return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2, "ALU imm", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying reg %s insn %.4x%.4x\n",
|
||||
"ALU", insn1, insn2);
|
||||
displaced_debug_printf ("copying reg %s insn %.4x%.4x", "ALU", insn1, insn2);
|
||||
|
||||
/* Instruction is of form:
|
||||
|
||||
@ -5346,9 +5317,8 @@ arm_copy_alu_reg (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
|
||||
if (!insn_references_pc (insn, 0x000ff00ful))
|
||||
return arm_copy_unmodified (gdbarch, insn, "ALU reg", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying reg %s insn %.8lx\n",
|
||||
is_mov ? "move" : "ALU", (unsigned long) insn);
|
||||
displaced_debug_printf ("copying reg %s insn %.8lx",
|
||||
is_mov ? "move" : "ALU", (unsigned long) insn);
|
||||
|
||||
if (is_mov)
|
||||
dsc->modinsn[0] = (insn & 0xfff00ff0) | 0x2;
|
||||
@ -5373,9 +5343,7 @@ thumb_copy_alu_reg (struct gdbarch *gdbarch, uint16_t insn,
|
||||
if (rd != ARM_PC_REGNUM && rm != ARM_PC_REGNUM)
|
||||
return thumb_copy_unmodified_16bit (gdbarch, insn, "ALU reg", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying ALU reg insn %.4x\n",
|
||||
(unsigned short) insn);
|
||||
displaced_debug_printf ("copying ALU reg insn %.4x", (unsigned short) insn);
|
||||
|
||||
dsc->modinsn[0] = ((insn & 0xff00) | 0x10);
|
||||
|
||||
@ -5450,10 +5418,9 @@ arm_copy_alu_shifted_reg (struct gdbarch *gdbarch, uint32_t insn,
|
||||
if (!insn_references_pc (insn, 0x000fff0ful))
|
||||
return arm_copy_unmodified (gdbarch, insn, "ALU shifted reg", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying shifted reg %s insn "
|
||||
"%.8lx\n", is_mov ? "move" : "ALU",
|
||||
(unsigned long) insn);
|
||||
displaced_debug_printf ("copying shifted reg %s insn %.8lx",
|
||||
is_mov ? "move" : "ALU",
|
||||
(unsigned long) insn);
|
||||
|
||||
rn = bits (insn, 16, 19);
|
||||
rm = bits (insn, 0, 3);
|
||||
@ -5542,10 +5509,9 @@ arm_copy_extra_ld_st (struct gdbarch *gdbarch, uint32_t insn, int unprivileged,
|
||||
if (!insn_references_pc (insn, 0x000ff00ful))
|
||||
return arm_copy_unmodified (gdbarch, insn, "extra load/store", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying %sextra load/store "
|
||||
"insn %.8lx\n", unprivileged ? "unprivileged " : "",
|
||||
(unsigned long) insn);
|
||||
displaced_debug_printf ("copying %sextra load/store insn %.8lx",
|
||||
unprivileged ? "unprivileged " : "",
|
||||
(unsigned long) insn);
|
||||
|
||||
opcode = ((op2 << 2) | (op1 & 0x1) | ((op1 & 0x4) >> 1)) - 4;
|
||||
|
||||
@ -5663,11 +5629,9 @@ thumb2_copy_load_literal (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
int imm12 = bits (insn2, 0, 11);
|
||||
ULONGEST pc_val;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: copying ldr pc (0x%x) R%d %c imm12 %.4x\n",
|
||||
(unsigned int) dsc->insn_addr, rt, u_bit ? '+' : '-',
|
||||
imm12);
|
||||
displaced_debug_printf ("copying ldr pc (0x%x) R%d %c imm12 %.4x",
|
||||
(unsigned int) dsc->insn_addr, rt, u_bit ? '+' : '-',
|
||||
imm12);
|
||||
|
||||
if (!u_bit)
|
||||
imm12 = -1 * imm12;
|
||||
@ -5725,10 +5689,8 @@ thumb2_copy_load_reg_imm (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2, "load",
|
||||
dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: copying ldr r%d [r%d] insn %.4x%.4x\n",
|
||||
rt, rn, insn1, insn2);
|
||||
displaced_debug_printf ("copying ldr r%d [r%d] insn %.4x%.4x",
|
||||
rt, rn, insn1, insn2);
|
||||
|
||||
install_load_store (gdbarch, regs, dsc, 1, immed, writeback, 4,
|
||||
0, rt, rm, rn);
|
||||
@ -5773,13 +5735,12 @@ arm_copy_ldr_str_ldrb_strb (struct gdbarch *gdbarch, uint32_t insn,
|
||||
if (!insn_references_pc (insn, 0x000ff00ful))
|
||||
return arm_copy_unmodified (gdbarch, insn, "load/store", dsc);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: copying %s%s r%d [r%d] insn %.8lx\n",
|
||||
load ? (size == 1 ? "ldrb" : "ldr")
|
||||
: (size == 1 ? "strb" : "str"), usermode ? "t" : "",
|
||||
rt, rn,
|
||||
(unsigned long) insn);
|
||||
displaced_debug_printf ("copying %s%s r%d [r%d] insn %.8lx",
|
||||
load ? (size == 1 ? "ldrb" : "ldr")
|
||||
: (size == 1 ? "strb" : "str"),
|
||||
usermode ? "t" : "",
|
||||
rt, rn,
|
||||
(unsigned long) insn);
|
||||
|
||||
install_load_store (gdbarch, regs, dsc, load, immed, writeback, size,
|
||||
usermode, rt, rm, rn);
|
||||
@ -5870,11 +5831,10 @@ cleanup_block_load_all (struct gdbarch *gdbarch, struct regcache *regs,
|
||||
/* We don't handle any stores here for now. */
|
||||
gdb_assert (dsc->u.block.load != 0);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: emulating block transfer: "
|
||||
"%s %s %s\n", dsc->u.block.load ? "ldm" : "stm",
|
||||
dsc->u.block.increment ? "inc" : "dec",
|
||||
dsc->u.block.before ? "before" : "after");
|
||||
displaced_debug_printf ("emulating block transfer: %s %s %s",
|
||||
dsc->u.block.load ? "ldm" : "stm",
|
||||
dsc->u.block.increment ? "inc" : "dec",
|
||||
dsc->u.block.before ? "before" : "after");
|
||||
|
||||
while (regmask)
|
||||
{
|
||||
@ -5940,9 +5900,8 @@ cleanup_block_store_pc (struct gdbarch *gdbarch, struct regcache *regs,
|
||||
stm_insn_addr = dsc->scratch_base;
|
||||
offset = pc_val - stm_insn_addr;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: detected PC offset %.8lx for "
|
||||
"STM instruction\n", offset);
|
||||
displaced_debug_printf ("detected PC offset %.8lx for STM instruction",
|
||||
offset);
|
||||
|
||||
/* Rewrite the stored PC to the proper value for the non-displaced original
|
||||
instruction. */
|
||||
@ -5985,15 +5944,12 @@ cleanup_block_load_pc (struct gdbarch *gdbarch,
|
||||
{
|
||||
ULONGEST rval = displaced_read_reg (regs, dsc, read_reg);
|
||||
displaced_write_reg (regs, dsc, write_reg, rval, LOAD_WRITE_PC);
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, _("displaced: LDM: move "
|
||||
"loaded register r%d to r%d\n"), read_reg,
|
||||
write_reg);
|
||||
displaced_debug_printf ("LDM: move loaded register r%d to r%d",
|
||||
read_reg, write_reg);
|
||||
}
|
||||
else if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, _("displaced: LDM: register "
|
||||
"r%d already in the right place\n"),
|
||||
write_reg);
|
||||
else
|
||||
displaced_debug_printf ("LDM: register r%d already in the right "
|
||||
"place", write_reg);
|
||||
|
||||
clobbered &= ~(1 << write_reg);
|
||||
|
||||
@ -6010,9 +5966,8 @@ cleanup_block_load_pc (struct gdbarch *gdbarch,
|
||||
{
|
||||
displaced_write_reg (regs, dsc, write_reg, dsc->tmp[write_reg],
|
||||
CANNOT_WRITE_PC);
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, _("displaced: LDM: restored "
|
||||
"clobbered register r%d\n"), write_reg);
|
||||
displaced_debug_printf ("LDM: restored clobbered register r%d",
|
||||
write_reg);
|
||||
clobbered &= ~(1 << write_reg);
|
||||
}
|
||||
}
|
||||
@ -6059,9 +6014,8 @@ arm_copy_block_xfer (struct gdbarch *gdbarch, uint32_t insn,
|
||||
return arm_copy_unmodified (gdbarch, insn, "unpredictable ldm/stm", dsc);
|
||||
}
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying block transfer insn "
|
||||
"%.8lx\n", (unsigned long) insn);
|
||||
displaced_debug_printf ("copying block transfer insn %.8lx",
|
||||
(unsigned long) insn);
|
||||
|
||||
dsc->u.block.xfer_addr = displaced_read_reg (regs, dsc, rn);
|
||||
dsc->u.block.rn = rn;
|
||||
@ -6122,11 +6076,10 @@ arm_copy_block_xfer (struct gdbarch *gdbarch, uint32_t insn,
|
||||
|
||||
new_regmask = (1 << num_in_list) - 1;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, _("displaced: LDM r%d%s, "
|
||||
"{..., pc}: original reg list %.4x, modified "
|
||||
"list %.4x\n"), rn, writeback ? "!" : "",
|
||||
(int) insn & 0xffff, new_regmask);
|
||||
displaced_debug_printf ("LDM r%d%s, {..., pc}: original reg list "
|
||||
"%.4x, modified list %.4x",
|
||||
rn, writeback ? "!" : "",
|
||||
(int) insn & 0xffff, new_regmask);
|
||||
|
||||
dsc->modinsn[0] = (insn & ~0xffff) | (new_regmask & 0xffff);
|
||||
|
||||
@ -6171,9 +6124,8 @@ thumb2_copy_block_xfer (struct gdbarch *gdbarch, uint16_t insn1, uint16_t insn2,
|
||||
"unpredictable ldm/stm", dsc);
|
||||
}
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying block transfer insn "
|
||||
"%.4x%.4x\n", insn1, insn2);
|
||||
displaced_debug_printf ("copying block transfer insn %.4x%.4x",
|
||||
insn1, insn2);
|
||||
|
||||
/* Clear bit 13, since it should be always zero. */
|
||||
dsc->u.block.regmask = (insn2 & 0xdfff);
|
||||
@ -6208,11 +6160,10 @@ thumb2_copy_block_xfer (struct gdbarch *gdbarch, uint16_t insn1, uint16_t insn2,
|
||||
|
||||
new_regmask = (1 << num_in_list) - 1;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, _("displaced: LDM r%d%s, "
|
||||
"{..., pc}: original reg list %.4x, modified "
|
||||
"list %.4x\n"), rn, writeback ? "!" : "",
|
||||
(int) dsc->u.block.regmask, new_regmask);
|
||||
displaced_debug_printf ("LDM r%d%s, {..., pc}: original reg list "
|
||||
"%.4x, modified list %.4x",
|
||||
rn, writeback ? "!" : "",
|
||||
(int) dsc->u.block.regmask, new_regmask);
|
||||
|
||||
dsc->modinsn[0] = insn1;
|
||||
dsc->modinsn[1] = (new_regmask & 0xffff);
|
||||
@ -6302,9 +6253,8 @@ cleanup_svc (struct gdbarch *gdbarch, struct regcache *regs,
|
||||
{
|
||||
CORE_ADDR resume_addr = dsc->insn_addr + dsc->insn_size;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: cleanup for svc, resume at "
|
||||
"%.8lx\n", (unsigned long) resume_addr);
|
||||
displaced_debug_printf ("cleanup for svc, resume at %.8lx",
|
||||
(unsigned long) resume_addr);
|
||||
|
||||
displaced_write_reg (regs, dsc, ARM_PC_REGNUM, resume_addr, BRANCH_WRITE_PC);
|
||||
}
|
||||
@ -6339,9 +6289,8 @@ arm_copy_svc (struct gdbarch *gdbarch, uint32_t insn,
|
||||
struct regcache *regs, arm_displaced_step_closure *dsc)
|
||||
{
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying svc insn %.8lx\n",
|
||||
(unsigned long) insn);
|
||||
displaced_debug_printf ("copying svc insn %.8lx",
|
||||
(unsigned long) insn);
|
||||
|
||||
dsc->modinsn[0] = insn;
|
||||
|
||||
@ -6353,9 +6302,7 @@ thumb_copy_svc (struct gdbarch *gdbarch, uint16_t insn,
|
||||
struct regcache *regs, arm_displaced_step_closure *dsc)
|
||||
{
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying svc insn %.4x\n",
|
||||
insn);
|
||||
displaced_debug_printf ("copying svc insn %.4x", insn);
|
||||
|
||||
dsc->modinsn[0] = insn;
|
||||
|
||||
@ -6368,10 +6315,8 @@ static int
|
||||
arm_copy_undef (struct gdbarch *gdbarch, uint32_t insn,
|
||||
arm_displaced_step_closure *dsc)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: copying undefined insn %.8lx\n",
|
||||
(unsigned long) insn);
|
||||
displaced_debug_printf ("copying undefined insn %.8lx",
|
||||
(unsigned long) insn);
|
||||
|
||||
dsc->modinsn[0] = insn;
|
||||
|
||||
@ -6383,10 +6328,8 @@ thumb_32bit_copy_undef (struct gdbarch *gdbarch, uint16_t insn1, uint16_t insn2,
|
||||
arm_displaced_step_closure *dsc)
|
||||
{
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying undefined insn "
|
||||
"%.4x %.4x\n", (unsigned short) insn1,
|
||||
(unsigned short) insn2);
|
||||
displaced_debug_printf ("copying undefined insn %.4x %.4x",
|
||||
(unsigned short) insn1, (unsigned short) insn2);
|
||||
|
||||
dsc->modinsn[0] = insn1;
|
||||
dsc->modinsn[1] = insn2;
|
||||
@ -6401,9 +6344,8 @@ static int
|
||||
arm_copy_unpred (struct gdbarch *gdbarch, uint32_t insn,
|
||||
arm_displaced_step_closure *dsc)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying unpredictable insn "
|
||||
"%.8lx\n", (unsigned long) insn);
|
||||
displaced_debug_printf ("copying unpredictable insn %.8lx",
|
||||
(unsigned long) insn);
|
||||
|
||||
dsc->modinsn[0] = insn;
|
||||
|
||||
@ -6975,10 +6917,8 @@ thumb_decode_pc_relative_16bit (struct gdbarch *gdbarch, uint16_t insn,
|
||||
unsigned int rd = bits (insn, 8, 10);
|
||||
unsigned int imm8 = bits (insn, 0, 7);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: copying thumb adr r%d, #%d insn %.4x\n",
|
||||
rd, imm8, insn);
|
||||
displaced_debug_printf ("copying thumb adr r%d, #%d insn %.4x",
|
||||
rd, imm8, insn);
|
||||
|
||||
return thumb_copy_pc_relative_16bit (gdbarch, regs, dsc, rd, imm8);
|
||||
}
|
||||
@ -6996,10 +6936,8 @@ thumb_copy_pc_relative_32bit (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
unsigned int imm_3_8 = insn2 & 0x70ff;
|
||||
unsigned int imm_i = insn1 & 0x0400; /* Clear all bits except bit 10. */
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: copying thumb adr r%d, #%d:%d insn %.4x%.4x\n",
|
||||
rd, imm_i, imm_3_8, insn1, insn2);
|
||||
displaced_debug_printf ("copying thumb adr r%d, #%d:%d insn %.4x%.4x",
|
||||
rd, imm_i, imm_3_8, insn1, insn2);
|
||||
|
||||
if (bit (insn1, 7)) /* Encoding T2 */
|
||||
{
|
||||
@ -7038,10 +6976,7 @@ thumb_copy_16bit_ldr_literal (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
Insn: LDR R0, [R2, R3];
|
||||
Cleanup: R2 <- tmp2, R3 <- tmp3, Rd <- R0, R0 <- tmp0 */
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: copying thumb ldr r%d [pc #%d]\n"
|
||||
, rt, imm8);
|
||||
displaced_debug_printf ("copying thumb ldr r%d [pc #%d]", rt, imm8);
|
||||
|
||||
dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
|
||||
dsc->tmp[2] = displaced_read_reg (regs, dsc, 2);
|
||||
@ -7096,10 +7031,9 @@ thumb_copy_cbnz_cbz (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
dsc->u.branch.link = 0;
|
||||
dsc->u.branch.exchange = 0;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copying %s [r%d = 0x%x]"
|
||||
" insn %.4x to %.8lx\n", non_zero ? "cbnz" : "cbz",
|
||||
rn, rn_val, insn1, dsc->u.branch.dest);
|
||||
displaced_debug_printf ("copying %s [r%d = 0x%x] insn %.4x to %.8lx",
|
||||
non_zero ? "cbnz" : "cbz",
|
||||
rn, rn_val, insn1, dsc->u.branch.dest);
|
||||
|
||||
dsc->modinsn[0] = THUMB_NOP;
|
||||
|
||||
@ -7136,11 +7070,10 @@ thumb2_copy_table_branch (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
halfwords = extract_unsigned_integer (buf, 1, byte_order);
|
||||
}
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: %s base 0x%x offset 0x%x"
|
||||
" offset 0x%x\n", is_tbh ? "tbh" : "tbb",
|
||||
(unsigned int) rn_val, (unsigned int) rm_val,
|
||||
(unsigned int) halfwords);
|
||||
displaced_debug_printf ("%s base 0x%x offset 0x%x offset 0x%x",
|
||||
is_tbh ? "tbh" : "tbb",
|
||||
(unsigned int) rn_val, (unsigned int) rm_val,
|
||||
(unsigned int) halfwords);
|
||||
|
||||
dsc->u.branch.cond = INST_AL;
|
||||
dsc->u.branch.link = 0;
|
||||
@ -7197,10 +7130,8 @@ thumb_copy_pop_pc_16bit (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
Cleanup: Set registers in original reglist from r0 - rN. Restore r0 - rN
|
||||
from tmp[] properly.
|
||||
*/
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: copying thumb pop {%.8x, pc} insn %.4x\n",
|
||||
dsc->u.block.regmask, insn1);
|
||||
displaced_debug_printf ("copying thumb pop {%.8x, pc} insn %.4x",
|
||||
dsc->u.block.regmask, insn1);
|
||||
|
||||
if (dsc->u.block.regmask == 0xff)
|
||||
{
|
||||
@ -7224,11 +7155,9 @@ thumb_copy_pop_pc_16bit (struct gdbarch *gdbarch, uint16_t insn1,
|
||||
|
||||
new_regmask = (1 << (num_in_list + 1)) - 1;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, _("displaced: POP "
|
||||
"{..., pc}: original reg list %.4x,"
|
||||
" modified list %.4x\n"),
|
||||
(int) dsc->u.block.regmask, new_regmask);
|
||||
displaced_debug_printf ("POP {..., pc}: original reg list %.4x, "
|
||||
"modified list %.4x",
|
||||
(int) dsc->u.block.regmask, new_regmask);
|
||||
|
||||
dsc->u.block.regmask |= 0x8000;
|
||||
dsc->u.block.writeback = 0;
|
||||
@ -7562,9 +7491,8 @@ thumb_process_displaced_insn (struct gdbarch *gdbarch, CORE_ADDR from,
|
||||
uint16_t insn1
|
||||
= read_memory_unsigned_integer (from, 2, byte_order_for_code);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: process thumb insn %.4x "
|
||||
"at %.8lx\n", insn1, (unsigned long) from);
|
||||
displaced_debug_printf ("process thumb insn %.4x at %.8lx",
|
||||
insn1, (unsigned long) from);
|
||||
|
||||
dsc->is_thumb = 1;
|
||||
dsc->insn_size = thumb_insn_size (insn1);
|
||||
@ -7601,10 +7529,8 @@ arm_process_displaced_insn (struct gdbarch *gdbarch, CORE_ADDR from,
|
||||
dsc->is_thumb = 0;
|
||||
dsc->insn_size = 4;
|
||||
insn = read_memory_unsigned_integer (from, 4, byte_order_for_code);
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: stepping insn %.8lx "
|
||||
"at %.8lx\n", (unsigned long) insn,
|
||||
(unsigned long) from);
|
||||
displaced_debug_printf ("stepping insn %.8lx at %.8lx",
|
||||
(unsigned long) insn, (unsigned long) from);
|
||||
|
||||
if ((insn & 0xf0000000) == 0xf0000000)
|
||||
err = arm_decode_unconditional (gdbarch, insn, regs, dsc);
|
||||
@ -7652,20 +7578,14 @@ arm_displaced_init_closure (struct gdbarch *gdbarch, CORE_ADDR from,
|
||||
/* Poke modified instruction(s). */
|
||||
for (i = 0; i < dsc->numinsns; i++)
|
||||
{
|
||||
if (debug_displaced)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: writing insn ");
|
||||
if (size == 4)
|
||||
fprintf_unfiltered (gdb_stdlog, "%.8lx",
|
||||
dsc->modinsn[i]);
|
||||
else if (size == 2)
|
||||
fprintf_unfiltered (gdb_stdlog, "%.4x",
|
||||
(unsigned short)dsc->modinsn[i]);
|
||||
if (size == 4)
|
||||
displaced_debug_printf ("writing insn %.8lx at %.8lx",
|
||||
dsc->modinsn[i], (unsigned long) to + offset);
|
||||
else if (size == 2)
|
||||
displaced_debug_printf ("writing insn %.4x at %.8lx",
|
||||
(unsigned short) dsc->modinsn[i],
|
||||
(unsigned long) to + offset);
|
||||
|
||||
fprintf_unfiltered (gdb_stdlog, " at %.8lx\n",
|
||||
(unsigned long) to + offset);
|
||||
|
||||
}
|
||||
write_memory_unsigned_integer (to + offset, size,
|
||||
byte_order_for_code,
|
||||
dsc->modinsn[i]);
|
||||
@ -7687,9 +7607,8 @@ arm_displaced_init_closure (struct gdbarch *gdbarch, CORE_ADDR from,
|
||||
/* Put breakpoint afterwards. */
|
||||
write_memory (to + offset, bkp_insn, len);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to));
|
||||
displaced_debug_printf ("copy %s->%s", paddress (gdbarch, from),
|
||||
paddress (gdbarch, to));
|
||||
}
|
||||
|
||||
/* Entry point for cleaning things up after a displaced instruction has been
|
||||
|
||||
@ -825,12 +825,9 @@ i386_displaced_step_copy_insn (struct gdbarch *gdbarch,
|
||||
|
||||
write_memory (to, buf, len);
|
||||
|
||||
if (debug_displaced)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to));
|
||||
displaced_step_dump_bytes (gdb_stdlog, buf, len);
|
||||
}
|
||||
displaced_debug_printf ("%s->%s: %s",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to),
|
||||
displaced_step_dump_bytes (buf, len).c_str ());
|
||||
|
||||
/* This is a work around for a problem with g++ 4.8. */
|
||||
return displaced_step_closure_up (closure.release ());
|
||||
@ -859,12 +856,9 @@ i386_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
/* The start of the insn, needed in case we see some prefixes. */
|
||||
gdb_byte *insn_start = insn;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: fixup (%s, %s), "
|
||||
"insn = 0x%02x 0x%02x ...\n",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to),
|
||||
insn[0], insn[1]);
|
||||
displaced_debug_printf ("fixup (%s, %s), insn = 0x%02x 0x%02x ...",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to),
|
||||
insn[0], insn[1]);
|
||||
|
||||
/* The list of issues to contend with here is taken from
|
||||
resume_execution in arch/i386/kernel/kprobes.c, Linux 2.6.20.
|
||||
@ -918,13 +912,8 @@ i386_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
Presumably this is a kernel bug.
|
||||
i386_displaced_step_copy_insn ensures its a nop,
|
||||
we add one to the length for it. */
|
||||
&& orig_eip != to + (insn - insn_start) + insn_len + 1)
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: syscall changed %%eip; "
|
||||
"not relocating\n");
|
||||
}
|
||||
&& orig_eip != to + (insn - insn_start) + insn_len + 1)
|
||||
displaced_debug_printf ("syscall changed %%eip; not relocating");
|
||||
else
|
||||
{
|
||||
ULONGEST eip = (orig_eip - insn_offset) & 0xffffffffUL;
|
||||
@ -935,12 +924,9 @@ i386_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
|
||||
regcache_cooked_write_unsigned (regs, I386_EIP_REGNUM, eip);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: "
|
||||
"relocated %%eip from %s to %s\n",
|
||||
paddress (gdbarch, orig_eip),
|
||||
paddress (gdbarch, eip));
|
||||
displaced_debug_printf ("relocated %%eip from %s to %s",
|
||||
paddress (gdbarch, orig_eip),
|
||||
paddress (gdbarch, eip));
|
||||
}
|
||||
}
|
||||
|
||||
@ -963,11 +949,9 @@ i386_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
retaddr = (retaddr - insn_offset) & 0xffffffffUL;
|
||||
write_memory_unsigned_integer (esp, retaddr_len, byte_order, retaddr);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: relocated return addr at %s to %s\n",
|
||||
paddress (gdbarch, esp),
|
||||
paddress (gdbarch, retaddr));
|
||||
displaced_debug_printf ("relocated return addr at %s to %s",
|
||||
paddress (gdbarch, esp),
|
||||
paddress (gdbarch, retaddr));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1019,12 +1003,9 @@ i386_relocate_instruction (struct gdbarch *gdbarch,
|
||||
newrel = (oldloc - *to) + rel32;
|
||||
store_signed_integer (insn + 1, 4, byte_order, newrel);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"Adjusted insn rel32=%s at %s to"
|
||||
" rel32=%s at %s\n",
|
||||
hex_string (rel32), paddress (gdbarch, oldloc),
|
||||
hex_string (newrel), paddress (gdbarch, *to));
|
||||
displaced_debug_printf ("adjusted insn rel32=%s at %s to rel32=%s at %s",
|
||||
hex_string (rel32), paddress (gdbarch, oldloc),
|
||||
hex_string (newrel), paddress (gdbarch, *to));
|
||||
|
||||
/* Write the adjusted jump into its displaced location. */
|
||||
append_insns (to, 5, insn);
|
||||
@ -1044,12 +1025,9 @@ i386_relocate_instruction (struct gdbarch *gdbarch,
|
||||
rel32 = extract_signed_integer (insn + offset, 4, byte_order);
|
||||
newrel = (oldloc - *to) + rel32;
|
||||
store_signed_integer (insn + offset, 4, byte_order, newrel);
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"Adjusted insn rel32=%s at %s to"
|
||||
" rel32=%s at %s\n",
|
||||
hex_string (rel32), paddress (gdbarch, oldloc),
|
||||
hex_string (newrel), paddress (gdbarch, *to));
|
||||
displaced_debug_printf ("adjusted insn rel32=%s at %s to rel32=%s at %s",
|
||||
hex_string (rel32), paddress (gdbarch, oldloc),
|
||||
hex_string (newrel), paddress (gdbarch, *to));
|
||||
}
|
||||
|
||||
/* Write the adjusted instructions into their displaced
|
||||
|
||||
99
gdb/infrun.c
99
gdb/infrun.c
@ -179,6 +179,16 @@ show_debug_infrun (struct ui_file *file, int from_tty,
|
||||
fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
|
||||
}
|
||||
|
||||
/* See infrun.h. */
|
||||
|
||||
void
|
||||
displaced_debug_printf_1 (const char *func_name, const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start (ap, fmt);
|
||||
debug_prefixed_vprintf ("displaced", func_name, fmt, ap);
|
||||
va_end (ap);
|
||||
}
|
||||
|
||||
/* Support for disabling address space randomization. */
|
||||
|
||||
@ -1629,17 +1639,22 @@ displaced_step_reset (displaced_step_inferior_state *displaced)
|
||||
|
||||
using displaced_step_reset_cleanup = FORWARD_SCOPE_EXIT (displaced_step_reset);
|
||||
|
||||
/* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
|
||||
void
|
||||
displaced_step_dump_bytes (struct ui_file *file,
|
||||
const gdb_byte *buf,
|
||||
size_t len)
|
||||
{
|
||||
int i;
|
||||
/* See infrun.h. */
|
||||
|
||||
for (i = 0; i < len; i++)
|
||||
fprintf_unfiltered (file, "%02x ", buf[i]);
|
||||
fputs_unfiltered ("\n", file);
|
||||
std::string
|
||||
displaced_step_dump_bytes (const gdb_byte *buf, size_t len)
|
||||
{
|
||||
std::string ret;
|
||||
|
||||
for (size_t i = 0; i < len; i++)
|
||||
{
|
||||
if (i == 0)
|
||||
ret += string_printf ("%02x", buf[i]);
|
||||
else
|
||||
ret += string_printf (" %02x", buf[i]);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Prepare to single-step, using displaced stepping.
|
||||
@ -1692,21 +1707,15 @@ displaced_step_prepare_throw (thread_info *tp)
|
||||
/* Already waiting for a displaced step to finish. Defer this
|
||||
request and place in queue. */
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: deferring step of %s\n",
|
||||
target_pid_to_str (tp->ptid).c_str ());
|
||||
displaced_debug_printf ("deferring step of %s",
|
||||
target_pid_to_str (tp->ptid).c_str ());
|
||||
|
||||
thread_step_over_chain_enqueue (tp);
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: stepping %s now\n",
|
||||
displaced_debug_printf ("stepping %s now",
|
||||
target_pid_to_str (tp->ptid).c_str ());
|
||||
}
|
||||
|
||||
displaced_step_reset (displaced);
|
||||
|
||||
@ -1730,12 +1739,8 @@ displaced_step_prepare_throw (thread_info *tp)
|
||||
in the scratch pad range (after initial startup) anyway, but
|
||||
the former is unacceptable. Simply punt and fallback to
|
||||
stepping over this breakpoint in-line. */
|
||||
if (debug_displaced)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: breakpoint set in scratch pad. "
|
||||
"Stepping over breakpoint in-line instead.\n");
|
||||
}
|
||||
displaced_debug_printf ("breakpoint set in scratch pad. "
|
||||
"Stepping over breakpoint in-line instead.");
|
||||
|
||||
return -1;
|
||||
}
|
||||
@ -1748,14 +1753,11 @@ displaced_step_prepare_throw (thread_info *tp)
|
||||
_("Error accessing memory address %s (%s) for "
|
||||
"displaced-stepping scratch space."),
|
||||
paddress (gdbarch, copy), safe_strerror (status));
|
||||
if (debug_displaced)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
|
||||
paddress (gdbarch, copy));
|
||||
displaced_step_dump_bytes (gdb_stdlog,
|
||||
displaced->step_saved_copy.data (),
|
||||
len);
|
||||
};
|
||||
|
||||
displaced_debug_printf ("saved %s: %s",
|
||||
paddress (gdbarch, copy),
|
||||
displaced_step_dump_bytes
|
||||
(displaced->step_saved_copy.data (), len).c_str ());
|
||||
|
||||
displaced->step_closure
|
||||
= gdbarch_displaced_step_copy_insn (gdbarch, original, copy, regcache);
|
||||
@ -1783,9 +1785,7 @@ displaced_step_prepare_throw (thread_info *tp)
|
||||
cleanup.release ();
|
||||
}
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
|
||||
paddress (gdbarch, copy));
|
||||
displaced_debug_printf ("displaced pc to %s", paddress (gdbarch, copy));
|
||||
|
||||
return 1;
|
||||
}
|
||||
@ -1850,11 +1850,11 @@ displaced_step_restore (struct displaced_step_inferior_state *displaced,
|
||||
|
||||
write_memory_ptid (ptid, displaced->step_copy,
|
||||
displaced->step_saved_copy.data (), len);
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
|
||||
target_pid_to_str (ptid).c_str (),
|
||||
paddress (displaced->step_gdbarch,
|
||||
displaced->step_copy));
|
||||
|
||||
displaced_debug_printf ("restored %s %s",
|
||||
target_pid_to_str (ptid).c_str (),
|
||||
paddress (displaced->step_gdbarch,
|
||||
displaced->step_copy));
|
||||
}
|
||||
|
||||
/* If we displaced stepped an instruction successfully, adjust
|
||||
@ -2593,10 +2593,11 @@ resume_1 (enum gdb_signal sig)
|
||||
CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
|
||||
gdb_byte buf[4];
|
||||
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
|
||||
paddress (resume_gdbarch, actual_pc));
|
||||
read_memory (actual_pc, buf, sizeof (buf));
|
||||
displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
|
||||
displaced_debug_printf ("run %s: %s",
|
||||
paddress (resume_gdbarch, actual_pc),
|
||||
displaced_step_dump_bytes
|
||||
(buf, sizeof (buf)).c_str ());
|
||||
}
|
||||
|
||||
if (tp->control.may_range_step)
|
||||
@ -5354,12 +5355,10 @@ handle_inferior_event (struct execution_control_state *ecs)
|
||||
/* Read PC value of parent process. */
|
||||
parent_pc = regcache_read_pc (regcache);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: write child pc from %s to %s\n",
|
||||
paddress (gdbarch,
|
||||
regcache_read_pc (child_regcache)),
|
||||
paddress (gdbarch, parent_pc));
|
||||
displaced_debug_printf ("write child pc from %s to %s",
|
||||
paddress (gdbarch,
|
||||
regcache_read_pc (child_regcache)),
|
||||
paddress (gdbarch, parent_pc));
|
||||
|
||||
regcache_write_pc (child_regcache, parent_pc);
|
||||
}
|
||||
|
||||
18
gdb/infrun.h
18
gdb/infrun.h
@ -47,6 +47,19 @@ void ATTRIBUTE_PRINTF (2, 3) infrun_debug_printf_1
|
||||
/* True if we are debugging displaced stepping. */
|
||||
extern bool debug_displaced;
|
||||
|
||||
/* Print a "displaced" debug statement. Should be used through
|
||||
displaced_debug_printf. */
|
||||
void ATTRIBUTE_PRINTF (2, 3) displaced_debug_printf_1
|
||||
(const char *func_name, const char *fmt, ...);
|
||||
|
||||
#define displaced_debug_printf(fmt, ...) \
|
||||
do \
|
||||
{ \
|
||||
if (debug_displaced) \
|
||||
displaced_debug_printf_1 (__func__, fmt, ##__VA_ARGS__); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
/* Nonzero if we want to give control to the user when we're notified
|
||||
of shared library events by the dynamic linker. */
|
||||
extern int stop_on_solib_events;
|
||||
@ -229,9 +242,8 @@ extern void update_signals_program_target (void);
|
||||
$_exitsignal. */
|
||||
extern void clear_exit_convenience_vars (void);
|
||||
|
||||
/* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
|
||||
extern void displaced_step_dump_bytes (struct ui_file *file,
|
||||
const gdb_byte *buf, size_t len);
|
||||
/* Dump LEN bytes at BUF in hex to a string and return it. */
|
||||
extern std::string displaced_step_dump_bytes (const gdb_byte *buf, size_t len);
|
||||
|
||||
extern struct displaced_step_closure *get_displaced_step_closure_by_addr
|
||||
(CORE_ADDR addr);
|
||||
|
||||
@ -874,25 +874,17 @@ ppc_displaced_step_copy_insn (struct gdbarch *gdbarch,
|
||||
/* Assume all atomic sequences start with a Load and Reserve instruction. */
|
||||
if (IS_LOAD_AND_RESERVE_INSN (insn))
|
||||
{
|
||||
if (debug_displaced)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: can't displaced step "
|
||||
"atomic sequence at %s\n",
|
||||
displaced_debug_printf ("can't displaced step atomic sequence at %s",
|
||||
paddress (gdbarch, from));
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
write_memory (to, buf, len);
|
||||
|
||||
if (debug_displaced)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to));
|
||||
displaced_step_dump_bytes (gdb_stdlog, buf, len);
|
||||
}
|
||||
displaced_debug_printf ("copy %s->%s: %s",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to),
|
||||
displaced_step_dump_bytes (buf, len).c_str ());;
|
||||
|
||||
/* This is a work around for a problem with g++ 4.8. */
|
||||
return displaced_step_closure_up (closure.release ());
|
||||
@ -917,11 +909,8 @@ ppc_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
|
||||
opcode = insn & BRANCH_MASK;
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: (ppc) fixup (%s, %s)\n",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to));
|
||||
|
||||
displaced_debug_printf ("(ppc) fixup (%s, %s)",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to));
|
||||
|
||||
/* Handle PC-relative branch instructions. */
|
||||
if (opcode == B_INSN || opcode == BC_INSN || opcode == BXL_INSN)
|
||||
@ -942,13 +931,11 @@ ppc_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
if (!(insn & 0x2))
|
||||
{
|
||||
/* PC-relative addressing is being used in the branch. */
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered
|
||||
(gdb_stdlog,
|
||||
"displaced: (ppc) branch instruction: %s\n"
|
||||
"displaced: (ppc) adjusted PC from %s to %s\n",
|
||||
paddress (gdbarch, insn), paddress (gdbarch, current_pc),
|
||||
paddress (gdbarch, from + offset));
|
||||
displaced_debug_printf ("(ppc) branch instruction: %s",
|
||||
paddress (gdbarch, insn));
|
||||
displaced_debug_printf ("(ppc) adjusted PC from %s to %s",
|
||||
paddress (gdbarch, current_pc),
|
||||
paddress (gdbarch, from + offset));
|
||||
|
||||
regcache_cooked_write_unsigned (regs,
|
||||
gdbarch_pc_regnum (gdbarch),
|
||||
@ -975,10 +962,8 @@ ppc_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
regcache_cooked_write_unsigned (regs,
|
||||
gdbarch_tdep (gdbarch)->ppc_lr_regnum,
|
||||
from + PPC_INSN_SIZE);
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: (ppc) adjusted LR to %s\n",
|
||||
paddress (gdbarch, from + PPC_INSN_SIZE));
|
||||
displaced_debug_printf ("(ppc) adjusted LR to %s",
|
||||
paddress (gdbarch, from + PPC_INSN_SIZE));
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -454,13 +454,8 @@ s390_displaced_step_copy_insn (struct gdbarch *gdbarch,
|
||||
{
|
||||
/* Let the core fall back to stepping over the breakpoint
|
||||
in-line. */
|
||||
if (debug_displaced)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: can't displaced step "
|
||||
"RIL instruction: offset %s out of range\n",
|
||||
plongest (offset));
|
||||
}
|
||||
displaced_debug_printf ("can't displaced step RIL instruction: offset "
|
||||
"%s out of range", plongest (offset));
|
||||
|
||||
return NULL;
|
||||
}
|
||||
@ -470,12 +465,9 @@ s390_displaced_step_copy_insn (struct gdbarch *gdbarch,
|
||||
|
||||
write_memory (to, buf, len);
|
||||
|
||||
if (debug_displaced)
|
||||
{
|
||||
fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to));
|
||||
displaced_step_dump_bytes (gdb_stdlog, buf, len);
|
||||
}
|
||||
displaced_debug_printf ("copy %s->%s: %s",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to),
|
||||
displaced_step_dump_bytes (buf, len).c_str ());
|
||||
|
||||
/* This is a work around for a problem with g++ 4.8. */
|
||||
return displaced_step_closure_up (closure.release ());
|
||||
@ -511,11 +503,9 @@ s390_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
amode &= 0x80000000;
|
||||
}
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to),
|
||||
paddress (gdbarch, pc), insnlen, (int) amode);
|
||||
displaced_debug_printf ("(s390) fixup (%s, %s) pc %s len %d amode 0x%x",
|
||||
paddress (gdbarch, from), paddress (gdbarch, to),
|
||||
paddress (gdbarch, pc), insnlen, (int) amode);
|
||||
|
||||
/* Handle absolute branch and save instructions. */
|
||||
int op_basr_p = is_rr (insn, op_basr, &r1, &r2);
|
||||
@ -578,10 +568,8 @@ s390_displaced_step_fixup (struct gdbarch *gdbarch,
|
||||
else
|
||||
regcache_write_pc (regs, pc - to + from);
|
||||
|
||||
if (debug_displaced)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"displaced: (s390) pc is now %s\n",
|
||||
paddress (gdbarch, regcache_read_pc (regs)));
|
||||
displaced_debug_printf ("(s390) pc is now %s",
|
||||
paddress (gdbarch, regcache_read_pc (regs)));
|
||||
}
|
||||
|
||||
/* Implement displaced_step_hw_singlestep gdbarch method. */
|
||||
|
||||
@ -1,3 +1,8 @@
|
||||
2020-10-30 Simon Marchi <simon.marchi@efficios.com>
|
||||
|
||||
* gdb.arch/amd64-disp-step-avx.exp: Update displaced step debug
|
||||
expected output.
|
||||
|
||||
2020-10-30 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
|
||||
|
||||
* gdb.base/paginate-after-ctrl-c-running.exp: Update with no pagination
|
||||
|
||||
@ -97,7 +97,7 @@ proc disp_step_func { func } {
|
||||
gdb_test_no_output "set debug displaced on"
|
||||
|
||||
gdb_test "continue" \
|
||||
"Continuing.*displaced: displaced pc to.*Breakpoint.*, ${test_end_label} ().*" \
|
||||
"Continuing.*displaced pc to.*Breakpoint.*, ${test_end_label} ().*" \
|
||||
"continue to ${test_end_label}"
|
||||
|
||||
gdb_test_no_output "set debug displaced off"
|
||||
|
||||
Loading…
Reference in New Issue
Block a user