LLDB mainline
ThreadList.cpp
Go to the documentation of this file.
1//===-- ThreadList.cpp ----------------------------------------------------===//
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 <cstdlib>
10
11#include <algorithm>
12
13#include "lldb/Target/Process.h"
15#include "lldb/Target/Thread.h"
20#include "lldb/Utility/Log.h"
21#include "lldb/Utility/State.h"
22
23using namespace lldb;
24using namespace lldb_private;
25
27 : ThreadCollection(), m_process(process), m_stop_id(0),
28 m_selected_tid(LLDB_INVALID_THREAD_ID) {}
29
31 : ThreadCollection(), m_process(rhs.m_process), m_stop_id(rhs.m_stop_id),
32 m_selected_tid() {
33 // Use the assignment operator since it uses the mutex
34 *this = rhs;
35}
36
38 if (this != &rhs) {
39 // We only allow assignments between thread lists describing the same
40 // process. Same process implies same mutex, which means it's enough to lock
41 // just the current object.
42 assert(&m_process == &rhs.m_process);
43 assert(&GetMutex() == &rhs.GetMutex());
44 std::lock_guard<std::recursive_mutex> guard(GetMutex());
45
46 m_stop_id = rhs.m_stop_id;
47 m_threads = rhs.m_threads;
49 }
50 return *this;
51}
52
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
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
70 m_expression_tid_stack.push_back(tid);
71}
72
74 assert(m_expression_tid_stack.back() == tid);
75 m_expression_tid_stack.pop_back();
76}
77
78uint32_t ThreadList::GetStopID() const { return m_stop_id; }
79
80void ThreadList::SetStopID(uint32_t stop_id) { m_stop_id = stop_id; }
81
82uint32_t ThreadList::GetSize(bool can_update) {
83 std::lock_guard<std::recursive_mutex> guard(GetMutex());
84
85 if (can_update)
87 return m_threads.size();
88}
89
90ThreadSP ThreadList::GetThreadAtIndex(uint32_t idx, bool can_update) {
91 std::lock_guard<std::recursive_mutex> guard(GetMutex());
92
93 if (can_update)
95
96 ThreadSP thread_sp;
97 if (idx < m_threads.size())
98 thread_sp = m_threads[idx];
99 return thread_sp;
100}
101
103 std::lock_guard<std::recursive_mutex> guard(GetMutex());
104
105 if (can_update)
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
121 std::lock_guard<std::recursive_mutex> guard(GetMutex());
122
123 if (can_update)
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
139 std::lock_guard<std::recursive_mutex> guard(GetMutex());
140
141 if (can_update)
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
158 bool can_update) {
159 std::lock_guard<std::recursive_mutex> guard(GetMutex());
160
161 if (can_update)
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
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
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
208ThreadSP ThreadList::FindThreadByIndexID(uint32_t index_id, bool can_update) {
209 std::lock_guard<std::recursive_mutex> guard(GetMutex());
210
211 if (can_update)
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
226 // Running events should never stop, obviously...
227
228 Log *log = GetLog(LLDBLog::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
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.
248 // If the thread didn't run but had work to do before declaring a public
249 // stop, then also include it.
250 // On Linux, if a thread-specific conditional breakpoint was hit, it won't
251 // necessarily be the thread that hit the breakpoint itself that
252 // evaluates the conditional expression, so the thread that hit the
253 // breakpoint could still be asked to stop, even though it hasn't been
254 // allowed to run since the previous stop.
255 if (thread_sp->GetTemporaryResumeState() != eStateSuspended ||
256 thread_sp->IsStillAtLastBreakpointHit()
257 || thread_sp->ShouldRunBeforePublicStop())
258 threads_copy.push_back(thread_sp);
259 }
260
261 // It is possible the threads we were allowing to run all exited and then
262 // maybe the user interrupted or something, then fall back on looking at
263 // all threads:
264
265 if (threads_copy.size() == 0)
266 threads_copy = m_threads;
267 }
268
269 collection::iterator pos, end = threads_copy.end();
270
271 if (log) {
272 log->PutCString("");
273 LLDB_LOGF(log,
274 "ThreadList::%s: %" PRIu64 " threads, %" PRIu64
275 " unsuspended threads",
276 __FUNCTION__, (uint64_t)m_threads.size(),
277 (uint64_t)threads_copy.size());
278 }
279
280 bool did_anybody_stop_for_a_reason = false;
281
282 // If the event is an Interrupt event, then we're going to stop no matter
283 // what. Otherwise, presume we won't stop.
284 bool should_stop = false;
286 LLDB_LOGF(
287 log, "ThreadList::%s handling interrupt event, should stop set to true",
288 __FUNCTION__);
289
290 should_stop = true;
291 }
292
293 // Now we run through all the threads and get their stop info's. We want to
294 // make sure to do this first before we start running the ShouldStop, because
295 // one thread's ShouldStop could destroy information (like deleting a thread
296 // specific breakpoint another thread had stopped at) which could lead us to
297 // compute the StopInfo incorrectly. We don't need to use it here, we just
298 // want to make sure it gets computed.
299
300 for (pos = threads_copy.begin(); pos != end; ++pos) {
301 ThreadSP thread_sp(*pos);
302 thread_sp->GetStopInfo();
303 }
304
305 // If a thread needs to finish some job that can be done just on this thread
306 // before broadcastion the stop, it will signal that by returning true for
307 // ShouldRunBeforePublicStop. This variable gathers the results from that.
308 bool a_thread_needs_to_run = false;
309 for (pos = threads_copy.begin(); pos != end; ++pos) {
310 ThreadSP thread_sp(*pos);
311
312 // We should never get a stop for which no thread had a stop reason, but
313 // sometimes we do see this - for instance when we first connect to a
314 // remote stub. In that case we should stop, since we can't figure out the
315 // right thing to do and stopping gives the user control over what to do in
316 // this instance.
317 //
318 // Note, this causes a problem when you have a thread specific breakpoint,
319 // and a bunch of threads hit the breakpoint, but not the thread which we
320 // are waiting for. All the threads that are not "supposed" to hit the
321 // breakpoint are marked as having no stop reason, which is right, they
322 // should not show a stop reason. But that triggers this code and causes
323 // 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
326 // going to trigger set did_anybody_stop_for_a_reason to true unless this
327 // is the first stop.
328 //
329 // If this becomes a problem, we'll have to have another StopReason like
330 // "StopInfoHidden" which will look invalid everywhere but at this check.
331
332 if (thread_sp->GetProcess()->GetStopID() > 1)
333 did_anybody_stop_for_a_reason = true;
334 else
335 did_anybody_stop_for_a_reason |= thread_sp->ThreadStoppedForAReason();
336
337 const bool thread_should_stop = thread_sp->ShouldStop(event_ptr);
338
339 if (thread_should_stop)
340 should_stop |= true;
341 else {
342 bool this_thread_forces_run = thread_sp->ShouldRunBeforePublicStop();
343 a_thread_needs_to_run |= this_thread_forces_run;
344 if (this_thread_forces_run)
345 LLDB_LOG(log,
346 "ThreadList::{0} thread: {1:x}, "
347 "says it needs to run before public stop.",
348 __FUNCTION__, thread_sp->GetID());
349 }
350 }
351
352 if (a_thread_needs_to_run) {
353 should_stop = false;
354 } else if (!should_stop && !did_anybody_stop_for_a_reason) {
355 should_stop = true;
356 LLDB_LOGF(log,
357 "ThreadList::%s we stopped but no threads had a stop reason, "
358 "overriding should_stop and stopping.",
359 __FUNCTION__);
360 }
361
362 LLDB_LOGF(log, "ThreadList::%s overall should_stop = %i", __FUNCTION__,
363 should_stop);
364
365 if (should_stop) {
366 for (pos = threads_copy.begin(); pos != end; ++pos) {
367 ThreadSP thread_sp(*pos);
368 thread_sp->WillStop();
369 }
370 }
371
372 return should_stop;
373}
374
376 std::lock_guard<std::recursive_mutex> guard(GetMutex());
377
378 Vote result = eVoteNoOpinion;
380 collection::iterator pos, end = m_threads.end();
381
382 Log *log = GetLog(LLDBLog::Step);
383
384 LLDB_LOGF(log, "ThreadList::%s %" PRIu64 " threads", __FUNCTION__,
385 (uint64_t)m_threads.size());
386
387 // Run through the threads and ask whether we should report this event. For
388 // stopping, a YES vote wins over everything. A NO vote wins over NO
389 // opinion. The exception is if a thread has work it needs to force before
390 // a public stop, which overrides everyone else's opinion:
391 for (pos = m_threads.begin(); pos != end; ++pos) {
392 ThreadSP thread_sp(*pos);
393 if (thread_sp->ShouldRunBeforePublicStop()) {
394 LLDB_LOG(log, "Thread {0:x} has private business to complete, overrode "
395 "the should report stop.", thread_sp->GetID());
396 result = eVoteNo;
397 break;
398 }
399
400 const Vote vote = thread_sp->ShouldReportStop(event_ptr);
401 switch (vote) {
402 case eVoteNoOpinion:
403 continue;
404
405 case eVoteYes:
406 result = eVoteYes;
407 break;
408
409 case eVoteNo:
410 if (result == eVoteNoOpinion) {
411 result = eVoteNo;
412 } else {
413 LLDB_LOG(log,
414 "Thread {0:x} voted {1}, but lost out because result was {2}",
415 thread_sp->GetID(), vote, result);
416 }
417 break;
418 }
419 }
420 LLDB_LOG(log, "Returning {0}", result);
421 return result;
422}
423
425 std::lock_guard<std::recursive_mutex> guard(GetMutex());
426
428 collection::iterator pos, end = m_threads.end();
429 for (pos = m_threads.begin(); pos != end; ++pos) {
430 ThreadSP thread_sp(*pos);
431 thread_sp->SetShouldReportStop(vote);
432 }
433}
434
436
437 std::lock_guard<std::recursive_mutex> guard(GetMutex());
438
439 Vote result = eVoteNoOpinion;
441 collection::iterator pos, end = m_threads.end();
442
443 // Run through the threads and ask whether we should report this event. The
444 // rule is NO vote wins over everything, a YES vote wins over no opinion.
445
446 Log *log = GetLog(LLDBLog::Step);
447
448 for (pos = m_threads.begin(); pos != end; ++pos) {
449 if ((*pos)->GetResumeState() != eStateSuspended) {
450 switch ((*pos)->ShouldReportRun(event_ptr)) {
451 case eVoteNoOpinion:
452 continue;
453 case eVoteYes:
454 if (result == eVoteNoOpinion)
455 result = eVoteYes;
456 break;
457 case eVoteNo:
458 LLDB_LOGF(log,
459 "ThreadList::ShouldReportRun() thread %d (0x%4.4" PRIx64
460 ") says don't report.",
461 (*pos)->GetIndexID(), (*pos)->GetID());
462 result = eVoteNo;
463 break;
464 }
465 }
466 }
467 return result;
468}
469
471 std::lock_guard<std::recursive_mutex> guard(GetMutex());
472 m_stop_id = 0;
473 m_threads.clear();
475}
476
478 std::lock_guard<std::recursive_mutex> guard(GetMutex());
479 const uint32_t num_threads = m_threads.size();
480 for (uint32_t idx = 0; idx < num_threads; ++idx) {
481 m_threads[idx]->DestroyThread();
482 }
483}
484
486 std::lock_guard<std::recursive_mutex> guard(GetMutex());
487
489
490 Log *log = GetLog(LLDBLog::Step);
491 if (log && log->GetVerbose())
492 LLDB_LOGF(log,
493 "Turning off notification of new threads while single stepping "
494 "a thread.");
495
496 collection::iterator pos, end = m_threads.end();
497 for (pos = m_threads.begin(); pos != end; ++pos)
498 (*pos)->RefreshStateAfterStop();
499}
500
502 // You don't need to update the thread list here, because only threads that
503 // you currently know about have any thread plans.
504 std::lock_guard<std::recursive_mutex> guard(GetMutex());
505
506 collection::iterator pos, end = m_threads.end();
507 for (pos = m_threads.begin(); pos != end; ++pos)
508 (*pos)->DiscardThreadPlans(true);
509}
510
512 // Run through the threads and perform their momentary actions. But we only
513 // do this for threads that are running, user suspended threads stay where
514 // they are.
515
516 std::lock_guard<std::recursive_mutex> guard(GetMutex());
518
519 collection::iterator pos, end = m_threads.end();
520
521 // See if any thread wants to run stopping others. If it does, then we won't
522 // setup the other threads for resume, since they aren't going to get a
523 // chance to run. This is necessary because the SetupForResume might add
524 // "StopOthers" plans which would then get to be part of the who-gets-to-run
525 // negotiation, but they're coming in after the fact, and the threads that
526 // are already set up should take priority.
527
528 bool wants_solo_run = false;
529
530 for (pos = m_threads.begin(); pos != end; ++pos) {
531 lldbassert((*pos)->GetCurrentPlan() &&
532 "thread should not have null thread plan");
533 if ((*pos)->GetResumeState() != eStateSuspended &&
534 (*pos)->GetCurrentPlan()->StopOthers()) {
535 if ((*pos)->IsOperatingSystemPluginThread() &&
536 !(*pos)->GetBackingThread())
537 continue;
538 wants_solo_run = true;
539 break;
540 }
541 }
542
543 if (wants_solo_run) {
544 Log *log = GetLog(LLDBLog::Step);
545 if (log && log->GetVerbose())
546 LLDB_LOGF(log, "Turning on notification of new threads while single "
547 "stepping a thread.");
549 } else {
550 Log *log = GetLog(LLDBLog::Step);
551 if (log && log->GetVerbose())
552 LLDB_LOGF(log, "Turning off notification of new threads while single "
553 "stepping a thread.");
555 }
556
557 // Give all the threads that are likely to run a last chance to set up their
558 // state before we negotiate who is actually going to get a chance to run...
559 // Don't set to resume suspended threads, and if any thread wanted to stop
560 // others, only call setup on the threads that request StopOthers...
561
562 for (pos = m_threads.begin(); pos != end; ++pos) {
563 if ((*pos)->GetResumeState() != eStateSuspended &&
564 (!wants_solo_run || (*pos)->GetCurrentPlan()->StopOthers())) {
565 if ((*pos)->IsOperatingSystemPluginThread() &&
566 !(*pos)->GetBackingThread())
567 continue;
568 (*pos)->SetupForResume();
569 }
570 }
571
572 // Now go through the threads and see if any thread wants to run just itself.
573 // if so then pick one and run it.
574
575 ThreadList run_me_only_list(m_process);
576
577 run_me_only_list.SetStopID(m_process.GetStopID());
578
579 // One or more threads might want to "Stop Others". We want to handle all
580 // those requests first. And if there is a thread that wanted to "resume
581 // before a public stop", let it get the first crack:
582 // There are two special kinds of thread that have priority for "StopOthers":
583 // a "ShouldRunBeforePublicStop thread, or the currently selected thread. If
584 // we find one satisfying that critereon, put it here.
585 ThreadSP stop_others_thread_sp;
586
587 for (pos = m_threads.begin(); pos != end; ++pos) {
588 ThreadSP thread_sp(*pos);
589 if (thread_sp->GetResumeState() != eStateSuspended &&
590 thread_sp->GetCurrentPlan()->StopOthers()) {
591 if ((*pos)->IsOperatingSystemPluginThread() &&
592 !(*pos)->GetBackingThread())
593 continue;
594
595 // You can't say "stop others" and also want yourself to be suspended.
596 assert(thread_sp->GetCurrentPlan()->RunState() != eStateSuspended);
597 run_me_only_list.AddThread(thread_sp);
598
599 if (thread_sp == GetSelectedThread())
600 stop_others_thread_sp = thread_sp;
601
602 if (thread_sp->ShouldRunBeforePublicStop()) {
603 // This takes precedence, so if we find one of these, service it:
604 stop_others_thread_sp = thread_sp;
605 break;
606 }
607 }
608 }
609
610 bool need_to_resume = true;
611
612 if (run_me_only_list.GetSize(false) == 0) {
613 // Everybody runs as they wish:
614 for (pos = m_threads.begin(); pos != end; ++pos) {
615 ThreadSP thread_sp(*pos);
616 StateType run_state;
617 if (thread_sp->GetResumeState() != eStateSuspended)
618 run_state = thread_sp->GetCurrentPlan()->RunState();
619 else
620 run_state = eStateSuspended;
621 if (!thread_sp->ShouldResume(run_state))
622 need_to_resume = false;
623 }
624 } else {
625 ThreadSP thread_to_run;
626
627 if (stop_others_thread_sp) {
628 thread_to_run = stop_others_thread_sp;
629 } else if (run_me_only_list.GetSize(false) == 1) {
630 thread_to_run = run_me_only_list.GetThreadAtIndex(0);
631 } else {
632 int random_thread =
633 (int)((run_me_only_list.GetSize(false) * (double)rand()) /
634 (RAND_MAX + 1.0));
635 thread_to_run = run_me_only_list.GetThreadAtIndex(random_thread);
636 }
637
638 for (pos = m_threads.begin(); pos != end; ++pos) {
639 ThreadSP thread_sp(*pos);
640 if (thread_sp == thread_to_run) {
641 // Note, a thread might be able to fulfil it's plan w/o actually
642 // resuming. An example of this is a step that changes the current
643 // inlined function depth w/o moving the PC. Check that here:
644 if (!thread_sp->ShouldResume(thread_sp->GetCurrentPlan()->RunState()))
645 need_to_resume = false;
646 } else
647 thread_sp->ShouldResume(eStateSuspended);
648 }
649 }
650
651 return need_to_resume;
652}
653
655 std::lock_guard<std::recursive_mutex> guard(GetMutex());
656 collection::iterator pos, end = m_threads.end();
657 for (pos = m_threads.begin(); pos != end; ++pos) {
658 // Don't clear out threads that aren't going to get a chance to run, rather
659 // leave their state for the next time around.
660 ThreadSP thread_sp(*pos);
661 if (thread_sp->GetTemporaryResumeState() != eStateSuspended)
662 thread_sp->DidResume();
663 }
664}
665
667 std::lock_guard<std::recursive_mutex> guard(GetMutex());
668 collection::iterator pos, end = m_threads.end();
669 for (pos = m_threads.begin(); pos != end; ++pos) {
670 // Notify threads that the process just stopped. Note, this currently
671 // assumes that all threads in the list stop when the process stops. In
672 // the future we will want to support a debugging model where some threads
673 // continue to run while others are stopped. We either need to handle that
674 // somehow here or create a special thread list containing only threads
675 // which will stop in the code that calls this method (currently
676 // Process::SetPrivateState).
677 ThreadSP thread_sp(*pos);
678 if (StateIsRunningState(thread_sp->GetState()))
679 thread_sp->DidStop();
680 }
681}
682
684 std::lock_guard<std::recursive_mutex> guard(GetMutex());
686 if (!thread_sp.get()) {
687 if (m_threads.size() == 0)
688 return thread_sp;
689 m_selected_tid = m_threads[0]->GetID();
690 thread_sp = m_threads[0];
691 }
692 return thread_sp;
693}
694
696 std::lock_guard<std::recursive_mutex> guard(GetMutex());
697 ThreadSP selected_thread_sp(FindThreadByID(tid));
698 if (selected_thread_sp) {
699 m_selected_tid = tid;
700 selected_thread_sp->SetDefaultFileAndLineToSelectedFrame();
701 } else
703
704 if (notify)
706
708}
709
710bool ThreadList::SetSelectedThreadByIndexID(uint32_t index_id, bool notify) {
711 std::lock_guard<std::recursive_mutex> guard(GetMutex());
712 ThreadSP selected_thread_sp(FindThreadByIndexID(index_id));
713 if (selected_thread_sp.get()) {
714 m_selected_tid = selected_thread_sp->GetID();
715 selected_thread_sp->SetDefaultFileAndLineToSelectedFrame();
716 } else
718
719 if (notify)
721
723}
724
726 ThreadSP selected_thread_sp(FindThreadByID(tid));
727 if (selected_thread_sp->EventTypeHasListeners(
729 auto data_sp =
730 std::make_shared<Thread::ThreadEventData>(selected_thread_sp);
731 selected_thread_sp->BroadcastEvent(Thread::eBroadcastBitThreadSelected,
732 data_sp);
733 }
734}
735
737 if (this != &rhs) {
738 // We only allow assignments between thread lists describing the same
739 // process. Same process implies same mutex, which means it's enough to lock
740 // just the current object.
741 assert(&m_process == &rhs.m_process);
742 assert(&GetMutex() == &rhs.GetMutex());
743 std::lock_guard<std::recursive_mutex> guard(GetMutex());
744
745 m_stop_id = rhs.m_stop_id;
746 m_threads.swap(rhs.m_threads);
748
749 // Now we look for threads that we are done with and make sure to clear
750 // them up as much as possible so anyone with a shared pointer will still
751 // have a reference, but the thread won't be of much use. Using
752 // std::weak_ptr for all backward references (such as a thread to a
753 // process) will eventually solve this issue for us, but for now, we need
754 // to work around the issue
755 collection::iterator rhs_pos, rhs_end = rhs.m_threads.end();
756 for (rhs_pos = rhs.m_threads.begin(); rhs_pos != rhs_end; ++rhs_pos) {
757 // If this thread has already been destroyed, we don't need to look for
758 // it to destroy it again.
759 if (!(*rhs_pos)->IsValid())
760 continue;
761
762 const lldb::tid_t tid = (*rhs_pos)->GetID();
763 bool thread_is_alive = false;
764 const uint32_t num_threads = m_threads.size();
765 for (uint32_t idx = 0; idx < num_threads; ++idx) {
766 ThreadSP backing_thread = m_threads[idx]->GetBackingThread();
767 if (m_threads[idx]->GetID() == tid ||
768 (backing_thread && backing_thread->GetID() == tid)) {
769 thread_is_alive = true;
770 break;
771 }
772 }
773 if (!thread_is_alive) {
774 (*rhs_pos)->DestroyThread();
775 }
776 }
777 }
778}
779
781 std::lock_guard<std::recursive_mutex> guard(GetMutex());
782 collection::iterator pos, end = m_threads.end();
783 for (pos = m_threads.begin(); pos != end; ++pos)
784 (*pos)->Flush();
785}
786
787std::recursive_mutex &ThreadList::GetMutex() const {
789}
790
792 lldb::ThreadSP thread_sp)
793 : m_thread_list(nullptr), m_tid(LLDB_INVALID_THREAD_ID) {
794 if (thread_sp) {
795 m_tid = thread_sp->GetID();
796 m_thread_list = &thread_sp->GetProcess()->GetThreadList();
798 }
799}
#define lldbassert(x)
Definition: LLDBAssert.h:15
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:359
#define LLDB_LOGF(log,...)
Definition: Log.h:366
void PutCString(const char *cstr)
Definition: Log.cpp:135
bool GetVerbose() const
Definition: Log.cpp:314
static bool GetInterruptedFromEvent(const Event *event_ptr)
Definition: Process.cpp:4421
A plug-in interface definition class for debugging a process.
Definition: Process.h:341
void UpdateThreadListIfNeeded()
Definition: Process.cpp:1176
std::recursive_mutex m_thread_mutex
Definition: Process.h:3074
virtual bool StopNoticingNewThreads()
Call this to turn off the stop & notice new threads mode.
Definition: Process.h:2462
uint32_t GetStopID() const
Definition: Process.h:1478
virtual bool StartNoticingNewThreads()
Call this to set the lldb in the mode where it breaks on new thread creations, and then auto-restarts...
Definition: Process.h:2455
std::vector< lldb::ThreadSP > collection
void AddThread(const lldb::ThreadSP &thread_sp)
ExpressionExecutionThreadPusher(ThreadList &thread_list, lldb::tid_t tid)
Definition: ThreadList.h:50
lldb::ThreadSP RemoveThreadByID(lldb::tid_t tid, bool can_update=true)
Definition: ThreadList.cpp:138
lldb::ThreadSP GetSelectedThread()
Definition: ThreadList.cpp:683
bool ShouldStop(Event *event_ptr)
Definition: ThreadList.cpp:225
Vote ShouldReportStop(Event *event_ptr)
Definition: ThreadList.cpp:375
uint32_t GetStopID() const
Definition: ThreadList.cpp:78
bool SetSelectedThreadByIndexID(uint32_t index_id, bool notify=false)
Definition: ThreadList.cpp:710
lldb::ThreadSP FindThreadByProtocolID(lldb::tid_t tid, bool can_update=true)
Definition: ThreadList.cpp:120
uint32_t GetSize(bool can_update=true)
Definition: ThreadList.cpp:82
void PopExpressionExecutionThread(lldb::tid_t tid)
Definition: ThreadList.cpp:73
bool SetSelectedThreadByID(lldb::tid_t tid, bool notify=false)
Definition: ThreadList.cpp:695
lldb::ThreadSP FindThreadByIndexID(uint32_t index_id, bool can_update=true)
Definition: ThreadList.cpp:208
Vote ShouldReportRun(Event *event_ptr)
Definition: ThreadList.cpp:435
void SetStopID(uint32_t stop_id)
Definition: ThreadList.cpp:80
lldb::ThreadSP GetThreadSPForThreadPtr(Thread *thread_ptr)
Definition: ThreadList.cpp:177
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
Definition: ThreadList.cpp:90
uint32_t m_stop_id
The process stop ID that this thread list is valid for.
Definition: ThreadList.h:150
std::recursive_mutex & GetMutex() const override
Definition: ThreadList.cpp:787
lldb::ThreadSP FindThreadByID(lldb::tid_t tid, bool can_update=true)
Definition: ThreadList.cpp:102
lldb::ThreadSP GetExpressionExecutionThread()
Definition: ThreadList.cpp:59
const ThreadList & operator=(const ThreadList &rhs)
Precondition: both thread lists must be belong to the same process.
Definition: ThreadList.cpp:37
void Update(ThreadList &rhs)
Precondition: both thread lists must be belong to the same process.
Definition: ThreadList.cpp:736
lldb::ThreadSP GetBackingThread(const lldb::ThreadSP &real_thread)
Definition: ThreadList.cpp:194
bool WillResume()
The thread list asks tells all the threads it is about to resume.
Definition: ThreadList.cpp:511
void PushExpressionExecutionThread(lldb::tid_t tid)
Definition: ThreadList.cpp:69
void SetShouldReportStop(Vote vote)
Definition: ThreadList.cpp:424
lldb::tid_t m_selected_tid
For targets that need the notion of a current thread.
Definition: ThreadList.h:152
void NotifySelectedThreadChanged(lldb::tid_t tid)
Definition: ThreadList.cpp:725
lldb::ThreadSP RemoveThreadByProtocolID(lldb::tid_t tid, bool can_update=true)
Definition: ThreadList.cpp:157
Process & m_process
The process that manages this thread list.
Definition: ThreadList.h:148
std::vector< lldb::tid_t > m_expression_tid_stack
Definition: ThreadList.h:153
@ eBroadcastBitThreadSelected
Definition: Thread.h:75
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:90
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:331
bool StateIsRunningState(lldb::StateType state)
Check if a state represents a state where the process or thread is running.
Definition: State.cpp:68
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:444
StateType
Process and Thread States.
@ eStateSuspended
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
uint64_t tid_t
Definition: lldb-types.h:84