gdb/

	Fix regression for gdb.cp/gdb2495.exp with gcc-4.7.
	* arch-utils.c (displaced_step_at_entry_point): Incrase BP_LEN skip to
	3 times.
	* infcall.c (call_function_by_hand) <AT_SYMBOL>: Move it upwards and
	fall through into AT_ENTRY_POINT.
	(call_function_by_hand) <AT_ENTRY_POINT>: New variable bp_len.  Adjust
	DUMMY_ADDR with it.
	* ppc-linux-tdep.c (ppc_linux_displaced_step_location): Increase
	PPC_INSN_SIZE skip to 3 times.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 3a5f1875eeb4098aed3db0423cb816e3be077a13..db26777db319e5e2ef4ffb1c0176e72be7d18ceb 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,16 @@
+2012-01-02  Jan Kratochvil  <jan.kratochvil@redhat.com>
+           Joel Brobecker  <brobecker@adacore.com>
+
+       Fix regression for gdb.cp/gdb2495.exp with gcc-4.7.
+       * arch-utils.c (displaced_step_at_entry_point): Incrase BP_LEN skip to
+       3 times.
+       * infcall.c (call_function_by_hand) <AT_SYMBOL>: Move it upwards and
+       fall through into AT_ENTRY_POINT.
+       (call_function_by_hand) <AT_ENTRY_POINT>: New variable bp_len.  Adjust
+       DUMMY_ADDR with it.
+       * ppc-linux-tdep.c (ppc_linux_displaced_step_location): Increase
+       PPC_INSN_SIZE skip to 3 times.
+
 2012-01-02  Jan Kratochvil  <jan.kratochvil@redhat.com>
 
        * amd64-linux-nat.c (update_debug_registers_callback): New comment on

diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
index 2cedb38f92cfd5ad901f42cd918a9510b4ece3ff..92e310172b960282a19645974013b7605f8dcdc0 100644 (file)
--- a/gdb/arch-utils.c
+++ b/gdb/arch-utils.c
@@ -86,7 +86,7 @@ displaced_step_at_entry_point (struct gdbarch *gdbarch)
      We don't want displaced stepping to interfere with those
      breakpoints, so leave space.  */
   gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
-  addr += bp_len * 2;
+  addr += bp_len * 3;
 
   return addr;
 }

diff --git a/gdb/infcall.c b/gdb/infcall.c
index b8b7ff5d328f2a44a9199c12753a49b27e832a99..e3171d7051f3329bf70d06b63ae592f7263abce3 100644 (file)
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -631,17 +631,6 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
                                args, nargs, target_values_type,
                                &real_pc, &bp_addr, get_current_regcache ());
       break;
-    case AT_ENTRY_POINT:
-      {
-       CORE_ADDR dummy_addr;
-
-       real_pc = funaddr;
-       dummy_addr = entry_point_address ();
-       /* A call dummy always consists of just a single breakpoint, so
-          its address is the same as the address of the dummy.  */
-       bp_addr = dummy_addr;
-       break;
-      }
     case AT_SYMBOL:
       /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose
         address is the location where the breakpoint should be
@@ -661,11 +650,39 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
            dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
                                                             dummy_addr,
                                                             &current_target);
+           /* A call dummy always consists of just a single breakpoint,
+              so its address is the same as the address of the dummy.  */
+           bp_addr = dummy_addr;
+           break;
          }
-       else
-         dummy_addr = entry_point_address ();
-       /* A call dummy always consists of just a single breakpoint,
-          so it's address is the same as the address of the dummy.  */
+      }
+      /* FALLTHROUGH */
+    case AT_ENTRY_POINT:
+      {
+       CORE_ADDR dummy_addr;
+       int bp_len;
+
+       real_pc = funaddr;
+       dummy_addr = entry_point_address ();
+
+       /* If the inferior call throws an uncaught C++ exception,
+          the inferior unwinder tries to unwind all frames, including
+          our dummy frame.  The unwinder determines the address of
+          the calling instruction by subtracting 1 to the return
+          address.  So, using the entry point's address as the return
+          address would lead the unwinder to use the unwinding
+          information of the code immediately preceding the entry
+          point.  This information, if found, is invalid for the dummy
+          frame, and can potentially crash the inferior's unwinder.
+          Therefore, we adjust the return address by the length of
+          a breakpoint, guaranteeing that the unwinder finds the
+          correct function as the caller.  */
+
+       gdbarch_breakpoint_from_pc (gdbarch, &dummy_addr, &bp_len);
+       dummy_addr += bp_len;
+
+       /* A call dummy always consists of just a single breakpoint, so
+          its address is the same as the address of the dummy.  */
        bp_addr = dummy_addr;
        break;
       }

diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c
index 9968621e0dce2abd7e6fcbdd3e0a2cbcd72de6af..07dd990a9820a6bfb8f24eca0c6d37fcb4ce0e85 100644 (file)
--- a/gdb/ppc-linux-tdep.c
+++ b/gdb/ppc-linux-tdep.c
@@ -1075,7 +1075,7 @@ ppc_linux_displaced_step_location (struct gdbarch *gdbarch)
       /* Inferior calls also use the entry point as a breakpoint location.
         We don't want displaced stepping to interfere with those
         breakpoints, so leave space.  */
-      ppc_linux_entry_point_addr = addr + 2 * PPC_INSN_SIZE;
+      ppc_linux_entry_point_addr = addr + 3 * PPC_INSN_SIZE;
     }
 
   return ppc_linux_entry_point_addr;