[lldb] Move thread_to_run selection to happen before SetupForResume() is called

Later, we'll need to know which thread will run before we determine the
execution direction, which has to happen before we call `SetupForResume()`.
We fix up `thread_to_run` after calling `SetupForResume()`, if required.

Author: rocallahan

lldb/source/Target/ThreadList.cpp

@@ -556,36 +556,46 @@ bool ThreadList::WillResume() {
     }
   }
 
+  ThreadSP thread_to_run;
+  if (run_me_only_list.GetSize(false) > 0) {
+    if (stop_others_thread_sp) {
+      thread_to_run = stop_others_thread_sp;
+    } else if (run_me_only_list.GetSize(false) == 1) {
+      thread_to_run = run_me_only_list.GetThreadAtIndex(0);
+    } else {
+      int random_thread =
+          (int)((run_me_only_list.GetSize(false) * (double)rand()) /
+                (RAND_MAX + 1.0));
+      thread_to_run = run_me_only_list.GetThreadAtIndex(random_thread);
+    }
+  }
+
   // Give all the threads that are likely to run a last chance to set up their
   // state before we negotiate who is actually going to get a chance to run...
   // Don't set to resume suspended threads, and if any thread wanted to stop
   // others, only call setup on the threads that request StopOthers...
-  bool wants_solo_run = run_me_only_list.GetSize(false) > 0;
-  for (pos = m_threads.begin(); pos != end; ++pos) {
-    ThreadSP thread_sp(*pos);
+  if (thread_to_run != nullptr) {
     // See if any thread wants to run stopping others.  If it does, then we
     // won't setup the other threads for resume, since they aren't going to get
     // a chance to run.  This is necessary because the SetupForResume might add
     // "StopOthers" plans which would then get to be part of the who-gets-to-run
     // negotiation, but they're coming in after the fact, and the threads that
     // are already set up should take priority.
-    if (thread_sp->GetResumeState() != eStateSuspended &&
-        (!wants_solo_run || thread_sp->GetCurrentPlan()->StopOthers())) {
-      if (thread_sp->IsOperatingSystemPluginThread() &&
-          !thread_sp->GetBackingThread())
-        continue;
-      if (thread_sp->SetupForResume()) {
-        // You can't say "stop others" and also want yourself to be suspended.
-        assert(thread_sp->GetCurrentPlan()->RunState() != eStateSuspended);
-        run_me_only_list.AddThread(thread_sp);
-
-        if (!(stop_others_thread_sp && stop_others_thread_sp->ShouldRunBeforePublicStop())) {
-          if (thread_sp == GetSelectedThread())
-            stop_others_thread_sp = thread_sp;
-
+    thread_to_run->SetupForResume();
+  } else {
+    for (pos = m_threads.begin(); pos != end; ++pos) {
+      ThreadSP thread_sp(*pos);
+      if (thread_sp->GetResumeState() != eStateSuspended) {
+        if (thread_sp->IsOperatingSystemPluginThread() &&
+            !thread_sp->GetBackingThread())
+          continue;
+        if (thread_sp->SetupForResume()) {
+          // You can't say "stop others" and also want yourself to be suspended.
+          assert(thread_sp->GetCurrentPlan()->RunState() != eStateSuspended);
+          run_me_only_list.AddThread(thread_sp);
+          thread_to_run = thread_sp;
           if (thread_sp->ShouldRunBeforePublicStop()) {
             // This takes precedence, so if we find one of these, service it:
-            stop_others_thread_sp = thread_sp;
             break;
           }
         }
@@ -622,19 +632,6 @@ bool ThreadList::WillResume() {
         need_to_resume = false;
     }
   } else {
-    ThreadSP thread_to_run;
-
-    if (stop_others_thread_sp) {
-      thread_to_run = stop_others_thread_sp;
-    } else if (run_me_only_list.GetSize(false) == 1) {
-      thread_to_run = run_me_only_list.GetThreadAtIndex(0);
-    } else {
-      int random_thread =
-          (int)((run_me_only_list.GetSize(false) * (double)rand()) /
-                (RAND_MAX + 1.0));
-      thread_to_run = run_me_only_list.GetThreadAtIndex(random_thread);
-    }
-
     for (pos = m_threads.begin(); pos != end; ++pos) {
       ThreadSP thread_sp(*pos);
       if (thread_sp == thread_to_run) {