[PATCH v3 13/44] gdb, ze: add TARGET_WAITKIND_UNAVAILABLE

[Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>]

From: Markus Metzger <markus.t.metzger@intel.com>

This new WAITKIND means that we cannot interact with the thread at the
moment.  The thread may become available again at a later time.

This will be used to model idle threads on Intel GT devices.
---
 gdb/fork-child.c        | 10 +++++++---
 gdb/gdbthread.h         | 12 +++++++++---
 gdb/infrun.c            | 22 +++++++++++++++++++++-
 gdb/nat/fork-inferior.c | 10 ++++++++++
 gdb/remote.c            |  6 +++++-
 gdb/target/waitstatus.c |  1 +
 gdb/target/waitstatus.h | 22 ++++++++++++++++++++++
 gdb/thread.c            |  2 +-
 8 files changed, 76 insertions(+), 9 deletions(-)

diff --git a/gdb/fork-child.c b/gdb/fork-child.c
index fd7f1e0d16bb1b6e1e889b16d42bde84d150d86b..f5ac1c13ef61968bd182fbe6df650a6ff2c8d4a2 100644
--- a/gdb/fork-child.c
+++ b/gdb/fork-child.c
@@ -124,14 +124,18 @@ gdb_startup_inferior (pid_t pid, int num_traps)
 {
   inferior *inf = current_inferior ();
   process_stratum_target *proc_target = inf->process_target ();
+  struct target_waitstatus ws;
 
   scoped_restore save_starting_up
     = make_scoped_restore (&inf->starting_up, true);
 
-  ptid_t ptid = startup_inferior (proc_target, pid, num_traps, NULL, NULL);
+  ptid_t ptid = startup_inferior (proc_target, pid, num_traps, &ws, NULL);
 
-  /* Mark all threads non-executing.  */
-  set_executing (proc_target, ptid, false);
+  if (ws.kind () != TARGET_WAITKIND_UNAVAILABLE)
+    {
+      /* Mark all threads non-executing.  */
+      set_executing (proc_target, ptid, false);
+    }
 
   return ptid;
 }
diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h
index c561e9a7b64d9246a08ea00b209dfc936c517b59..52c5c3ac43d6ffcb126d80a2cf7c9bcf3af2abf9 100644
--- a/gdb/gdbthread.h
+++ b/gdb/gdbthread.h
@@ -847,9 +847,15 @@ extern bool threads_are_executing (process_stratum_target *targ);
 /* Merge the executing property of thread PTID of TARG over to its
    thread state property (frontend running/stopped view).
 
-   "not executing" -> "stopped"
-   "executing"     -> "running"
-   "exited"        -> "exited"
+   "not executing or not resumed"	-> "stopped"
+   "executing and resumed"		-> "running"
+   "exited"				-> "exited"
+
+   On GPUs, threads may exist but not currently be available, e.g. because
+   they are idle or are executing a dispatch of another process.  We call
+   them unavailable and we model them as executing but not resumed.  From
+   the front-end perspective, they are stopped.  From the target
+   perspective, they are running.
 
    If PTID is minus_one_ptid, go over all threads of TARG.
 
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 4483082c899c5648f8693636ebe2af0d47da238e..65392bc3b6f063fe65320d55b990b64a68a638a4 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -5448,7 +5448,19 @@ mark_non_executing_threads (process_stratum_target *target,
   else
     mark_ptid = event_ptid;
 
-  set_executing (target, mark_ptid, false);
+  /* Unavailable threads are still executing.
+
+     They were idle when we tried to stop them but they may start
+     executing work at any time.
+
+     In all-stop mode, because the target does not listen to debug
+     events, those threads are practically not executing.  But in
+     non-stop mode, the target can receive debug events from those
+     threads and the user can send interrupts to them.  So, we leave
+     them as executing.  */
+  if (!(target_is_non_stop_p ()
+	&& ws.kind () == TARGET_WAITKIND_UNAVAILABLE))
+    set_executing (target, mark_ptid, false);
 
   /* Likewise the resumed flag.  */
   set_resumed (target, mark_ptid, false);
@@ -6638,6 +6650,14 @@ handle_inferior_event (struct execution_control_state *ecs)
       interps_notify_no_history ();
       stop_waiting (ecs);
       return;
+
+    case TARGET_WAITKIND_UNAVAILABLE:
+      context_switch (ecs);
+      infrun_debug_printf ("unavailable");
+
+      stop_print_frame = false;
+      stop_waiting (ecs);
+      return;
     }
 }
 
diff --git a/gdb/nat/fork-inferior.c b/gdb/nat/fork-inferior.c
index b6cf410ac9c413008fce9bdb6f921a52a4428bf6..1e42c42cf9fe54ed2d77d2ce253712146804d17e 100644
--- a/gdb/nat/fork-inferior.c
+++ b/gdb/nat/fork-inferior.c
@@ -480,6 +480,16 @@ startup_inferior (process_stratum_target *proc_target, pid_t pid, int ntraps,
 	    resume_signal = ws.sig ();
 	    switch_to_thread (proc_target, event_ptid);
 	    break;
+
+	case TARGET_WAITKIND_UNAVAILABLE:
+	  /* We tried to interrupt the target but it responded that it is
+	     currently unavailable.
+
+	     There is no guarantee that it will become available any time
+	     soon.  That's good enough for starting up the inferior,
+	     however.  */
+	  switch_to_thread (proc_target, event_ptid);
+	  return resume_ptid;
 	}
 
       if (resume_signal != GDB_SIGNAL_TRAP)
diff --git a/gdb/remote.c b/gdb/remote.c
index a4daca885f77803374384adbe13524af3e62b12b..b0e70e1517d6022ca7aba3b63ec34ddf90c85b7b 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -4992,7 +4992,11 @@ remote_target::process_initial_stop_replies (int from_tty)
 	  || ws.sig () != GDB_SIGNAL_0)
 	evthread->set_pending_waitstatus (ws);
 
-      set_executing (this, event_ptid, false);
+      /* Unavailable threads are executing (i.e. they may report events
+	 and we cannot access their state) but not running (i.e. we tried
+	 to stop them) from GDB's point of view.  */
+      if (ws.kind () != TARGET_WAITKIND_UNAVAILABLE)
+	set_executing (this, event_ptid, false);
       set_running (this, event_ptid, false);
       get_remote_thread_info (evthread)->set_not_resumed ();
     }
diff --git a/gdb/target/waitstatus.c b/gdb/target/waitstatus.c
index 94d129a786f81edb27c36e85aff1fcfa32e7af23..4576e5a4553125fa7c13422f9ac17ce23cf416d6 100644
--- a/gdb/target/waitstatus.c
+++ b/gdb/target/waitstatus.c
@@ -62,6 +62,7 @@ DIAGNOSTIC_ERROR_SWITCH
     case TARGET_WAITKIND_NO_HISTORY:
     case TARGET_WAITKIND_NO_RESUMED:
     case TARGET_WAITKIND_THREAD_CREATED:
+    case TARGET_WAITKIND_UNAVAILABLE:
       return str;
     }
 DIAGNOSTIC_POP
diff --git a/gdb/target/waitstatus.h b/gdb/target/waitstatus.h
index d87988f9b77d6c8353db275ace8c18149a792c85..5b897256c1758cb4c6f32ce0ec1240e5876d09c4 100644
--- a/gdb/target/waitstatus.h
+++ b/gdb/target/waitstatus.h
@@ -107,6 +107,19 @@ enum target_waitkind
 
   /* The thread has exited.  The exit status is in value.integer.  */
   TARGET_WAITKIND_THREAD_EXITED,
+
+  /* The thread is unavailable.  We tried to stop it but it did not
+     respond in reasonable time.  Chances are that we won't be able to
+     stop it.
+
+     On GPUs, if we model hardware threads to avoid frequent entry/exit
+     notifications, idle threads may not respond to interrupts and hence
+     cannot be stopped by us.
+
+     They become responsive again when they pick up new work and they may
+     create events such as hitting breakpoints.  But we cannot tell when
+     this will happen - if at all.  */
+  TARGET_WAITKIND_UNAVAILABLE,
 };
 
 /* Determine if KIND represents an event with a new child - a fork,
@@ -165,6 +178,8 @@ DIAGNOSTIC_ERROR_SWITCH
       return "THREAD_CREATED";
     case TARGET_WAITKIND_THREAD_EXITED:
       return "THREAD_EXITED";
+    case TARGET_WAITKIND_UNAVAILABLE:
+      return "UNAVAILABLE";
   };
 DIAGNOSTIC_POP
 
@@ -368,6 +383,13 @@ struct target_waitstatus
     return *this;
   }
 
+  target_waitstatus &set_unavailable ()
+  {
+    this->reset ();
+    m_kind = TARGET_WAITKIND_UNAVAILABLE;
+    return *this;
+  }
+
   /* Get the kind of this wait status.  */
 
   target_waitkind kind () const
diff --git a/gdb/thread.c b/gdb/thread.c
index 920d8dc07a8551a299b475526fa0ac60588b0c32..2bff29ed6646e4a2f08fc641954f6ef6c2184701 100644
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -970,7 +970,7 @@ finish_thread_state (process_stratum_target *targ, ptid_t ptid)
   bool any_started = false;
 
   for (thread_info *tp : all_non_exited_threads (targ, ptid))
-    if (set_running_thread (tp, tp->executing ()))
+    if (set_running_thread (tp, tp->executing () && tp->resumed ()))
       any_started = true;
 
   if (any_started)

-- 
2.34.1

Intel Deutschland GmbH
Registered Address: Am Campeon 10, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de
Managing Directors: Sean Fennelly, Jeffrey Schneiderman, Tiffany Doon Silva
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928