arm software watchpoint: return to epilogue
authorYao Qi <yao@codesourcery.com>
Fri, 1 Aug 2014 03:26:16 +0000 (11:26 +0800)
committerYao Qi <yao@codesourcery.com>
Thu, 28 Aug 2014 07:21:21 +0000 (15:21 +0800)
Hi,
This patch is to handle a software watchpoint case that program returns
to caller's epilogue, and it causes the fail in thumb mode,

finish^M
Run till exit from #0  func () at gdb/testsuite/gdb.base/watchpoint-cond-gone.c:26^M
0x000001f6 in jumper ()^M
(gdb) FAIL: gdb.base/watchpoint-cond-gone.exp: Catch the no longer valid watchpoint

In the test, jumper calls func, and programs returns from func to
jumper's epilogue, IOW, the branch instruction is the last instruction
of jumper's function body.

    jumper:
    .....
    0x000001f2 <+10>:    bl      0x200   [1] <---- indirect call to func
    0x000001f6 <+14>:    mov     sp, r7  [2] <---- start of the epilogue
    0x000001f8 <+16>:    add     sp, #8
    0x000001fa <+18>:    pop     {r7}
    0x000001fc <+20>:    pop     {r0}
    0x000001fe <+22>:    bx      r0

When the inferior returns from func back to jumper, it is expected
that an expression of a software watchpoint becomes out-of-scope.
GDB validates the expression by checking the corresponding frame,
but this check is guarded by gdbarch_in_function_epilogue_p.  See
breakpoint.c:watchpoint_check.

It doesn't work in this case, because program returns from func's
epilogue back to jumper's epilogue [2], GDB thinks the program is
still within the epilogue, but in fact it goes to a different one.
When PC points at [2], the sp-restore instruction is to be
executed, so the stack frame isn't destroyed yet and we can still
use the frame mechanism reliably.

Note that when PC points to the first instruction of restoring SP,
it is part of epilogue, but we still return zero.  When goes to
the next instruction, the backward scan will still match the
epilogue sequence correctly.  The reason for doing this is to
handle the "return-to-epilogue" case.

What this patch does is to restrict the epilogue matching that let
GDB think the first SP restore instruction isn't part of the epilogue,
and fall back to use frame mechanism.  We set 'found_stack_adjust'
zero before backward scan, and we've done this for arm mode
counterpart (arm_in_function_epilogue_p) too.

The patch is tested in arm-none-eabi and arm-none-linux-gnueabi with
various multilibs.  OK to apply?

gdb:

2014-08-28  Yao Qi  <yao@codesourcery.com>

* arm-tdep.c (thumb_in_function_epilogue_p): Don't set
found_stack_adjust in forward scan.  Remove condition check
on found_stack_adjust which is always true.  Indent the code.

gdb/ChangeLog
gdb/arm-tdep.c

index c7ccb41fc39a2bd8642cccabd81e73b755a72b03..b6d846965ad7e438a7cdd9ca71f9b07dcddd2394 100644 (file)
@@ -1,3 +1,9 @@
+2014-08-28  Yao Qi  <yao@codesourcery.com>
+
+       * arm-tdep.c (thumb_in_function_epilogue_p): Don't set
+       found_stack_adjust in forward scan.  Remove condition check
+       on found_stack_adjust which is always true.  Indent the code.
+
 2014-08-28  Yao Qi  <yao@codesourcery.com>
 
        * dwarf2read.c (dwarf_decode_lines): Update declaration.
index 9bc65079c5794f0ba1e732e30be920a824f378b0..f9feb523721c2449cdfb39af49d11b66e7327d96 100644 (file)
@@ -3273,7 +3273,6 @@ thumb_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
        found_return = 1;
       else if (thumb_instruction_restores_sp (insn))
        {
-         found_stack_adjust = 1;
          if ((insn & 0xfe00) == 0xbd00)  /* pop <registers, PC> */
            found_return = 1;
        }
@@ -3287,20 +3286,18 @@ thumb_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 
          if (insn == 0xe8bd)  /* ldm.w sp!, <registers> */
            {
-             found_stack_adjust = 1;
              if (insn2 & 0x8000)  /* <registers> include PC.  */
                found_return = 1;
            }
          else if (insn == 0xf85d  /* ldr.w <Rt>, [sp], #4 */
                   && (insn2 & 0x0fff) == 0x0b04)
            {
-             found_stack_adjust = 1;
              if ((insn2 & 0xf000) == 0xf000) /* <Rt> is PC.  */
                found_return = 1;
            }
          else if ((insn & 0xffbf) == 0xecbd  /* vldm sp!, <list> */
                   && (insn2 & 0x0e00) == 0x0a00)
-           found_stack_adjust = 1;
+           ;
          else
            break;
        }
@@ -3317,27 +3314,24 @@ thumb_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
      a 32-bit instruction.  This is just a heuristic, so we do not worry
      too much about false positives.  */
 
-  if (!found_stack_adjust)
-    {
-      if (pc - 4 < func_start)
-       return 0;
-      if (target_read_memory (pc - 4, buf, 4))
-       return 0;
-
-      insn = extract_unsigned_integer (buf, 2, byte_order_for_code);
-      insn2 = extract_unsigned_integer (buf + 2, 2, byte_order_for_code);
+  if (pc - 4 < func_start)
+    return 0;
+  if (target_read_memory (pc - 4, buf, 4))
+    return 0;
 
-      if (thumb_instruction_restores_sp (insn2))
-       found_stack_adjust = 1;
-      else if (insn == 0xe8bd)  /* ldm.w sp!, <registers> */
-       found_stack_adjust = 1;
-      else if (insn == 0xf85d  /* ldr.w <Rt>, [sp], #4 */
-              && (insn2 & 0x0fff) == 0x0b04)
-       found_stack_adjust = 1;
-      else if ((insn & 0xffbf) == 0xecbd  /* vldm sp!, <list> */
-              && (insn2 & 0x0e00) == 0x0a00)
-       found_stack_adjust = 1;
-    }
+  insn = extract_unsigned_integer (buf, 2, byte_order_for_code);
+  insn2 = extract_unsigned_integer (buf + 2, 2, byte_order_for_code);
+
+  if (thumb_instruction_restores_sp (insn2))
+    found_stack_adjust = 1;
+  else if (insn == 0xe8bd)  /* ldm.w sp!, <registers> */
+    found_stack_adjust = 1;
+  else if (insn == 0xf85d  /* ldr.w <Rt>, [sp], #4 */
+          && (insn2 & 0x0fff) == 0x0b04)
+    found_stack_adjust = 1;
+  else if ((insn & 0xffbf) == 0xecbd  /* vldm sp!, <list> */
+          && (insn2 & 0x0e00) == 0x0a00)
+    found_stack_adjust = 1;
 
   return found_stack_adjust;
 }