gdb: add target_ops::supports_displaced_step

[deliverable/binutils-gdb.git] / gdb / inf-loop.c

diff --git a/gdb/inf-loop.c b/gdb/inf-loop.c
index 244520926c97312bb1f87fe2fb9531bcd69c09eb..c40ae2394269ee64e4b5474bbef7ffcfa19b133c 100644 (file)
--- a/gdb/inf-loop.c
+++ b/gdb/inf-loop.c
@@ -1,5 +1,5 @@
 /* Handling of inferior events for the event loop for GDB, the GNU debugger.
-   Copyright (C) 1999-2014 Free Software Foundation, Inc.
+   Copyright (C) 1999-2020 Free Software Foundation, Inc.
    Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
 
    This file is part of GDB.
@@ -20,8 +20,7 @@
 #include "defs.h"
 #include "inferior.h"
 #include "infrun.h"
-#include "target.h"             /* For enum inferior_event_type.  */
-#include "event-loop.h"
+#include "gdbsupport/event-loop.h"
 #include "event-top.h"
 #include "inf-loop.h"
 #include "remote.h"
@@ -30,41 +29,18 @@
 #include "continuations.h"
 #include "interps.h"
 #include "top.h"
-#include "observer.h"
+#include "observable.h"
+
+/* General function to handle events in the inferior.  */
 
-/* General function to handle events in the inferior.  So far it just
-   takes care of detecting errors reported by select() or poll(),
-   otherwise it assumes that all is OK, and goes on reading data from
-   the fd.  This however may not always be what we want to do.  */
 void
 inferior_event_handler (enum inferior_event_type event_type, 
                        gdb_client_data client_data)
 {
-  struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
-
   switch (event_type)
     {
     case INF_REG_EVENT:
-      /* Catch errors for now, until the inner layers of
-        fetch_inferior_event (i.e. readchar) can return meaningful
-        error status.  If an error occurs while getting an event from
-        the target, just cancel the current command.  */
-      {
-       volatile struct gdb_exception ex;
-
-       TRY_CATCH (ex, RETURN_MASK_ALL)
-         {
-           fetch_inferior_event (client_data);
-         }
-       if (ex.reason < 0)
-         {
-           bpstat_clear_actions ();
-           do_all_intermediate_continuations (1);
-           do_all_continuations (1);
-
-           throw_exception (ex);
-         }
-      }
+      fetch_inferior_event (client_data);
       break;
 
     case INF_EXEC_COMPLETE:
@@ -73,74 +49,45 @@ inferior_event_handler (enum inferior_event_type event_type,
          /* Unregister the inferior from the event loop.  This is done
             so that when the inferior is not running we don't get
             distracted by spurious inferior output.  */
-         if (target_has_execution)
-           target_async (NULL, 0);
+         if (target_has_execution && target_can_async_p ())
+           target_async (0);
        }
 
       /* Do all continuations associated with the whole inferior (not
         a particular thread).  */
-      if (!ptid_equal (inferior_ptid, null_ptid))
+      if (inferior_ptid != null_ptid)
        do_all_inferior_continuations (0);
 
-      /* If we were doing a multi-step (eg: step n, next n), but it
-        got interrupted by a breakpoint, still do the pending
-        continuations.  The continuation itself is responsible for
-        distinguishing the cases.  The continuations are allowed to
-        touch the inferior memory, e.g. to remove breakpoints, so run
-        them before running breakpoint commands, which may resume the
-        target.  */
-      if (non_stop
-         && target_has_execution
-         && !ptid_equal (inferior_ptid, null_ptid))
-       do_all_intermediate_continuations_thread (inferior_thread (), 0);
-      else
-       do_all_intermediate_continuations (0);
-
-      /* Always finish the previous command before running any
-        breakpoint commands.  Any stop cancels the previous command.
-        E.g. a "finish" or "step-n" command interrupted by an
-        unrelated breakpoint is canceled.  */
-      if (non_stop
-         && target_has_execution
-         && !ptid_equal (inferior_ptid, null_ptid))
-       do_all_continuations_thread (inferior_thread (), 0);
-      else
-       do_all_continuations (0);
-
       /* When running a command list (from a user command, say), these
         are only run when the command list is all done.  */
-      if (interpreter_async)
+      if (current_ui->async)
        {
-         volatile struct gdb_exception e;
-
          check_frame_language_change ();
 
          /* Don't propagate breakpoint commands errors.  Either we're
             stopping or some command resumes the inferior.  The user will
             be informed.  */
-         TRY_CATCH (e, RETURN_MASK_ALL)
+         try
            {
              bpstat_do_actions ();
            }
-         exception_print (gdb_stderr, e);
+         catch (const gdb_exception &e)
+           {
+             /* If the user was running a foreground execution
+                command, then propagate the error so that the prompt
+                can be reenabled.  Otherwise, the user already has
+                the prompt and is typing some unrelated command, so
+                just inform the user and swallow the exception.  */
+             if (current_ui->prompt_state == PROMPT_BLOCKED)
+               throw;
+             else
+               exception_print (gdb_stderr, e);
+           }
        }
       break;
 
-    case INF_EXEC_CONTINUE:
-      /* Is there anything left to do for the command issued to
-         complete?  */
-
-      if (non_stop)
-       do_all_intermediate_continuations_thread (inferior_thread (), 0);
-      else
-       do_all_intermediate_continuations (0);
-      break;
-
-    case INF_TIMER:
     default:
       printf_unfiltered (_("Event type not recognized.\n"));
       break;
     }
-
-  discard_cleanups (cleanup_if_error);
 }