* inferior.h (read_sp): Remove prototype.

[deliverable/binutils-gdb.git] / gdb / infrun.c

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 91198b7dff6bde712b7c671953836eae392d8bf3..dccd9ec07315c23839a85ac7cd76811179c3b777 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -176,23 +176,6 @@ show_debug_infrun (struct ui_file *file, int from_tty,
 #define SOLIB_IN_DYNAMIC_LINKER(pid,pc) 0
 #endif
 
-/* We can't step off a permanent breakpoint in the ordinary way, because we
-   can't remove it.  Instead, we have to advance the PC to the next
-   instruction.  This macro should expand to a pointer to a function that
-   does that, or zero if we have no such function.  If we don't have a
-   definition for it, we have to report an error.  */
-#ifndef SKIP_PERMANENT_BREAKPOINT
-#define SKIP_PERMANENT_BREAKPOINT (default_skip_permanent_breakpoint)
-static void
-default_skip_permanent_breakpoint (void)
-{
-  error (_("\
-The program is stopped at a permanent breakpoint, but GDB does not know\n\
-how to step past a permanent breakpoint on this architecture.  Try using\n\
-a command like `return' or `jump' to continue execution."));
-}
-#endif
-
 
 /* Convert the #defines into values.  This is temporary until wfi control
    flow is completely sorted out.  */
@@ -543,12 +526,20 @@ resume (int step, enum target_signal sig)
      at a permanent breakpoint; we need to step over it, but permanent
      breakpoints can't be removed.  So we have to test for it here.  */
   if (breakpoint_here_p (read_pc ()) == permanent_breakpoint_here)
-    SKIP_PERMANENT_BREAKPOINT ();
+    {
+      if (gdbarch_skip_permanent_breakpoint_p (current_gdbarch))
+       gdbarch_skip_permanent_breakpoint (current_gdbarch, current_regcache);
+      else
+       error (_("\
+The program is stopped at a permanent breakpoint, but GDB does not know\n\
+how to step past a permanent breakpoint on this architecture.  Try using\n\
+a command like `return' or `jump' to continue execution."));
+    }
 
   if (SOFTWARE_SINGLE_STEP_P () && step)
     {
       /* Do it the hard way, w/temp breakpoints */
-      if (SOFTWARE_SINGLE_STEP (sig, 1 /*insert-breakpoints */ ))
+      if (SOFTWARE_SINGLE_STEP (current_regcache))
         {
           /* ...and don't ask hardware to do it.  */
           step = 0;
@@ -1571,7 +1562,7 @@ handle_inferior_event (struct execution_control_state *ecs)
          if (debug_infrun)
            fprintf_unfiltered (gdb_stdlog, "infrun: stepping_past_singlestep_breakpoint\n");
          /* Pull the single step breakpoints out of the target.  */
-         (void) SOFTWARE_SINGLE_STEP (0, 0);
+         remove_single_step_breakpoints ();
          singlestep_breakpoints_inserted_p = 0;
 
          ecs->random_signal = 0;
@@ -1680,7 +1671,7 @@ handle_inferior_event (struct execution_control_state *ecs)
          if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p)
            {
              /* Pull the single step breakpoints out of the target. */
-             (void) SOFTWARE_SINGLE_STEP (0, 0);
+             remove_single_step_breakpoints ();
              singlestep_breakpoints_inserted_p = 0;
            }
 
@@ -1751,7 +1742,7 @@ handle_inferior_event (struct execution_control_state *ecs)
   if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p)
     {
       /* Pull the single step breakpoints out of the target. */
-      (void) SOFTWARE_SINGLE_STEP (0, 0);
+      remove_single_step_breakpoints ();
       singlestep_breakpoints_inserted_p = 0;
     }
 
@@ -2022,6 +2013,7 @@ process_event_stop_test:
             code paths as single-step - set a breakpoint at the
             signal return address and then, once hit, step off that
             breakpoint.  */
+
          insert_step_resume_breakpoint_at_frame (get_current_frame ());
          ecs->step_after_step_resume_breakpoint = 1;
          keep_going (ecs);
@@ -2338,7 +2330,8 @@ process_event_stop_test:
   if (step_resume_breakpoint)
     {
       if (debug_infrun)
-        fprintf_unfiltered (gdb_stdlog, "infrun: step-resume breakpoint\n");
+        fprintf_unfiltered (gdb_stdlog,
+                            "infrun: step-resume breakpoint is inserted\n");
 
       /* Having a step-resume breakpoint overrides anything
          else having to do with stepping commands until
@@ -2785,7 +2778,7 @@ step_into_function (struct execution_control_state *ecs)
   keep_going (ecs);
 }
 
-/* Insert a "step resume breakpoint" at SR_SAL with frame ID SR_ID.
+/* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
    This is used to both functions and to skip over code.  */
 
 static void
@@ -2796,13 +2789,19 @@ insert_step_resume_breakpoint_at_sal (struct symtab_and_line sr_sal,
      thread, so we should never be setting a new
      step_resume_breakpoint when one is already active.  */
   gdb_assert (step_resume_breakpoint == NULL);
+
+  if (debug_infrun)
+    fprintf_unfiltered (gdb_stdlog,
+                       "infrun: inserting step-resume breakpoint at 0x%s\n",
+                       paddr_nz (sr_sal.pc));
+
   step_resume_breakpoint = set_momentary_breakpoint (sr_sal, sr_id,
                                                     bp_step_resume);
   if (breakpoints_inserted)
     insert_breakpoints ();
 }
 
-/* Insert a "step resume breakpoint" at RETURN_FRAME.pc.  This is used
+/* Insert a "step-resume breakpoint" at RETURN_FRAME.pc.  This is used
    to skip a potential signal handler.
 
    This is called with the interrupted function's frame.  The signal