Remove support for catch load and catch unload commands.

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

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 552c91f2c061abb8602a3895a4c11b10f732c6a1..292200f237f25a83f5c126074fde920c58aed5c7 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -2834,10 +2834,19 @@ targets should add new threads to the thread list themselves in non-stop mode.")
         SIGTRAP.  Some systems (e.g. Windows), and stubs supporting
         target extended-remote report it instead of a SIGSTOP
         (e.g. gdbserver).  We already rely on SIGTRAP being our
-        signal, so this is no exception.  */
+        signal, so this is no exception.
+
+        Also consider that the attach is complete when we see a
+        TARGET_SIGNAL_0.  In non-stop mode, GDB will explicitly tell
+        the target to stop all threads of the inferior, in case the
+        low level attach operation doesn't stop them implicitly.  If
+        they weren't stopped implicitly, then the stub will report a
+        TARGET_SIGNAL_0, meaning: stopped for no particular reason
+        other than GDB's request.  */
       if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
          && (ecs->event_thread->stop_signal == TARGET_SIGNAL_STOP
-             || ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP))
+             || ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP
+             || ecs->event_thread->stop_signal == TARGET_SIGNAL_0))
        {
          stop_stepping (ecs);
          ecs->event_thread->stop_signal = TARGET_SIGNAL_0;
@@ -3153,43 +3162,6 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
              stop_stepping (ecs);
              return;
            }
-
-         /* If we stopped due to an explicit catchpoint, then the
-            (see above) call to SOLIB_ADD pulled in any symbols
-            from a newly-loaded library, if appropriate.
-
-            We do want the inferior to stop, but not where it is
-            now, which is in the dynamic linker callback.  Rather,
-            we would like it stop in the user's program, just after
-            the call that caused this catchpoint to trigger.  That
-            gives the user a more useful vantage from which to
-            examine their program's state. */
-         else if (what.main_action
-                  == BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK)
-           {
-             /* ??rehrauer: If I could figure out how to get the
-                right return PC from here, we could just set a temp
-                breakpoint and resume.  I'm not sure we can without
-                cracking open the dld's shared libraries and sniffing
-                their unwind tables and text/data ranges, and that's
-                not a terribly portable notion.
-
-                Until that time, we must step the inferior out of the
-                dld callback, and also out of the dld itself (and any
-                code or stubs in libdld.sl, such as "shl_load" and
-                friends) until we reach non-dld code.  At that point,
-                we can stop stepping. */
-             bpstat_get_triggered_catchpoints (ecs->event_thread->stop_bpstat,
-                                               &ecs->
-                                               event_thread->
-                                               stepping_through_solib_catchpoints);
-             ecs->event_thread->stepping_through_solib_after_catch = 1;
-
-             /* Be sure to lift all breakpoints, so the inferior does
-                actually step past this point... */
-             ecs->event_thread->stepping_over_breakpoint = 1;
-             break;
-           }
          else
            {
              /* We want to step over this breakpoint, then keep going.  */
@@ -3388,12 +3360,27 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
             Reverse (backward) execution.  set the step-resume
             breakpoint at the start of the function that we just
             stepped into (backwards), and continue to there.  When we
-            get there, we'll need to single-step back to the
-            caller.  */
+            get there, we'll need to single-step back to the caller.  */
 
          if (execution_direction == EXEC_REVERSE)
            {
              struct symtab_and_line sr_sal;
+
+             if (ecs->stop_func_start == 0 
+                 && in_solib_dynsym_resolve_code (stop_pc))
+               {
+                 /* Stepped into runtime loader dynamic symbol
+                    resolution code.  Since we're in reverse, 
+                    we have already backed up through the runtime
+                    loader and the dynamic function.  This is just
+                    the trampoline (jump table).
+
+                    Just keep stepping, we'll soon be home.
+                 */
+                 keep_going (ecs);
+                 return;
+               }
+             /* Normal (staticly linked) function call return.  */
              init_sal (&sr_sal);
              sr_sal.pc = ecs->stop_func_start;
              insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id);
@@ -4709,16 +4696,6 @@ struct inferior_status
   int proceed_to_finish;
 };
 
-void
-write_inferior_status_register (struct inferior_status *inf_status, int regno,
-                               LONGEST val)
-{
-  int size = register_size (current_gdbarch, regno);
-  void *buf = alloca (size);
-  store_signed_integer (buf, size, val);
-  regcache_raw_write (inf_status->registers, regno, buf);
-}
-
 /* Save all of the information associated with the inferior<==>gdb
    connection.  INF_STATUS is a pointer to a "struct inferior_status"
    (defined in inferior.h).  */