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