commit 7f03bd92e389a32da490bb55037881cf374d0f69
Author: Pedro Alves <palves@redhat.com>
Date: Thu Aug 6 18:23:00 2015 +0100
PPC64: Fix gdb.arch/ppc64-atomic-inst.exp with displaced stepping
The ppc64 displaced step code can't handle atomic sequences. Fallback
to stepping over the breakpoint in-line if we detect one.
gdb/ChangeLog:
2015-08-07 Pedro Alves <palves@redhat.com>
* infrun.c (displaced_step_prepare_throw): Return -1 if
gdbarch_displaced_step_copy_insn returns NULL. Update intro
comment.
* rs6000-tdep.c (LWARX_MASK, LWARX_INSTRUCTION, LDARX_INSTRUCTION)
(STWCX_MASK, STWCX_INSTRUCTION, STDCX_INSTRUCTION): Move higher up
in file.
(ppc_displaced_step_copy_insn): New function.
(ppc_displaced_step_fixup): Update comment.
(rs6000_gdbarch_init): Install ppc_displaced_step_copy_insn as
gdbarch_displaced_step_copy_insn hook.
* gdbarch.sh (displaced_step_copy_insn): Document what happens on
NULL return.
* gdbarch.h: Regenerate.
gdb/testsuite/ChangeLog:
2015-08-07 Pedro Alves <palves@redhat.com>
* gdb.arch/ppc64-atomic-inst.exp (do_test): New procedure, move
tests here.
(top level): Run do_test with and without displaced stepping.
### a/gdb/ChangeLog
### b/gdb/ChangeLog
## -1,5 +1,21 @@
2015-08-07 Pedro Alves <palves@redhat.com>
+ * infrun.c (displaced_step_prepare_throw): Return -1 if
+ gdbarch_displaced_step_copy_insn returns NULL. Update intro
+ comment.
+ * rs6000-tdep.c (LWARX_MASK, LWARX_INSTRUCTION, LDARX_INSTRUCTION)
+ (STWCX_MASK, STWCX_INSTRUCTION, STDCX_INSTRUCTION): Move higher up
+ in file.
+ (ppc_displaced_step_copy_insn): New function.
+ (ppc_displaced_step_fixup): Update comment.
+ (rs6000_gdbarch_init): Install ppc_displaced_step_copy_insn as
+ gdbarch_displaced_step_copy_insn hook.
+ * gdbarch.sh (displaced_step_copy_insn): Document what happens on
+ NULL return.
+ * gdbarch.h: Regenerate.
+
+2015-08-07 Pedro Alves <palves@redhat.com>
+
* inferior.h (struct inferior) <displaced_stepping_failed>: New
field.
* infrun.c (use_displaced_stepping_now_p): New parameter 'inf'.
Index: gdb-7.6.1/gdb/gdbarch.h
===================================================================
--- gdb-7.6.1.orig/gdb/gdbarch.h 2017-08-29 21:41:21.400218851 +0200
+++ gdb-7.6.1/gdb/gdbarch.h 2017-08-29 21:41:29.832299833 +0200
@@ -870,7 +870,11 @@
If your architecture doesn't need to adjust instructions before
single-stepping them, consider using simple_displaced_step_copy_insn
- here. */
+ here.
+
+ If the instruction cannot execute out of line, return NULL. The
+ core falls back to stepping past the instruction in-line instead in
+ that case. */
extern int gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch);
Index: gdb-7.6.1/gdb/gdbarch.sh
===================================================================
--- gdb-7.6.1.orig/gdb/gdbarch.sh 2017-08-29 21:41:21.401218861 +0200
+++ gdb-7.6.1/gdb/gdbarch.sh 2017-08-29 21:41:29.833299843 +0200
@@ -724,6 +724,10 @@
# If your architecture doesn't need to adjust instructions before
# single-stepping them, consider using simple_displaced_step_copy_insn
# here.
+#
+# If the instruction cannot execute out of line, return NULL. The
+# core falls back to stepping past the instruction in-line instead in
+# that case.
M:struct displaced_step_closure *:displaced_step_copy_insn:CORE_ADDR from, CORE_ADDR to, struct regcache *regs:from, to, regs
# Return true if GDB should use hardware single-stepping to execute
Index: gdb-7.6.1/gdb/infrun.c
===================================================================
--- gdb-7.6.1.orig/gdb/infrun.c 2017-08-29 21:41:21.404218890 +0200
+++ gdb-7.6.1/gdb/infrun.c 2017-08-29 21:41:29.835299862 +0200
@@ -1323,7 +1323,9 @@
explain how we handle this case instead.
Returns 1 if preparing was successful -- this thread is going to be
- stepped now; or 0 if displaced stepping this thread got queued. */
+ stepped now; 0 if displaced stepping this thread got queued; or -1
+ if this instruction can't be displaced stepped. */
+
static int
displaced_step_prepare (ptid_t ptid)
{
@@ -1412,9 +1414,14 @@
closure = gdbarch_displaced_step_copy_insn (gdbarch,
original, copy, regcache);
-
- /* We don't support the fully-simulated case at present. */
- gdb_assert (closure);
+ if (closure == NULL)
+ {
+ /* The architecture doesn't know how or want to displaced step
+ this instruction or instruction sequence. Fallback to
+ stepping over the breakpoint in-line. */
+ do_cleanups (old_cleanups);
+ return -1;
+ }
/* Save the information we need to fix things up if the step
succeeds. */
Index: gdb-7.6.1/gdb/rs6000-tdep.c
===================================================================
--- gdb-7.6.1.orig/gdb/rs6000-tdep.c 2017-08-29 21:41:21.407218918 +0200
+++ gdb-7.6.1/gdb/rs6000-tdep.c 2017-08-29 21:41:29.837299881 +0200
@@ -975,6 +975,61 @@
#define BXL_INSN 0x4c000000
#define BP_INSN 0x7C000008
+/* Instruction masks used during single-stepping of atomic
+ sequences. */
+#define LWARX_MASK 0xfc0007fe
+#define LWARX_INSTRUCTION 0x7c000028
+#define LDARX_INSTRUCTION 0x7c0000A8
+#define STWCX_MASK 0xfc0007ff
+#define STWCX_INSTRUCTION 0x7c00012d
+#define STDCX_INSTRUCTION 0x7c0001ad
+
+/* We can't displaced step atomic sequences. Otherwise this is just
+ like simple_displaced_step_copy_insn. */
+
+static struct displaced_step_closure *
+ppc_displaced_step_copy_insn (struct gdbarch *gdbarch,
+ CORE_ADDR from, CORE_ADDR to,
+ struct regcache *regs)
+{
+ size_t len = gdbarch_max_insn_length (gdbarch);
+ gdb_byte *buf = xmalloc (len);
+ struct cleanup *old_chain = make_cleanup (xfree, buf);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ int insn;
+
+ read_memory (from, buf, len);
+
+ insn = extract_signed_integer (buf, PPC_INSN_SIZE, byte_order);
+
+ /* Assume all atomic sequences start with a lwarx/ldarx instruction. */
+ if ((insn & LWARX_MASK) == LWARX_INSTRUCTION
+ || (insn & LWARX_MASK) == LDARX_INSTRUCTION)
+ {
+ if (debug_displaced)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "displaced: can't displaced step "
+ "atomic sequence at %s\n",
+ paddress (gdbarch, from));
+ }
+ do_cleanups (old_chain);
+ 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);
+ }
+
+ discard_cleanups (old_chain);
+ return (struct displaced_step_closure *) buf;
+}
+
/* Fix up the state of registers and memory after having single-stepped
a displaced instruction. */
static void
@@ -984,8 +1039,7 @@
struct regcache *regs)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- /* Since we use simple_displaced_step_copy_insn, our closure is a
- copy of the instruction. */
+ /* Our closure is a copy of the instruction. */
ULONGEST insn = extract_unsigned_integer ((gdb_byte *) closure,
PPC_INSN_SIZE, byte_order);
ULONGEST opcode = 0;
@@ -1078,14 +1132,6 @@
return 1;
}
-/* Instruction masks used during single-stepping of atomic sequences. */
-#define LWARX_MASK 0xfc0007fe
-#define LWARX_INSTRUCTION 0x7c000028
-#define LDARX_INSTRUCTION 0x7c0000A8
-#define STWCX_MASK 0xfc0007ff
-#define STWCX_INSTRUCTION 0x7c00012d
-#define STDCX_INSTRUCTION 0x7c0001ad
-
/* Checks for an atomic sequence of instructions beginning with a LWARX/LDARX
instruction and ending with a STWCX/STDCX instruction. If such a sequence
is found, attempt to step through it. A breakpoint is placed at the end of
@@ -6427,7 +6473,7 @@
/* Setup displaced stepping. */
set_gdbarch_displaced_step_copy_insn (gdbarch,
- simple_displaced_step_copy_insn);
+ ppc_displaced_step_copy_insn);
set_gdbarch_displaced_step_hw_singlestep (gdbarch,
ppc_displaced_step_hw_singlestep);
set_gdbarch_displaced_step_fixup (gdbarch, ppc_displaced_step_fixup);
Index: gdb-7.6.1/gdb/testsuite/gdb.arch/ppc64-atomic-inst.exp
===================================================================
--- gdb-7.6.1.orig/gdb/testsuite/gdb.arch/ppc64-atomic-inst.exp 2017-08-29 21:41:21.408218928 +0200
+++ gdb-7.6.1/gdb/testsuite/gdb.arch/ppc64-atomic-inst.exp 2017-08-29 21:41:29.837299881 +0200
@@ -32,27 +32,41 @@
return -1
}
-if ![runto_main] then {
- untested "could not run to main"
- return -1
-}
+# The test proper. DISPLACED is true if we should try with displaced
+# stepping.
+proc do_test { displaced } {
+ global decimal hex
+
+ if ![runto_main] then {
+ untested "could not run to main"
+ return -1
+ }
+
+ gdb_test_no_output "set displaced-stepping $displaced"
-set bp1 [gdb_get_line_number "lwarx"]
-gdb_breakpoint "$bp1" "Breakpoint $decimal at $hex" \
- "Set the breakpoint at the start of the lwarx/stwcx sequence"
+ set bp1 [gdb_get_line_number "lwarx"]
+ gdb_breakpoint "$bp1" "Breakpoint $decimal at $hex" \
+ "Set the breakpoint at the start of the lwarx/stwcx sequence"
-set bp2 [gdb_get_line_number "ldarx"]
-gdb_breakpoint "$bp2" "Breakpoint $decimal at $hex" \
- "Set the breakpoint at the start of the ldarx/stdcx sequence"
+ set bp2 [gdb_get_line_number "ldarx"]
+ gdb_breakpoint "$bp2" "Breakpoint $decimal at $hex" \
+ "Set the breakpoint at the start of the ldarx/stdcx sequence"
-gdb_test continue "Continuing.*Breakpoint $decimal.*" \
- "Continue until lwarx/stwcx start breakpoint"
+ gdb_test continue "Continuing.*Breakpoint $decimal.*" \
+ "Continue until lwarx/stwcx start breakpoint"
-gdb_test nexti "bne.*1b" \
- "Step through the lwarx/stwcx sequence"
+ gdb_test nexti "bne.*1b" \
+ "Step through the lwarx/stwcx sequence"
-gdb_test continue "Continuing.*Breakpoint $decimal.*" \
- "Continue until ldarx/stdcx start breakpoint"
+ gdb_test continue "Continuing.*Breakpoint $decimal.*" \
+ "Continue until ldarx/stdcx start breakpoint"
-gdb_test nexti "bne.*1b" \
- "Step through the ldarx/stdcx sequence"
+ gdb_test nexti "bne.*1b" \
+ "Step through the ldarx/stdcx sequence"
+}
+
+foreach displaced { "off" "on" } {
+ with_test_prefix "displaced=$displaced" {
+ do_test $displaced
+ }
+}