1 //===-- ThreadList.cpp ------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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"
22 using namespace lldb_private;
24 ThreadList::ThreadList (Process *process) :
28 m_selected_tid (LLDB_INVALID_THREAD_ID)
32 ThreadList::ThreadList (const ThreadList &rhs) :
33 m_process (rhs.m_process),
34 m_stop_id (rhs.m_stop_id),
38 // Use the assignment operator since it uses the mutex
43 ThreadList::operator = (const ThreadList& rhs)
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;
59 ThreadList::~ThreadList()
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.
69 ThreadList::GetStopID () const
75 ThreadList::SetStopID (uint32_t stop_id)
82 ThreadList::AddThread (const ThreadSP &thread_sp)
84 Mutex::Locker locker(GetMutex());
85 m_threads.push_back(thread_sp);
89 ThreadList::InsertThread (const lldb::ThreadSP &thread_sp, uint32_t idx)
91 Mutex::Locker locker(GetMutex());
92 if (idx < m_threads.size())
93 m_threads.insert(m_threads.begin() + idx, thread_sp);
95 m_threads.push_back (thread_sp);
100 ThreadList::GetSize (bool can_update)
102 Mutex::Locker locker(GetMutex());
104 m_process->UpdateThreadListIfNeeded();
105 return m_threads.size();
109 ThreadList::GetThreadAtIndex (uint32_t idx, bool can_update)
111 Mutex::Locker locker(GetMutex());
113 m_process->UpdateThreadListIfNeeded();
116 if (idx < m_threads.size())
117 thread_sp = m_threads[idx];
122 ThreadList::FindThreadByID (lldb::tid_t tid, bool can_update)
124 Mutex::Locker locker(GetMutex());
127 m_process->UpdateThreadListIfNeeded();
131 const uint32_t num_threads = m_threads.size();
132 for (idx = 0; idx < num_threads; ++idx)
134 if (m_threads[idx]->GetID() == tid)
136 thread_sp = m_threads[idx];
144 ThreadList::FindThreadByProtocolID (lldb::tid_t tid, bool can_update)
146 Mutex::Locker locker(GetMutex());
149 m_process->UpdateThreadListIfNeeded();
153 const uint32_t num_threads = m_threads.size();
154 for (idx = 0; idx < num_threads; ++idx)
156 if (m_threads[idx]->GetProtocolID() == tid)
158 thread_sp = m_threads[idx];
167 ThreadList::RemoveThreadByID (lldb::tid_t tid, bool can_update)
169 Mutex::Locker locker(GetMutex());
172 m_process->UpdateThreadListIfNeeded();
176 const uint32_t num_threads = m_threads.size();
177 for (idx = 0; idx < num_threads; ++idx)
179 if (m_threads[idx]->GetID() == tid)
181 thread_sp = m_threads[idx];
182 m_threads.erase(m_threads.begin()+idx);
190 ThreadList::RemoveThreadByProtocolID (lldb::tid_t tid, bool can_update)
192 Mutex::Locker locker(GetMutex());
195 m_process->UpdateThreadListIfNeeded();
199 const uint32_t num_threads = m_threads.size();
200 for (idx = 0; idx < num_threads; ++idx)
202 if (m_threads[idx]->GetProtocolID() == tid)
204 thread_sp = m_threads[idx];
205 m_threads.erase(m_threads.begin()+idx);
213 ThreadList::GetThreadSPForThreadPtr (Thread *thread_ptr)
218 Mutex::Locker locker(GetMutex());
221 const uint32_t num_threads = m_threads.size();
222 for (idx = 0; idx < num_threads; ++idx)
224 if (m_threads[idx].get() == thread_ptr)
226 thread_sp = m_threads[idx];
237 ThreadList::FindThreadByIndexID (uint32_t index_id, bool can_update)
239 Mutex::Locker locker(GetMutex());
242 m_process->UpdateThreadListIfNeeded();
245 const uint32_t num_threads = m_threads.size();
246 for (uint32_t idx = 0; idx < num_threads; ++idx)
248 if (m_threads[idx]->GetIndexID() == index_id)
250 thread_sp = m_threads[idx];
258 ThreadList::ShouldStop (Event *event_ptr)
260 // Running events should never stop, obviously...
262 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
264 // The ShouldStop method of the threads can do a whole lot of work,
265 // running breakpoint commands & conditions, etc. 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.
272 collection threads_copy;
275 Mutex::Locker locker(GetMutex());
277 m_process->UpdateThreadListIfNeeded();
278 threads_copy = m_threads;
281 collection::iterator pos, end = threads_copy.end();
286 log->Printf ("ThreadList::%s: %" PRIu64 " threads", __FUNCTION__, (uint64_t)m_threads.size());
289 bool did_anybody_stop_for_a_reason = false;
290 bool should_stop = false;
292 // Now we run through all the threads and get their stop info's. We want to make sure to do this first before
293 // we start running the ShouldStop, because one thread's ShouldStop could destroy information (like deleting a
294 // thread specific breakpoint another thread had stopped at) which could lead us to compute the StopInfo incorrectly.
295 // We don't need to use it here, we just want to make sure it gets computed.
297 for (pos = threads_copy.begin(); pos != end; ++pos)
299 ThreadSP thread_sp(*pos);
300 thread_sp->GetStopInfo();
303 for (pos = threads_copy.begin(); pos != end; ++pos)
305 ThreadSP thread_sp(*pos);
307 // We should never get a stop for which no thread had a stop reason, but sometimes we do see this -
308 // for instance when we first connect to a remote stub. In that case we should stop, since we can't figure out
309 // the right thing to do and stopping gives the user control over what to do in this instance.
311 // Note, this causes a problem when you have a thread specific breakpoint, and a bunch of threads hit the breakpoint,
312 // but not the thread which we are waiting for. All the threads that are not "supposed" to hit the breakpoint
313 // are marked as having no stop reason, which is right, they should not show a stop reason. But that triggers this
314 // code and causes us to stop seemingly for no reason.
316 // 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
317 // to true unless this is the first stop.
319 // If this becomes a problem, we'll have to have another StopReason like "StopInfoHidden" which will look invalid
320 // everywhere but at this check.
322 if (thread_sp->GetProcess()->GetStopID() > 1)
323 did_anybody_stop_for_a_reason = true;
325 did_anybody_stop_for_a_reason |= thread_sp->ThreadStoppedForAReason();
327 const bool thread_should_stop = thread_sp->ShouldStop(event_ptr);
328 if (thread_should_stop)
332 if (!should_stop && !did_anybody_stop_for_a_reason)
336 log->Printf ("ThreadList::%s we stopped but no threads had a stop reason, overriding should_stop and stopping.", __FUNCTION__);
340 log->Printf ("ThreadList::%s overall should_stop = %i", __FUNCTION__, should_stop);
344 for (pos = threads_copy.begin(); pos != end; ++pos)
346 ThreadSP thread_sp(*pos);
347 thread_sp->WillStop ();
355 ThreadList::ShouldReportStop (Event *event_ptr)
357 Mutex::Locker locker(GetMutex());
359 Vote result = eVoteNoOpinion;
360 m_process->UpdateThreadListIfNeeded();
361 collection::iterator pos, end = m_threads.end();
363 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
366 log->Printf ("ThreadList::%s %" PRIu64 " threads", __FUNCTION__, (uint64_t)m_threads.size());
368 // Run through the threads and ask whether we should report this event.
369 // For stopping, a YES vote wins over everything. A NO vote wins over NO opinion.
370 for (pos = m_threads.begin(); pos != end; ++pos)
372 ThreadSP thread_sp(*pos);
373 const Vote vote = thread_sp->ShouldReportStop (event_ptr);
384 if (result == eVoteNoOpinion)
391 log->Printf ("ThreadList::%s thread 0x%4.4" PRIx64 ": voted %s, but lost out because result was %s",
394 GetVoteAsCString (vote),
395 GetVoteAsCString (result));
401 log->Printf ("ThreadList::%s returning %s", __FUNCTION__, GetVoteAsCString (result));
406 ThreadList::SetShouldReportStop (Vote vote)
408 Mutex::Locker locker(GetMutex());
409 m_process->UpdateThreadListIfNeeded();
410 collection::iterator pos, end = m_threads.end();
411 for (pos = m_threads.begin(); pos != end; ++pos)
413 ThreadSP thread_sp(*pos);
414 thread_sp->SetShouldReportStop (vote);
419 ThreadList::ShouldReportRun (Event *event_ptr)
422 Mutex::Locker locker(GetMutex());
424 Vote result = eVoteNoOpinion;
425 m_process->UpdateThreadListIfNeeded();
426 collection::iterator pos, end = m_threads.end();
428 // Run through the threads and ask whether we should report this event.
429 // The rule is NO vote wins over everything, a YES vote wins over no opinion.
431 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
433 for (pos = m_threads.begin(); pos != end; ++pos)
435 if ((*pos)->GetResumeState () != eStateSuspended)
437 switch ((*pos)->ShouldReportRun (event_ptr))
442 if (result == eVoteNoOpinion)
447 log->Printf ("ThreadList::ShouldReportRun() thread %d (0x%4.4" PRIx64 ") says don't report.",
448 (*pos)->GetIndexID(),
461 Mutex::Locker locker(GetMutex());
464 m_selected_tid = LLDB_INVALID_THREAD_ID;
468 ThreadList::Destroy()
470 Mutex::Locker locker(GetMutex());
471 const uint32_t num_threads = m_threads.size();
472 for (uint32_t idx = 0; idx < num_threads; ++idx)
474 m_threads[idx]->DestroyThread();
479 ThreadList::RefreshStateAfterStop ()
481 Mutex::Locker locker(GetMutex());
483 m_process->UpdateThreadListIfNeeded();
485 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
486 if (log && log->GetVerbose())
487 log->Printf ("Turning off notification of new threads while single stepping a thread.");
489 collection::iterator pos, end = m_threads.end();
490 for (pos = m_threads.begin(); pos != end; ++pos)
491 (*pos)->RefreshStateAfterStop ();
495 ThreadList::DiscardThreadPlans ()
497 // You don't need to update the thread list here, because only threads
498 // that you currently know about have any thread plans.
499 Mutex::Locker locker(GetMutex());
501 collection::iterator pos, end = m_threads.end();
502 for (pos = m_threads.begin(); pos != end; ++pos)
503 (*pos)->DiscardThreadPlans (true);
508 ThreadList::WillResume ()
510 // Run through the threads and perform their momentary actions.
511 // But we only do this for threads that are running, user suspended
512 // threads stay where they are.
514 Mutex::Locker locker(GetMutex());
515 m_process->UpdateThreadListIfNeeded();
517 collection::iterator pos, end = m_threads.end();
519 // See if any thread wants to run stopping others. If it does, then we won't
520 // setup the other threads for resume, since they aren't going to get a chance
521 // to run. This is necessary because the SetupForResume might add "StopOthers"
522 // plans which would then get to be part of the who-gets-to-run negotiation, but
523 // they're coming in after the fact, and the threads that are already set up should
526 bool wants_solo_run = false;
528 for (pos = m_threads.begin(); pos != end; ++pos)
530 if ((*pos)->GetResumeState() != eStateSuspended &&
531 (*pos)->GetCurrentPlan()->StopOthers())
533 if ((*pos)->IsOperatingSystemPluginThread() && !(*pos)->GetBackingThread())
535 wants_solo_run = true;
542 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
543 if (log && log->GetVerbose())
544 log->Printf ("Turning on notification of new threads while single stepping a thread.");
545 m_process->StartNoticingNewThreads();
549 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
550 if (log && log->GetVerbose())
551 log->Printf ("Turning off notification of new threads while single stepping a thread.");
552 m_process->StopNoticingNewThreads();
555 // Give all the threads that are likely to run a last chance to set up their state before we
556 // negotiate who is actually going to get a chance to run...
557 // Don't set to resume suspended threads, and if any thread wanted to stop others, only
558 // call setup on the threads that request StopOthers...
560 for (pos = m_threads.begin(); pos != end; ++pos)
562 if ((*pos)->GetResumeState() != eStateSuspended
563 && (!wants_solo_run || (*pos)->GetCurrentPlan()->StopOthers()))
565 if ((*pos)->IsOperatingSystemPluginThread() && !(*pos)->GetBackingThread())
567 (*pos)->SetupForResume ();
571 // Now go through the threads and see if any thread wants to run just itself.
572 // if so then pick one and run it.
574 ThreadList run_me_only_list (m_process);
576 run_me_only_list.SetStopID(m_process->GetStopID());
578 bool run_only_current_thread = false;
580 for (pos = m_threads.begin(); pos != end; ++pos)
582 ThreadSP thread_sp(*pos);
583 if (thread_sp->GetResumeState() != eStateSuspended &&
584 thread_sp->GetCurrentPlan()->StopOthers())
586 if ((*pos)->IsOperatingSystemPluginThread() && !(*pos)->GetBackingThread())
589 // You can't say "stop others" and also want yourself to be suspended.
590 assert (thread_sp->GetCurrentPlan()->RunState() != eStateSuspended);
592 if (thread_sp == GetSelectedThread())
594 run_only_current_thread = true;
595 run_me_only_list.Clear();
596 run_me_only_list.AddThread (thread_sp);
600 run_me_only_list.AddThread (thread_sp);
605 bool need_to_resume = true;
607 if (run_me_only_list.GetSize (false) == 0)
609 // Everybody runs as they wish:
610 for (pos = m_threads.begin(); pos != end; ++pos)
612 ThreadSP thread_sp(*pos);
614 if (thread_sp->GetResumeState() != eStateSuspended)
615 run_state = thread_sp->GetCurrentPlan()->RunState();
617 run_state = eStateSuspended;
618 if (!thread_sp->ShouldResume(run_state))
619 need_to_resume = false;
624 ThreadSP thread_to_run;
626 if (run_only_current_thread)
628 thread_to_run = GetSelectedThread();
630 else if (run_me_only_list.GetSize (false) == 1)
632 thread_to_run = run_me_only_list.GetThreadAtIndex (0);
636 int random_thread = (int)
637 ((run_me_only_list.GetSize (false) * (double) rand ()) / (RAND_MAX + 1.0));
638 thread_to_run = run_me_only_list.GetThreadAtIndex (random_thread);
641 for (pos = m_threads.begin(); pos != end; ++pos)
643 ThreadSP thread_sp(*pos);
644 if (thread_sp == thread_to_run)
646 if (!thread_sp->ShouldResume(thread_sp->GetCurrentPlan()->RunState()))
647 need_to_resume = false;
650 thread_sp->ShouldResume (eStateSuspended);
654 return need_to_resume;
658 ThreadList::DidResume ()
660 Mutex::Locker locker(GetMutex());
661 collection::iterator pos, end = m_threads.end();
662 for (pos = m_threads.begin(); pos != end; ++pos)
664 // Don't clear out threads that aren't going to get a chance to run, rather
665 // leave their state for the next time around.
666 ThreadSP thread_sp(*pos);
667 if (thread_sp->GetResumeState() != eStateSuspended)
668 thread_sp->DidResume ();
673 ThreadList::DidStop ()
675 Mutex::Locker locker(GetMutex());
676 collection::iterator pos, end = m_threads.end();
677 for (pos = m_threads.begin(); pos != end; ++pos)
679 // Notify threads that the process just stopped.
680 // Note, this currently assumes that all threads in the list
681 // stop when the process stops. In the future we will want to support
682 // a debugging model where some threads continue to run while others
683 // are stopped. We either need to handle that somehow here or
684 // create a special thread list containing only threads which will
685 // stop in the code that calls this method (currently
686 // Process::SetPrivateState).
687 ThreadSP thread_sp(*pos);
688 if (StateIsRunningState(thread_sp->GetState()))
689 thread_sp->DidStop ();
694 ThreadList::GetSelectedThread ()
696 Mutex::Locker locker(GetMutex());
697 ThreadSP thread_sp = FindThreadByID(m_selected_tid);
698 if (!thread_sp.get())
700 if (m_threads.size() == 0)
702 m_selected_tid = m_threads[0]->GetID();
703 thread_sp = m_threads[0];
709 ThreadList::SetSelectedThreadByID (lldb::tid_t tid, bool notify)
711 Mutex::Locker locker(GetMutex());
712 ThreadSP selected_thread_sp(FindThreadByID(tid));
713 if (selected_thread_sp)
715 m_selected_tid = tid;
716 selected_thread_sp->SetDefaultFileAndLineToSelectedFrame();
719 m_selected_tid = LLDB_INVALID_THREAD_ID;
722 NotifySelectedThreadChanged(m_selected_tid);
724 return m_selected_tid != LLDB_INVALID_THREAD_ID;
728 ThreadList::SetSelectedThreadByIndexID (uint32_t index_id, bool notify)
730 Mutex::Locker locker(GetMutex());
731 ThreadSP selected_thread_sp (FindThreadByIndexID(index_id));
732 if (selected_thread_sp.get())
734 m_selected_tid = selected_thread_sp->GetID();
735 selected_thread_sp->SetDefaultFileAndLineToSelectedFrame();
738 m_selected_tid = LLDB_INVALID_THREAD_ID;
741 NotifySelectedThreadChanged(m_selected_tid);
743 return m_selected_tid != LLDB_INVALID_THREAD_ID;
747 ThreadList::NotifySelectedThreadChanged (lldb::tid_t tid)
749 ThreadSP selected_thread_sp (FindThreadByID(tid));
750 if (selected_thread_sp->EventTypeHasListeners(Thread::eBroadcastBitThreadSelected))
751 selected_thread_sp->BroadcastEvent(Thread::eBroadcastBitThreadSelected,
752 new Thread::ThreadEventData(selected_thread_sp));
756 ThreadList::Update (ThreadList &rhs)
760 // Lock both mutexes to make sure neither side changes anyone on us
761 // while the assignement occurs
762 Mutex::Locker locker(GetMutex());
763 m_process = rhs.m_process;
764 m_stop_id = rhs.m_stop_id;
765 m_threads.swap(rhs.m_threads);
766 m_selected_tid = rhs.m_selected_tid;
769 // Now we look for threads that we are done with and
770 // make sure to clear them up as much as possible so
771 // anyone with a shared pointer will still have a reference,
772 // but the thread won't be of much use. Using std::weak_ptr
773 // for all backward references (such as a thread to a process)
774 // will eventually solve this issue for us, but for now, we
775 // need to work around the issue
776 collection::iterator rhs_pos, rhs_end = rhs.m_threads.end();
777 for (rhs_pos = rhs.m_threads.begin(); rhs_pos != rhs_end; ++rhs_pos)
779 const lldb::tid_t tid = (*rhs_pos)->GetID();
780 bool thread_is_alive = false;
781 const uint32_t num_threads = m_threads.size();
782 for (uint32_t idx = 0; idx < num_threads; ++idx)
784 if (m_threads[idx]->GetID() == tid)
786 thread_is_alive = true;
790 if (!thread_is_alive)
791 (*rhs_pos)->DestroyThread();
799 Mutex::Locker locker(GetMutex());
800 collection::iterator pos, end = m_threads.end();
801 for (pos = m_threads.begin(); pos != end; ++pos)
806 ThreadList::GetMutex ()
808 return m_process->m_thread_mutex;