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 LLDB_LOGF(log, 271 "ThreadList::%s: %" PRIu64 " threads, %" PRIu64 272 " unsuspended threads", 273 __FUNCTION__, (uint64_t)m_threads.size(), 274 (uint64_t)threads_copy.size()); 275 } 276 277 bool did_anybody_stop_for_a_reason = false; 278 279 // If the event is an Interrupt event, then we're going to stop no matter 280 // what. Otherwise, presume we won't stop. 281 bool should_stop = false; 282 if (Process::ProcessEventData::GetInterruptedFromEvent(event_ptr)) { 283 LLDB_LOGF( 284 log, "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 LLDB_LOGF(log, 338 "ThreadList::%s we stopped but no threads had a stop reason, " 339 "overriding should_stop and stopping.", 340 __FUNCTION__); 341 } 342 343 LLDB_LOGF(log, "ThreadList::%s overall should_stop = %i", __FUNCTION__, 344 should_stop); 345 346 if (should_stop) { 347 for (pos = threads_copy.begin(); pos != end; ++pos) { 348 ThreadSP thread_sp(*pos); 349 thread_sp->WillStop(); 350 } 351 } 352 353 return should_stop; 354 } 355 356 Vote ThreadList::ShouldReportStop(Event *event_ptr) { 357 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 358 359 Vote result = eVoteNoOpinion; 360 m_process->UpdateThreadListIfNeeded(); 361 collection::iterator pos, end = m_threads.end(); 362 363 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 364 365 LLDB_LOGF(log, "ThreadList::%s %" PRIu64 " threads", __FUNCTION__, 366 (uint64_t)m_threads.size()); 367 368 // Run through the threads and ask whether we should report this event. For 369 // stopping, a YES vote wins over everything. A NO vote wins over NO 370 // opinion. 371 for (pos = m_threads.begin(); pos != end; ++pos) { 372 ThreadSP thread_sp(*pos); 373 const Vote vote = thread_sp->ShouldReportStop(event_ptr); 374 switch (vote) { 375 case eVoteNoOpinion: 376 continue; 377 378 case eVoteYes: 379 result = eVoteYes; 380 break; 381 382 case eVoteNo: 383 if (result == eVoteNoOpinion) { 384 result = eVoteNo; 385 } else { 386 LLDB_LOG(log, 387 "Thread {0:x} voted {1}, but lost out because result was {2}", 388 thread_sp->GetID(), vote, result); 389 } 390 break; 391 } 392 } 393 LLDB_LOG(log, "Returning {0}", result); 394 return result; 395 } 396 397 void ThreadList::SetShouldReportStop(Vote vote) { 398 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 399 400 m_process->UpdateThreadListIfNeeded(); 401 collection::iterator pos, end = m_threads.end(); 402 for (pos = m_threads.begin(); pos != end; ++pos) { 403 ThreadSP thread_sp(*pos); 404 thread_sp->SetShouldReportStop(vote); 405 } 406 } 407 408 Vote ThreadList::ShouldReportRun(Event *event_ptr) { 409 410 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 411 412 Vote result = eVoteNoOpinion; 413 m_process->UpdateThreadListIfNeeded(); 414 collection::iterator pos, end = m_threads.end(); 415 416 // Run through the threads and ask whether we should report this event. The 417 // rule is NO vote wins over everything, a YES vote wins over no opinion. 418 419 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 420 421 for (pos = m_threads.begin(); pos != end; ++pos) { 422 if ((*pos)->GetResumeState() != eStateSuspended) { 423 switch ((*pos)->ShouldReportRun(event_ptr)) { 424 case eVoteNoOpinion: 425 continue; 426 case eVoteYes: 427 if (result == eVoteNoOpinion) 428 result = eVoteYes; 429 break; 430 case eVoteNo: 431 LLDB_LOGF(log, 432 "ThreadList::ShouldReportRun() thread %d (0x%4.4" PRIx64 433 ") says don't report.", 434 (*pos)->GetIndexID(), (*pos)->GetID()); 435 result = eVoteNo; 436 break; 437 } 438 } 439 } 440 return result; 441 } 442 443 void ThreadList::Clear() { 444 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 445 m_stop_id = 0; 446 m_threads.clear(); 447 m_selected_tid = LLDB_INVALID_THREAD_ID; 448 } 449 450 void ThreadList::Destroy() { 451 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 452 const uint32_t num_threads = m_threads.size(); 453 for (uint32_t idx = 0; idx < num_threads; ++idx) { 454 m_threads[idx]->DestroyThread(); 455 } 456 } 457 458 void ThreadList::RefreshStateAfterStop() { 459 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 460 461 m_process->UpdateThreadListIfNeeded(); 462 463 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 464 if (log && log->GetVerbose()) 465 LLDB_LOGF(log, 466 "Turning off notification of new threads while single stepping " 467 "a thread."); 468 469 collection::iterator pos, end = m_threads.end(); 470 for (pos = m_threads.begin(); pos != end; ++pos) 471 (*pos)->RefreshStateAfterStop(); 472 } 473 474 void ThreadList::DiscardThreadPlans() { 475 // You don't need to update the thread list here, because only threads that 476 // you currently know about have any thread plans. 477 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 478 479 collection::iterator pos, end = m_threads.end(); 480 for (pos = m_threads.begin(); pos != end; ++pos) 481 (*pos)->DiscardThreadPlans(true); 482 } 483 484 bool ThreadList::WillResume() { 485 // Run through the threads and perform their momentary actions. But we only 486 // do this for threads that are running, user suspended threads stay where 487 // they are. 488 489 std::lock_guard<std::recursive_mutex> guard(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 496 // chance to run. This is necessary because the SetupForResume might add 497 // "StopOthers" plans which would then get to be part of the who-gets-to-run 498 // negotiation, but they're coming in after the fact, and the threads that 499 // are already set up should take priority. 500 501 bool wants_solo_run = false; 502 503 for (pos = m_threads.begin(); pos != end; ++pos) { 504 lldbassert((*pos)->GetCurrentPlan() && 505 "thread should not have null thread plan"); 506 if ((*pos)->GetResumeState() != eStateSuspended && 507 (*pos)->GetCurrentPlan()->StopOthers()) { 508 if ((*pos)->IsOperatingSystemPluginThread() && 509 !(*pos)->GetBackingThread()) 510 continue; 511 wants_solo_run = true; 512 break; 513 } 514 } 515 516 if (wants_solo_run) { 517 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 518 if (log && log->GetVerbose()) 519 LLDB_LOGF(log, "Turning on notification of new threads while single " 520 "stepping a thread."); 521 m_process->StartNoticingNewThreads(); 522 } else { 523 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 524 if (log && log->GetVerbose()) 525 LLDB_LOGF(log, "Turning off notification of new threads while single " 526 "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 531 // state before we 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 533 // others, only call setup on the threads that request StopOthers... 534 535 for (pos = m_threads.begin(); pos != end; ++pos) { 536 if ((*pos)->GetResumeState() != eStateSuspended && 537 (!wants_solo_run || (*pos)->GetCurrentPlan()->StopOthers())) { 538 if ((*pos)->IsOperatingSystemPluginThread() && 539 !(*pos)->GetBackingThread()) 540 continue; 541 (*pos)->SetupForResume(); 542 } 543 } 544 545 // Now go through the threads and see if any thread wants to run just itself. 546 // if so then pick one and run it. 547 548 ThreadList run_me_only_list(m_process); 549 550 run_me_only_list.SetStopID(m_process->GetStopID()); 551 552 bool run_only_current_thread = false; 553 554 for (pos = m_threads.begin(); pos != end; ++pos) { 555 ThreadSP thread_sp(*pos); 556 if (thread_sp->GetResumeState() != eStateSuspended && 557 thread_sp->GetCurrentPlan()->StopOthers()) { 558 if ((*pos)->IsOperatingSystemPluginThread() && 559 !(*pos)->GetBackingThread()) 560 continue; 561 562 // You can't say "stop others" and also want yourself to be suspended. 563 assert(thread_sp->GetCurrentPlan()->RunState() != eStateSuspended); 564 565 if (thread_sp == GetSelectedThread()) { 566 // If the currently selected thread wants to run on its own, always let 567 // it. 568 run_only_current_thread = true; 569 run_me_only_list.Clear(); 570 run_me_only_list.AddThread(thread_sp); 571 break; 572 } 573 574 run_me_only_list.AddThread(thread_sp); 575 } 576 } 577 578 bool need_to_resume = true; 579 580 if (run_me_only_list.GetSize(false) == 0) { 581 // Everybody runs as they wish: 582 for (pos = m_threads.begin(); pos != end; ++pos) { 583 ThreadSP thread_sp(*pos); 584 StateType run_state; 585 if (thread_sp->GetResumeState() != eStateSuspended) 586 run_state = thread_sp->GetCurrentPlan()->RunState(); 587 else 588 run_state = eStateSuspended; 589 if (!thread_sp->ShouldResume(run_state)) 590 need_to_resume = false; 591 } 592 } else { 593 ThreadSP thread_to_run; 594 595 if (run_only_current_thread) { 596 thread_to_run = GetSelectedThread(); 597 } else if (run_me_only_list.GetSize(false) == 1) { 598 thread_to_run = run_me_only_list.GetThreadAtIndex(0); 599 } else { 600 int random_thread = 601 (int)((run_me_only_list.GetSize(false) * (double)rand()) / 602 (RAND_MAX + 1.0)); 603 thread_to_run = run_me_only_list.GetThreadAtIndex(random_thread); 604 } 605 606 for (pos = m_threads.begin(); pos != end; ++pos) { 607 ThreadSP thread_sp(*pos); 608 if (thread_sp == thread_to_run) { 609 if (!thread_sp->ShouldResume(thread_sp->GetCurrentPlan()->RunState())) 610 need_to_resume = false; 611 } else 612 thread_sp->ShouldResume(eStateSuspended); 613 } 614 } 615 616 return need_to_resume; 617 } 618 619 void ThreadList::DidResume() { 620 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 621 collection::iterator pos, end = m_threads.end(); 622 for (pos = m_threads.begin(); pos != end; ++pos) { 623 // Don't clear out threads that aren't going to get a chance to run, rather 624 // leave their state for the next time around. 625 ThreadSP thread_sp(*pos); 626 if (thread_sp->GetResumeState() != eStateSuspended) 627 thread_sp->DidResume(); 628 } 629 } 630 631 void ThreadList::DidStop() { 632 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 633 collection::iterator pos, end = m_threads.end(); 634 for (pos = m_threads.begin(); pos != end; ++pos) { 635 // Notify threads that the process just stopped. Note, this currently 636 // assumes that all threads in the list stop when the process stops. In 637 // the future we will want to support a debugging model where some threads 638 // continue to run while others are stopped. We either need to handle that 639 // somehow here or create a special thread list containing only threads 640 // which will stop in the code that calls this method (currently 641 // Process::SetPrivateState). 642 ThreadSP thread_sp(*pos); 643 if (StateIsRunningState(thread_sp->GetState())) 644 thread_sp->DidStop(); 645 } 646 } 647 648 ThreadSP ThreadList::GetSelectedThread() { 649 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 650 ThreadSP thread_sp = FindThreadByID(m_selected_tid); 651 if (!thread_sp.get()) { 652 if (m_threads.size() == 0) 653 return thread_sp; 654 m_selected_tid = m_threads[0]->GetID(); 655 thread_sp = m_threads[0]; 656 } 657 return thread_sp; 658 } 659 660 bool ThreadList::SetSelectedThreadByID(lldb::tid_t tid, bool notify) { 661 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 662 ThreadSP selected_thread_sp(FindThreadByID(tid)); 663 if (selected_thread_sp) { 664 m_selected_tid = tid; 665 selected_thread_sp->SetDefaultFileAndLineToSelectedFrame(); 666 } else 667 m_selected_tid = LLDB_INVALID_THREAD_ID; 668 669 if (notify) 670 NotifySelectedThreadChanged(m_selected_tid); 671 672 return m_selected_tid != LLDB_INVALID_THREAD_ID; 673 } 674 675 bool ThreadList::SetSelectedThreadByIndexID(uint32_t index_id, bool notify) { 676 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 677 ThreadSP selected_thread_sp(FindThreadByIndexID(index_id)); 678 if (selected_thread_sp.get()) { 679 m_selected_tid = selected_thread_sp->GetID(); 680 selected_thread_sp->SetDefaultFileAndLineToSelectedFrame(); 681 } else 682 m_selected_tid = LLDB_INVALID_THREAD_ID; 683 684 if (notify) 685 NotifySelectedThreadChanged(m_selected_tid); 686 687 return m_selected_tid != LLDB_INVALID_THREAD_ID; 688 } 689 690 void ThreadList::NotifySelectedThreadChanged(lldb::tid_t tid) { 691 ThreadSP selected_thread_sp(FindThreadByID(tid)); 692 if (selected_thread_sp->EventTypeHasListeners( 693 Thread::eBroadcastBitThreadSelected)) 694 selected_thread_sp->BroadcastEvent( 695 Thread::eBroadcastBitThreadSelected, 696 new Thread::ThreadEventData(selected_thread_sp)); 697 } 698 699 void ThreadList::Update(ThreadList &rhs) { 700 if (this != &rhs) { 701 // Lock both mutexes to make sure neither side changes anyone on us while 702 // the assignment occurs 703 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 704 705 m_process = rhs.m_process; 706 m_stop_id = rhs.m_stop_id; 707 m_threads.swap(rhs.m_threads); 708 m_selected_tid = rhs.m_selected_tid; 709 710 // Now we look for threads that we are done with and make sure to clear 711 // them up as much as possible so anyone with a shared pointer will still 712 // have a reference, but the thread won't be of much use. Using 713 // std::weak_ptr for all backward references (such as a thread to a 714 // process) will eventually solve this issue for us, but for now, we need 715 // to work around the issue 716 collection::iterator rhs_pos, rhs_end = rhs.m_threads.end(); 717 for (rhs_pos = rhs.m_threads.begin(); rhs_pos != rhs_end; ++rhs_pos) { 718 const lldb::tid_t tid = (*rhs_pos)->GetID(); 719 bool thread_is_alive = false; 720 const uint32_t num_threads = m_threads.size(); 721 for (uint32_t idx = 0; idx < num_threads; ++idx) { 722 ThreadSP backing_thread = m_threads[idx]->GetBackingThread(); 723 if (m_threads[idx]->GetID() == tid || 724 (backing_thread && backing_thread->GetID() == tid)) { 725 thread_is_alive = true; 726 break; 727 } 728 } 729 if (!thread_is_alive) 730 (*rhs_pos)->DestroyThread(); 731 } 732 } 733 } 734 735 void ThreadList::Flush() { 736 std::lock_guard<std::recursive_mutex> guard(GetMutex()); 737 collection::iterator pos, end = m_threads.end(); 738 for (pos = m_threads.begin(); pos != end; ++pos) 739 (*pos)->Flush(); 740 } 741 742 std::recursive_mutex &ThreadList::GetMutex() const { 743 return m_process->m_thread_mutex; 744 } 745 746 ThreadList::ExpressionExecutionThreadPusher::ExpressionExecutionThreadPusher( 747 lldb::ThreadSP thread_sp) 748 : m_thread_list(nullptr), m_tid(LLDB_INVALID_THREAD_ID) { 749 if (thread_sp) { 750 m_tid = thread_sp->GetID(); 751 m_thread_list = &thread_sp->GetProcess()->GetThreadList(); 752 m_thread_list->PushExpressionExecutionThread(m_tid); 753 } 754 } 755