[PATCH v2 15/47] 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 539b11695d965a9e9523b04810fa5943c23b84d3..80372d023dac954eee32b40c468e3f0ce2c5dd87 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 1011cf8f240f0c60c1f67af5b96189149c64a8f8..2dff0d4735fd3d2f1cd4da7c58e22bfd3c99a140 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 5d778920afa7aa7553c62e060fce0ee87342c94b..d28a5867dcfd9fd7888c1d19008cb5606cb9116b 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -5434,7 +5434,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);
@@ -6624,6 +6636,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 41765b102bc0a74ea5cd5586b2c25bdeb6e5d1a3..d70a3d616caddbdc508575be2e63ab8851beb8df 100644
--- a/gdb/nat/fork-inferior.c
+++ b/gdb/nat/fork-inferior.c
@@ -521,6 +521,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 3aaa1614211d617e0d7683eade88f0d00e1bee8b..22c747de555e6a823973e17bbdb7c321364b547a 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -4974,7 +4974,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 9e9b5633b12d803dc2e9d9ac95d38a232525e86c..1cd0eee22367a8f907d7ded0300ee7df10841030 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 7d5ad3f97769c62b2555ec3efcf2a5abe5fc91a2..3d1d1b918c75a04c804c4f3bd311927a64486692 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 5892b158603a7d11cb7c7efc3346f01714797201..fb2959078d860ac39e4d11e7db0e7226cfb24c3e 100644
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -971,7 +971,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