contrib/llvm/tools/lldb/source/Target/ThreadList.cpp

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