contrib/llvm-project/lldb/source/Target/ThreadList.cpp

   1 //===-- ThreadList.cpp ------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include <stdlib.h>
  10
  11 #include <algorithm>
  12
  13 #include "lldb/Target/Process.h"
  14 #include "lldb/Target/RegisterContext.h"
  15 #include "lldb/Target/Thread.h"
  16 #include "lldb/Target/ThreadList.h"
  17 #include "lldb/Target/ThreadPlan.h"
  18 #include "lldb/Utility/LLDBAssert.h"
  19 #include "lldb/Utility/Log.h"
  20 #include "lldb/Utility/State.h"
  21
  22 using namespace lldb;
  23 using namespace lldb_private;
  24
  25 ThreadList::ThreadList(Process *process)
  26     : ThreadCollection(), m_process(process), m_stop_id(0),
  27       m_selected_tid(LLDB_INVALID_THREAD_ID) {}
  28
  29 ThreadList::ThreadList(const ThreadList &rhs)
  30     : ThreadCollection(), m_process(rhs.m_process), m_stop_id(rhs.m_stop_id),
  31       m_selected_tid() {
  32   // Use the assignment operator since it uses the mutex
  33   *this = rhs;
  34 }
  35
  36 const ThreadList &ThreadList::operator=(const ThreadList &rhs) {
  37   if (this != &rhs) {
  38     // Lock both mutexes to make sure neither side changes anyone on us while
  39     // the assignment occurs
  40     std::lock(GetMutex(), rhs.GetMutex());
  41     std::lock_guard<std::recursive_mutex> guard(GetMutex(), std::adopt_lock);
  42     std::lock_guard<std::recursive_mutex> rhs_guard(rhs.GetMutex(),
  43                                                     std::adopt_lock);
  44
  45     m_process = rhs.m_process;
  46     m_stop_id = rhs.m_stop_id;
  47     m_threads = rhs.m_threads;
  48     m_selected_tid = rhs.m_selected_tid;
  49   }
  50   return *this;
  51 }
  52
  53 ThreadList::~ThreadList() {
  54   // Clear the thread list. Clear will take the mutex lock which will ensure
  55   // that if anyone is using the list they won't get it removed while using it.
  56   Clear();
  57 }
  58
  59 lldb::ThreadSP ThreadList::GetExpressionExecutionThread() {
  60   if (m_expression_tid_stack.empty())
  61     return GetSelectedThread();
  62   ThreadSP expr_thread_sp = FindThreadByID(m_expression_tid_stack.back());
  63   if (expr_thread_sp)
  64     return expr_thread_sp;
  65   else
  66     return GetSelectedThread();
  67 }
  68
  69 void ThreadList::PushExpressionExecutionThread(lldb::tid_t tid) {
  70   m_expression_tid_stack.push_back(tid);
  71 }
  72
  73 void ThreadList::PopExpressionExecutionThread(lldb::tid_t tid) {
  74   assert(m_expression_tid_stack.back() == tid);
  75   m_expression_tid_stack.pop_back();
  76 }
  77
  78 uint32_t ThreadList::GetStopID() const { return m_stop_id; }
  79
  80 void ThreadList::SetStopID(uint32_t stop_id) { m_stop_id = stop_id; }
  81
  82 uint32_t ThreadList::GetSize(bool can_update) {
  83   std::lock_guard<std::recursive_mutex> guard(GetMutex());
  84
  85   if (can_update)
  86     m_process->UpdateThreadListIfNeeded();
  87   return m_threads.size();
  88 }
  89
  90 ThreadSP ThreadList::GetThreadAtIndex(uint32_t idx, bool can_update) {
  91   std::lock_guard<std::recursive_mutex> guard(GetMutex());
  92
  93   if (can_update)
  94     m_process->UpdateThreadListIfNeeded();
  95
  96   ThreadSP thread_sp;
  97   if (idx < m_threads.size())
  98     thread_sp = m_threads[idx];
  99   return thread_sp;
 100 }
 101
 102 ThreadSP ThreadList::FindThreadByID(lldb::tid_t tid, bool can_update) {
 103   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 104
 105   if (can_update)
 106     m_process->UpdateThreadListIfNeeded();
 107
 108   ThreadSP thread_sp;
 109   uint32_t idx = 0;
 110   const uint32_t num_threads = m_threads.size();
 111   for (idx = 0; idx < num_threads; ++idx) {
 112     if (m_threads[idx]->GetID() == tid) {
 113       thread_sp = m_threads[idx];
 114       break;
 115     }
 116   }
 117   return thread_sp;
 118 }
 119
 120 ThreadSP ThreadList::FindThreadByProtocolID(lldb::tid_t tid, bool can_update) {
 121   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 122
 123   if (can_update)
 124     m_process->UpdateThreadListIfNeeded();
 125
 126   ThreadSP thread_sp;
 127   uint32_t idx = 0;
 128   const uint32_t num_threads = m_threads.size();
 129   for (idx = 0; idx < num_threads; ++idx) {
 130     if (m_threads[idx]->GetProtocolID() == tid) {
 131       thread_sp = m_threads[idx];
 132       break;
 133     }
 134   }
 135   return thread_sp;
 136 }
 137
 138 ThreadSP ThreadList::RemoveThreadByID(lldb::tid_t tid, bool can_update) {
 139   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 140
 141   if (can_update)
 142     m_process->UpdateThreadListIfNeeded();
 143
 144   ThreadSP thread_sp;
 145   uint32_t idx = 0;
 146   const uint32_t num_threads = m_threads.size();
 147   for (idx = 0; idx < num_threads; ++idx) {
 148     if (m_threads[idx]->GetID() == tid) {
 149       thread_sp = m_threads[idx];
 150       m_threads.erase(m_threads.begin() + idx);
 151       break;
 152     }
 153   }
 154   return thread_sp;
 155 }
 156
 157 ThreadSP ThreadList::RemoveThreadByProtocolID(lldb::tid_t tid,
 158                                               bool can_update) {
 159   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 160
 161   if (can_update)
 162     m_process->UpdateThreadListIfNeeded();
 163
 164   ThreadSP thread_sp;
 165   uint32_t idx = 0;
 166   const uint32_t num_threads = m_threads.size();
 167   for (idx = 0; idx < num_threads; ++idx) {
 168     if (m_threads[idx]->GetProtocolID() == tid) {
 169       thread_sp = m_threads[idx];
 170       m_threads.erase(m_threads.begin() + idx);
 171       break;
 172     }
 173   }
 174   return thread_sp;
 175 }
 176
 177 ThreadSP ThreadList::GetThreadSPForThreadPtr(Thread *thread_ptr) {
 178   ThreadSP thread_sp;
 179   if (thread_ptr) {
 180     std::lock_guard<std::recursive_mutex> guard(GetMutex());
 181
 182     uint32_t idx = 0;
 183     const uint32_t num_threads = m_threads.size();
 184     for (idx = 0; idx < num_threads; ++idx) {
 185       if (m_threads[idx].get() == thread_ptr) {
 186         thread_sp = m_threads[idx];
 187         break;
 188       }
 189     }
 190   }
 191   return thread_sp;
 192 }
 193
 194 ThreadSP ThreadList::GetBackingThread(const ThreadSP &real_thread) {
 195   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 196
 197   ThreadSP thread_sp;
 198   const uint32_t num_threads = m_threads.size();
 199   for (uint32_t idx = 0; idx < num_threads; ++idx) {
 200     if (m_threads[idx]->GetBackingThread() == real_thread) {
 201       thread_sp = m_threads[idx];
 202       break;
 203     }
 204   }
 205   return thread_sp;
 206 }
 207
 208 ThreadSP ThreadList::FindThreadByIndexID(uint32_t index_id, bool can_update) {
 209   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 210
 211   if (can_update)
 212     m_process->UpdateThreadListIfNeeded();
 213
 214   ThreadSP thread_sp;
 215   const uint32_t num_threads = m_threads.size();
 216   for (uint32_t idx = 0; idx < num_threads; ++idx) {
 217     if (m_threads[idx]->GetIndexID() == index_id) {
 218       thread_sp = m_threads[idx];
 219       break;
 220     }
 221   }
 222   return thread_sp;
 223 }
 224
 225 bool ThreadList::ShouldStop(Event *event_ptr) {
 226   // Running events should never stop, obviously...
 227
 228   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 229
 230   // The ShouldStop method of the threads can do a whole lot of work, figuring
 231   // out whether the thread plan conditions are met.  So we don't want to keep
 232   // the ThreadList locked the whole time we are doing this.
 233   // FIXME: It is possible that running code could cause new threads
 234   // to be created.  If that happens, we will miss asking them whether they
 235   // should stop.  This is not a big deal since we haven't had a chance to hang
 236   // any interesting operations on those threads yet.
 237
 238   collection threads_copy;
 239   {
 240     // Scope for locker
 241     std::lock_guard<std::recursive_mutex> guard(GetMutex());
 242
 243     m_process->UpdateThreadListIfNeeded();
 244     for (lldb::ThreadSP thread_sp : m_threads) {
 245       // This is an optimization...  If we didn't let a thread run in between
 246       // the previous stop and this one, we shouldn't have to consult it for
 247       // ShouldStop.  So just leave it off the list we are going to inspect. On
 248       // Linux, if a thread-specific conditional breakpoint was hit, it won't
 249       // necessarily be the thread that hit the breakpoint itself that
 250       // evaluates the conditional expression, so the thread that hit the
 251       // breakpoint could still be asked to stop, even though it hasn't been
 252       // allowed to run since the previous stop.
 253       if (thread_sp->GetTemporaryResumeState() != eStateSuspended ||
 254           thread_sp->IsStillAtLastBreakpointHit())
 255         threads_copy.push_back(thread_sp);
 256     }
 257
 258     // It is possible the threads we were allowing to run all exited and then
 259     // maybe the user interrupted or something, then fall back on looking at
 260     // all threads:
 261
 262     if (threads_copy.size() == 0)
 263       threads_copy = m_threads;
 264   }
 265
 266   collection::iterator pos, end = threads_copy.end();
 267
 268   if (log) {
 269     log->PutCString("");
 270     log->Printf("ThreadList::%s: %" PRIu64 " threads, %" PRIu64
 271                 " unsuspended threads",
 272                 __FUNCTION__, (uint64_t)m_threads.size(),
 273                 (uint64_t)threads_copy.size());
 274   }
 275
 276   bool did_anybody_stop_for_a_reason = false;
 277
 278   // If the event is an Interrupt event, then we're going to stop no matter
 279   // what.  Otherwise, presume we won't stop.
 280   bool should_stop = false;
 281   if (Process::ProcessEventData::GetInterruptedFromEvent(event_ptr)) {
 282     if (log)
 283       log->Printf(
 284           "ThreadList::%s handling interrupt event, should stop set to true",
 285           __FUNCTION__);
 286
 287     should_stop = true;
 288   }
 289
 290   // Now we run through all the threads and get their stop info's.  We want to
 291   // make sure to do this first before we start running the ShouldStop, because
 292   // one thread's ShouldStop could destroy information (like deleting a thread
 293   // specific breakpoint another thread had stopped at) which could lead us to
 294   // compute the StopInfo incorrectly. We don't need to use it here, we just
 295   // want to make sure it gets computed.
 296
 297   for (pos = threads_copy.begin(); pos != end; ++pos) {
 298     ThreadSP thread_sp(*pos);
 299     thread_sp->GetStopInfo();
 300   }
 301
 302   for (pos = threads_copy.begin(); pos != end; ++pos) {
 303     ThreadSP thread_sp(*pos);
 304
 305     // We should never get a stop for which no thread had a stop reason, but
 306     // sometimes we do see this - for instance when we first connect to a
 307     // remote stub.  In that case we should stop, since we can't figure out the
 308     // right thing to do and stopping gives the user control over what to do in
 309     // this instance.
 310     //
 311     // Note, this causes a problem when you have a thread specific breakpoint,
 312     // and a bunch of threads hit the breakpoint, but not the thread which we
 313     // are waiting for.  All the threads that are not "supposed" to hit the
 314     // breakpoint are marked as having no stop reason, which is right, they
 315     // should not show a stop reason.  But that triggers this code and causes
 316     // us to stop seemingly for no reason.
 317     //
 318     // Since the only way we ever saw this error was on first attach, I'm only
 319     // going to trigger set did_anybody_stop_for_a_reason to true unless this
 320     // is the first stop.
 321     //
 322     // If this becomes a problem, we'll have to have another StopReason like
 323     // "StopInfoHidden" which will look invalid everywhere but at this check.
 324
 325     if (thread_sp->GetProcess()->GetStopID() > 1)
 326       did_anybody_stop_for_a_reason = true;
 327     else
 328       did_anybody_stop_for_a_reason |= thread_sp->ThreadStoppedForAReason();
 329
 330     const bool thread_should_stop = thread_sp->ShouldStop(event_ptr);
 331     if (thread_should_stop)
 332       should_stop |= true;
 333   }
 334
 335   if (!should_stop && !did_anybody_stop_for_a_reason) {
 336     should_stop = true;
 337     if (log)
 338       log->Printf("ThreadList::%s we stopped but no threads had a stop reason, "
 339                   "overriding should_stop and stopping.",
 340                   __FUNCTION__);
 341   }
 342
 343   if (log)
 344     log->Printf("ThreadList::%s overall should_stop = %i", __FUNCTION__,
 345                 should_stop);
 346
 347   if (should_stop) {
 348     for (pos = threads_copy.begin(); pos != end; ++pos) {
 349       ThreadSP thread_sp(*pos);
 350       thread_sp->WillStop();
 351     }
 352   }
 353
 354   return should_stop;
 355 }
 356
 357 Vote ThreadList::ShouldReportStop(Event *event_ptr) {
 358   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 359
 360   Vote result = eVoteNoOpinion;
 361   m_process->UpdateThreadListIfNeeded();
 362   collection::iterator pos, end = m_threads.end();
 363
 364   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 365
 366   if (log)
 367     log->Printf("ThreadList::%s %" PRIu64 " threads", __FUNCTION__,
 368                 (uint64_t)m_threads.size());
 369
 370   // Run through the threads and ask whether we should report this event. For
 371   // stopping, a YES vote wins over everything.  A NO vote wins over NO
 372   // opinion.
 373   for (pos = m_threads.begin(); pos != end; ++pos) {
 374     ThreadSP thread_sp(*pos);
 375     const Vote vote = thread_sp->ShouldReportStop(event_ptr);
 376     switch (vote) {
 377     case eVoteNoOpinion:
 378       continue;
 379
 380     case eVoteYes:
 381       result = eVoteYes;
 382       break;
 383
 384     case eVoteNo:
 385       if (result == eVoteNoOpinion) {
 386         result = eVoteNo;
 387       } else {
 388         LLDB_LOG(log,
 389           "Thread {0:x} voted {1}, but lost out because result was {2}",
 390           thread_sp->GetID(), vote, result);
 391       }
 392       break;
 393     }
 394   }
 395   LLDB_LOG(log, "Returning {0}", result);
 396   return result;
 397 }
 398
 399 void ThreadList::SetShouldReportStop(Vote vote) {
 400   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 401
 402   m_process->UpdateThreadListIfNeeded();
 403   collection::iterator pos, end = m_threads.end();
 404   for (pos = m_threads.begin(); pos != end; ++pos) {
 405     ThreadSP thread_sp(*pos);
 406     thread_sp->SetShouldReportStop(vote);
 407   }
 408 }
 409
 410 Vote ThreadList::ShouldReportRun(Event *event_ptr) {
 411
 412   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 413
 414   Vote result = eVoteNoOpinion;
 415   m_process->UpdateThreadListIfNeeded();
 416   collection::iterator pos, end = m_threads.end();
 417
 418   // Run through the threads and ask whether we should report this event. The
 419   // rule is NO vote wins over everything, a YES vote wins over no opinion.
 420
 421   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 422
 423   for (pos = m_threads.begin(); pos != end; ++pos) {
 424     if ((*pos)->GetResumeState() != eStateSuspended) {
 425       switch ((*pos)->ShouldReportRun(event_ptr)) {
 426       case eVoteNoOpinion:
 427         continue;
 428       case eVoteYes:
 429         if (result == eVoteNoOpinion)
 430           result = eVoteYes;
 431         break;
 432       case eVoteNo:
 433         if (log)
 434           log->Printf("ThreadList::ShouldReportRun() thread %d (0x%4.4" PRIx64
 435                       ") says don't report.",
 436                       (*pos)->GetIndexID(), (*pos)->GetID());
 437         result = eVoteNo;
 438         break;
 439       }
 440     }
 441   }
 442   return result;
 443 }
 444
 445 void ThreadList::Clear() {
 446   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 447   m_stop_id = 0;
 448   m_threads.clear();
 449   m_selected_tid = LLDB_INVALID_THREAD_ID;
 450 }
 451
 452 void ThreadList::Destroy() {
 453   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 454   const uint32_t num_threads = m_threads.size();
 455   for (uint32_t idx = 0; idx < num_threads; ++idx) {
 456     m_threads[idx]->DestroyThread();
 457   }
 458 }
 459
 460 void ThreadList::RefreshStateAfterStop() {
 461   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 462
 463   m_process->UpdateThreadListIfNeeded();
 464
 465   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 466   if (log && log->GetVerbose())
 467     log->Printf("Turning off notification of new threads while single stepping "
 468                 "a thread.");
 469
 470   collection::iterator pos, end = m_threads.end();
 471   for (pos = m_threads.begin(); pos != end; ++pos)
 472     (*pos)->RefreshStateAfterStop();
 473 }
 474
 475 void ThreadList::DiscardThreadPlans() {
 476   // You don't need to update the thread list here, because only threads that
 477   // you currently know about have any thread plans.
 478   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 479
 480   collection::iterator pos, end = m_threads.end();
 481   for (pos = m_threads.begin(); pos != end; ++pos)
 482     (*pos)->DiscardThreadPlans(true);
 483 }
 484
 485 bool ThreadList::WillResume() {
 486   // Run through the threads and perform their momentary actions. But we only
 487   // do this for threads that are running, user suspended threads stay where
 488   // they are.
 489
 490   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 491   m_process->UpdateThreadListIfNeeded();
 492
 493   collection::iterator pos, end = m_threads.end();
 494
 495   // See if any thread wants to run stopping others.  If it does, then we won't
 496   // setup the other threads for resume, since they aren't going to get a
 497   // chance to run.  This is necessary because the SetupForResume might add
 498   // "StopOthers" plans which would then get to be part of the who-gets-to-run
 499   // negotiation, but they're coming in after the fact, and the threads that
 500   // are already set up should take priority.
 501
 502   bool wants_solo_run = false;
 503
 504   for (pos = m_threads.begin(); pos != end; ++pos) {
 505     lldbassert((*pos)->GetCurrentPlan() &&
 506                "thread should not have null thread plan");
 507     if ((*pos)->GetResumeState() != eStateSuspended &&
 508         (*pos)->GetCurrentPlan()->StopOthers()) {
 509       if ((*pos)->IsOperatingSystemPluginThread() &&
 510           !(*pos)->GetBackingThread())
 511         continue;
 512       wants_solo_run = true;
 513       break;
 514     }
 515   }
 516
 517   if (wants_solo_run) {
 518     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 519     if (log && log->GetVerbose())
 520       log->Printf("Turning on notification of new threads while single "
 521                   "stepping a thread.");
 522     m_process->StartNoticingNewThreads();
 523   } else {
 524     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 525     if (log && log->GetVerbose())
 526       log->Printf("Turning off notification of new threads while single "
 527                   "stepping a thread.");
 528     m_process->StopNoticingNewThreads();
 529   }
 530
 531   // Give all the threads that are likely to run a last chance to set up their
 532   // state before we negotiate who is actually going to get a chance to run...
 533   // Don't set to resume suspended threads, and if any thread wanted to stop
 534   // others, only call setup on the threads that request StopOthers...
 535
 536   for (pos = m_threads.begin(); pos != end; ++pos) {
 537     if ((*pos)->GetResumeState() != eStateSuspended &&
 538         (!wants_solo_run || (*pos)->GetCurrentPlan()->StopOthers())) {
 539       if ((*pos)->IsOperatingSystemPluginThread() &&
 540           !(*pos)->GetBackingThread())
 541         continue;
 542       (*pos)->SetupForResume();
 543     }
 544   }
 545
 546   // Now go through the threads and see if any thread wants to run just itself.
 547   // if so then pick one and run it.
 548
 549   ThreadList run_me_only_list(m_process);
 550
 551   run_me_only_list.SetStopID(m_process->GetStopID());
 552
 553   bool run_only_current_thread = false;
 554
 555   for (pos = m_threads.begin(); pos != end; ++pos) {
 556     ThreadSP thread_sp(*pos);
 557     if (thread_sp->GetResumeState() != eStateSuspended &&
 558         thread_sp->GetCurrentPlan()->StopOthers()) {
 559       if ((*pos)->IsOperatingSystemPluginThread() &&
 560           !(*pos)->GetBackingThread())
 561         continue;
 562
 563       // You can't say "stop others" and also want yourself to be suspended.
 564       assert(thread_sp->GetCurrentPlan()->RunState() != eStateSuspended);
 565
 566       if (thread_sp == GetSelectedThread()) {
 567         // If the currently selected thread wants to run on its own, always let
 568         // it.
 569         run_only_current_thread = true;
 570         run_me_only_list.Clear();
 571         run_me_only_list.AddThread(thread_sp);
 572         break;
 573       }
 574
 575       run_me_only_list.AddThread(thread_sp);
 576     }
 577   }
 578
 579   bool need_to_resume = true;
 580
 581   if (run_me_only_list.GetSize(false) == 0) {
 582     // Everybody runs as they wish:
 583     for (pos = m_threads.begin(); pos != end; ++pos) {
 584       ThreadSP thread_sp(*pos);
 585       StateType run_state;
 586       if (thread_sp->GetResumeState() != eStateSuspended)
 587         run_state = thread_sp->GetCurrentPlan()->RunState();
 588       else
 589         run_state = eStateSuspended;
 590       if (!thread_sp->ShouldResume(run_state))
 591         need_to_resume = false;
 592     }
 593   } else {
 594     ThreadSP thread_to_run;
 595
 596     if (run_only_current_thread) {
 597       thread_to_run = GetSelectedThread();
 598     } else if (run_me_only_list.GetSize(false) == 1) {
 599       thread_to_run = run_me_only_list.GetThreadAtIndex(0);
 600     } else {
 601       int random_thread =
 602           (int)((run_me_only_list.GetSize(false) * (double)rand()) /
 603                 (RAND_MAX + 1.0));
 604       thread_to_run = run_me_only_list.GetThreadAtIndex(random_thread);
 605     }
 606
 607     for (pos = m_threads.begin(); pos != end; ++pos) {
 608       ThreadSP thread_sp(*pos);
 609       if (thread_sp == thread_to_run) {
 610         if (!thread_sp->ShouldResume(thread_sp->GetCurrentPlan()->RunState()))
 611           need_to_resume = false;
 612       } else
 613         thread_sp->ShouldResume(eStateSuspended);
 614     }
 615   }
 616
 617   return need_to_resume;
 618 }
 619
 620 void ThreadList::DidResume() {
 621   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 622   collection::iterator pos, end = m_threads.end();
 623   for (pos = m_threads.begin(); pos != end; ++pos) {
 624     // Don't clear out threads that aren't going to get a chance to run, rather
 625     // leave their state for the next time around.
 626     ThreadSP thread_sp(*pos);
 627     if (thread_sp->GetResumeState() != eStateSuspended)
 628       thread_sp->DidResume();
 629   }
 630 }
 631
 632 void ThreadList::DidStop() {
 633   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 634   collection::iterator pos, end = m_threads.end();
 635   for (pos = m_threads.begin(); pos != end; ++pos) {
 636     // Notify threads that the process just stopped. Note, this currently
 637     // assumes that all threads in the list stop when the process stops.  In
 638     // the future we will want to support a debugging model where some threads
 639     // continue to run while others are stopped.  We either need to handle that
 640     // somehow here or create a special thread list containing only threads
 641     // which will stop in the code that calls this method (currently
 642     // Process::SetPrivateState).
 643     ThreadSP thread_sp(*pos);
 644     if (StateIsRunningState(thread_sp->GetState()))
 645       thread_sp->DidStop();
 646   }
 647 }
 648
 649 ThreadSP ThreadList::GetSelectedThread() {
 650   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 651   ThreadSP thread_sp = FindThreadByID(m_selected_tid);
 652   if (!thread_sp.get()) {
 653     if (m_threads.size() == 0)
 654       return thread_sp;
 655     m_selected_tid = m_threads[0]->GetID();
 656     thread_sp = m_threads[0];
 657   }
 658   return thread_sp;
 659 }
 660
 661 bool ThreadList::SetSelectedThreadByID(lldb::tid_t tid, bool notify) {
 662   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 663   ThreadSP selected_thread_sp(FindThreadByID(tid));
 664   if (selected_thread_sp) {
 665     m_selected_tid = tid;
 666     selected_thread_sp->SetDefaultFileAndLineToSelectedFrame();
 667   } else
 668     m_selected_tid = LLDB_INVALID_THREAD_ID;
 669
 670   if (notify)
 671     NotifySelectedThreadChanged(m_selected_tid);
 672
 673   return m_selected_tid != LLDB_INVALID_THREAD_ID;
 674 }
 675
 676 bool ThreadList::SetSelectedThreadByIndexID(uint32_t index_id, bool notify) {
 677   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 678   ThreadSP selected_thread_sp(FindThreadByIndexID(index_id));
 679   if (selected_thread_sp.get()) {
 680     m_selected_tid = selected_thread_sp->GetID();
 681     selected_thread_sp->SetDefaultFileAndLineToSelectedFrame();
 682   } else
 683     m_selected_tid = LLDB_INVALID_THREAD_ID;
 684
 685   if (notify)
 686     NotifySelectedThreadChanged(m_selected_tid);
 687
 688   return m_selected_tid != LLDB_INVALID_THREAD_ID;
 689 }
 690
 691 void ThreadList::NotifySelectedThreadChanged(lldb::tid_t tid) {
 692   ThreadSP selected_thread_sp(FindThreadByID(tid));
 693   if (selected_thread_sp->EventTypeHasListeners(
 694           Thread::eBroadcastBitThreadSelected))
 695     selected_thread_sp->BroadcastEvent(
 696         Thread::eBroadcastBitThreadSelected,
 697         new Thread::ThreadEventData(selected_thread_sp));
 698 }
 699
 700 void ThreadList::Update(ThreadList &rhs) {
 701   if (this != &rhs) {
 702     // Lock both mutexes to make sure neither side changes anyone on us while
 703     // the assignment occurs
 704     std::lock_guard<std::recursive_mutex> guard(GetMutex());
 705
 706     m_process = rhs.m_process;
 707     m_stop_id = rhs.m_stop_id;
 708     m_threads.swap(rhs.m_threads);
 709     m_selected_tid = rhs.m_selected_tid;
 710
 711     // Now we look for threads that we are done with and make sure to clear
 712     // them up as much as possible so anyone with a shared pointer will still
 713     // have a reference, but the thread won't be of much use. Using
 714     // std::weak_ptr for all backward references (such as a thread to a
 715     // process) will eventually solve this issue for us, but for now, we need
 716     // to work around the issue
 717     collection::iterator rhs_pos, rhs_end = rhs.m_threads.end();
 718     for (rhs_pos = rhs.m_threads.begin(); rhs_pos != rhs_end; ++rhs_pos) {
 719       const lldb::tid_t tid = (*rhs_pos)->GetID();
 720       bool thread_is_alive = false;
 721       const uint32_t num_threads = m_threads.size();
 722       for (uint32_t idx = 0; idx < num_threads; ++idx) {
 723         ThreadSP backing_thread = m_threads[idx]->GetBackingThread();
 724         if (m_threads[idx]->GetID() == tid ||
 725             (backing_thread && backing_thread->GetID() == tid)) {
 726           thread_is_alive = true;
 727           break;
 728         }
 729       }
 730       if (!thread_is_alive)
 731         (*rhs_pos)->DestroyThread();
 732     }
 733   }
 734 }
 735
 736 void ThreadList::Flush() {
 737   std::lock_guard<std::recursive_mutex> guard(GetMutex());
 738   collection::iterator pos, end = m_threads.end();
 739   for (pos = m_threads.begin(); pos != end; ++pos)
 740     (*pos)->Flush();
 741 }
 742
 743 std::recursive_mutex &ThreadList::GetMutex() const {
 744   return m_process->m_thread_mutex;
 745 }
 746
 747 ThreadList::ExpressionExecutionThreadPusher::ExpressionExecutionThreadPusher(
 748     lldb::ThreadSP thread_sp)
 749     : m_thread_list(nullptr), m_tid(LLDB_INVALID_THREAD_ID) {
 750   if (thread_sp) {
 751     m_tid = thread_sp->GetID();
 752     m_thread_list = &thread_sp->GetProcess()->GetThreadList();
 753     m_thread_list->PushExpressionExecutionThread(m_tid);
 754   }
 755 }