LLDB  mainline
Thread.cpp
Go to the documentation of this file.
1 //===-- Thread.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 "lldb/Target/Thread.h"
13 #include "lldb/Core/Debugger.h"
14 #include "lldb/Core/FormatEntity.h"
15 #include "lldb/Core/Module.h"
16 #include "lldb/Core/ValueObject.h"
17 #include "lldb/Host/Host.h"
21 #include "lldb/Symbol/Function.h"
22 #include "lldb/Target/ABI.h"
26 #include "lldb/Target/Process.h"
29 #include "lldb/Target/StopInfo.h"
31 #include "lldb/Target/Target.h"
32 #include "lldb/Target/ThreadPlan.h"
44 #include "lldb/Target/ThreadSpec.h"
45 #include "lldb/Target/Unwind.h"
46 #include "lldb/Utility/Log.h"
48 #include "lldb/Utility/State.h"
49 #include "lldb/Utility/Stream.h"
51 #include "lldb/lldb-enumerations.h"
52 
53 #include <memory>
54 
55 using namespace lldb;
56 using namespace lldb_private;
57 
59  // NOTE: intentional leak so we don't crash if global destructor chain gets
60  // called as other threads still use the result of this function
61  static ThreadPropertiesSP *g_settings_sp_ptr =
62  new ThreadPropertiesSP(new ThreadProperties(true));
63  return *g_settings_sp_ptr;
64 }
65 
66 static constexpr PropertyDefinition g_properties[] = {
67  {"step-in-avoid-nodebug", OptionValue::eTypeBoolean, true, true, nullptr,
68  {},
69  "If true, step-in will not stop in functions with no debug information."},
70  {"step-out-avoid-nodebug", OptionValue::eTypeBoolean, true, false, nullptr,
71  {}, "If true, when step-in/step-out/step-over leave the current frame, "
72  "they will continue to step out till they come to a function with "
73  "debug information. Passing a frame argument to step-out will "
74  "override this option."},
75  {"step-avoid-regexp", OptionValue::eTypeRegex, true, 0, "^std::", {},
76  "A regular expression defining functions step-in won't stop in."},
77  {"step-avoid-libraries", OptionValue::eTypeFileSpecList, true, 0, nullptr,
78  {}, "A list of libraries that source stepping won't stop in."},
79  {"trace-thread", OptionValue::eTypeBoolean, false, false, nullptr, {},
80  "If true, this thread will single-step and log execution."},
81  {"max-backtrace-depth", OptionValue::eTypeUInt64, false, 300000, nullptr,
82  {}, "Maximum number of frames to backtrace."}};
83 
84 enum {
91 };
92 
94 public:
96  : OptionValueProperties(name) {}
97 
98  // This constructor is used when creating ThreadOptionValueProperties when it
99  // is part of a new lldb_private::Thread instance. It will copy all current
100  // global property values as needed
102  : OptionValueProperties(*global_properties->GetValueProperties()) {}
103 
105  bool will_modify,
106  uint32_t idx) const override {
107  // When getting the value for a key from the thread options, we will always
108  // try and grab the setting from the current thread if there is one. Else
109  // we just use the one from this instance.
110  if (exe_ctx) {
111  Thread *thread = exe_ctx->GetThreadPtr();
112  if (thread) {
113  ThreadOptionValueProperties *instance_properties =
114  static_cast<ThreadOptionValueProperties *>(
115  thread->GetValueProperties().get());
116  if (this != instance_properties)
117  return instance_properties->ProtectedGetPropertyAtIndex(idx);
118  }
119  }
120  return ProtectedGetPropertyAtIndex(idx);
121  }
122 };
123 
124 ThreadProperties::ThreadProperties(bool is_global) : Properties() {
125  if (is_global) {
127  std::make_shared<ThreadOptionValueProperties>(ConstString("thread"));
128  m_collection_sp->Initialize(g_properties);
129  } else
130  m_collection_sp = std::make_shared<ThreadOptionValueProperties>(
132 }
133 
135 
137  const uint32_t idx = ePropertyStepAvoidRegex;
138  return m_collection_sp->GetPropertyAtIndexAsOptionValueRegex(nullptr, idx);
139 }
140 
143  const OptionValueFileSpecList *option_value =
144  m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr,
145  false, idx);
146  assert(option_value);
147  return option_value->GetCurrentValue();
148 }
149 
152  return m_collection_sp->GetPropertyAtIndexAsBoolean(
153  nullptr, idx, g_properties[idx].default_uint_value != 0);
154 }
155 
158  return m_collection_sp->GetPropertyAtIndexAsBoolean(
159  nullptr, idx, g_properties[idx].default_uint_value != 0);
160 }
161 
164  return m_collection_sp->GetPropertyAtIndexAsBoolean(
165  nullptr, idx, g_properties[idx].default_uint_value != 0);
166 }
167 
170  return m_collection_sp->GetPropertyAtIndexAsUInt64(
171  nullptr, idx, g_properties[idx].default_uint_value != 0);
172 }
173 
174 // Thread Event Data
175 
177  static ConstString g_flavor("Thread::ThreadEventData");
178  return g_flavor;
179 }
180 
181 Thread::ThreadEventData::ThreadEventData(const lldb::ThreadSP thread_sp)
182  : m_thread_sp(thread_sp), m_stack_id() {}
183 
184 Thread::ThreadEventData::ThreadEventData(const lldb::ThreadSP thread_sp,
185  const StackID &stack_id)
186  : m_thread_sp(thread_sp), m_stack_id(stack_id) {}
187 
188 Thread::ThreadEventData::ThreadEventData() : m_thread_sp(), m_stack_id() {}
189 
191 
193 
196  if (event_ptr) {
197  const EventData *event_data = event_ptr->GetData();
198  if (event_data &&
199  event_data->GetFlavor() == ThreadEventData::GetFlavorString())
200  return static_cast<const ThreadEventData *>(event_ptr->GetData());
201  }
202  return nullptr;
203 }
204 
206  ThreadSP thread_sp;
207  const ThreadEventData *event_data = GetEventDataFromEvent(event_ptr);
208  if (event_data)
209  thread_sp = event_data->GetThread();
210  return thread_sp;
211 }
212 
214  StackID stack_id;
215  const ThreadEventData *event_data = GetEventDataFromEvent(event_ptr);
216  if (event_data)
217  stack_id = event_data->GetStackID();
218  return stack_id;
219 }
220 
221 StackFrameSP
223  const ThreadEventData *event_data = GetEventDataFromEvent(event_ptr);
224  StackFrameSP frame_sp;
225  if (event_data) {
226  ThreadSP thread_sp = event_data->GetThread();
227  if (thread_sp) {
228  frame_sp = thread_sp->GetStackFrameList()->GetFrameWithStackID(
229  event_data->GetStackID());
230  }
231  }
232  return frame_sp;
233 }
234 
235 // Thread class
236 
238  static ConstString class_name("lldb.thread");
239  return class_name;
240 }
241 
242 Thread::Thread(Process &process, lldb::tid_t tid, bool use_invalid_index_id)
243  : ThreadProperties(false), UserID(tid),
244  Broadcaster(process.GetTarget().GetDebugger().GetBroadcasterManager(),
245  Thread::GetStaticBroadcasterClass().AsCString()),
246  m_process_wp(process.shared_from_this()), m_stop_info_sp(),
248  m_index_id(use_invalid_index_id ? LLDB_INVALID_INDEX32
249  : process.GetNextThreadIndexID(tid)),
257  m_extended_info_fetched(false), m_extended_info() {
259  if (log)
260  log->Printf("%p Thread::Thread(tid = 0x%4.4" PRIx64 ")",
261  static_cast<void *>(this), GetID());
262 
264 
265  QueueFundamentalPlan(true);
266 }
267 
270  if (log)
271  log->Printf("%p Thread::~Thread(tid = 0x%4.4" PRIx64 ")",
272  static_cast<void *>(this), GetID());
273  /// If you hit this assert, it means your derived class forgot to call
274  /// DoDestroy in its destructor.
275  assert(m_destroy_called);
276 }
277 
279  // Tell any plans on the plan stacks that the thread is being destroyed since
280  // any plans that have a thread go away in the middle of might need to do
281  // cleanup, or in some cases NOT do cleanup...
282  for (auto plan : m_plan_stack)
283  plan->ThreadDestroyed();
284 
285  for (auto plan : m_discarded_plan_stack)
286  plan->ThreadDestroyed();
287 
288  for (auto plan : m_completed_plan_stack)
289  plan->ThreadDestroyed();
290 
291  m_destroy_called = true;
292  m_plan_stack.clear();
293  m_discarded_plan_stack.clear();
294  m_completed_plan_stack.clear();
295 
296  // Push a ThreadPlanNull on the plan stack. That way we can continue
297  // assuming that the plan stack is never empty, but if somebody errantly asks
298  // questions of a destroyed thread without checking first whether it is
299  // destroyed, they won't crash.
300  ThreadPlanSP null_plan_sp(new ThreadPlanNull(*this));
301  m_plan_stack.push_back(null_plan_sp);
302 
303  m_stop_info_sp.reset();
304  m_reg_context_sp.reset();
305  m_unwinder_up.reset();
306  std::lock_guard<std::recursive_mutex> guard(m_frame_mutex);
307  m_curr_frames_sp.reset();
308  m_prev_frames_sp.reset();
309 }
310 
311 void Thread::BroadcastSelectedFrameChange(StackID &new_frame_id) {
314  new ThreadEventData(this->shared_from_this(), new_frame_id));
315 }
316 
317 lldb::StackFrameSP Thread::GetSelectedFrame() {
318  StackFrameListSP stack_frame_list_sp(GetStackFrameList());
319  StackFrameSP frame_sp = stack_frame_list_sp->GetFrameAtIndex(
320  stack_frame_list_sp->GetSelectedFrameIndex());
321  FunctionOptimizationWarning(frame_sp.get());
322  return frame_sp;
323 }
324 
326  bool broadcast) {
327  uint32_t ret_value = GetStackFrameList()->SetSelectedFrame(frame);
328  if (broadcast)
329  BroadcastSelectedFrameChange(frame->GetStackID());
331  return ret_value;
332 }
333 
334 bool Thread::SetSelectedFrameByIndex(uint32_t frame_idx, bool broadcast) {
335  StackFrameSP frame_sp(GetStackFrameList()->GetFrameAtIndex(frame_idx));
336  if (frame_sp) {
337  GetStackFrameList()->SetSelectedFrame(frame_sp.get());
338  if (broadcast)
339  BroadcastSelectedFrameChange(frame_sp->GetStackID());
340  FunctionOptimizationWarning(frame_sp.get());
341  return true;
342  } else
343  return false;
344 }
345 
347  Stream &output_stream) {
348  const bool broadcast = true;
349  bool success = SetSelectedFrameByIndex(frame_idx, broadcast);
350  if (success) {
351  StackFrameSP frame_sp = GetSelectedFrame();
352  if (frame_sp) {
353  bool already_shown = false;
354  SymbolContext frame_sc(
355  frame_sp->GetSymbolContext(eSymbolContextLineEntry));
356  if (GetProcess()->GetTarget().GetDebugger().GetUseExternalEditor() &&
357  frame_sc.line_entry.file && frame_sc.line_entry.line != 0) {
358  already_shown = Host::OpenFileInExternalEditor(
359  frame_sc.line_entry.file, frame_sc.line_entry.line);
360  }
361 
362  bool show_frame_info = true;
363  bool show_source = !already_shown;
364  FunctionOptimizationWarning(frame_sp.get());
365  return frame_sp->GetStatus(output_stream, show_frame_info, show_source);
366  }
367  return false;
368  } else
369  return false;
370 }
371 
373  if (frame && frame->HasDebugInformation() &&
374  GetProcess()->GetWarningsOptimization()) {
375  SymbolContext sc =
376  frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextModule);
377  GetProcess()->PrintWarningOptimization(sc);
378  }
379 }
380 
381 lldb::StopInfoSP Thread::GetStopInfo() {
382  if (m_destroy_called)
383  return m_stop_info_sp;
384 
385  ThreadPlanSP completed_plan_sp(GetCompletedPlan());
386  ProcessSP process_sp(GetProcess());
387  const uint32_t stop_id = process_sp ? process_sp->GetStopID() : UINT32_MAX;
388 
389  // Here we select the stop info according to priorirty: - m_stop_info_sp (if
390  // not trace) - preset value - completed plan stop info - new value with plan
391  // from completed plan stack - m_stop_info_sp (trace stop reason is OK now) -
392  // ask GetPrivateStopInfo to set stop info
393 
394  bool have_valid_stop_info = m_stop_info_sp &&
395  m_stop_info_sp ->IsValid() &&
396  m_stop_info_stop_id == stop_id;
397  bool have_valid_completed_plan = completed_plan_sp && completed_plan_sp->PlanSucceeded();
398  bool plan_failed = completed_plan_sp && !completed_plan_sp->PlanSucceeded();
399  bool plan_overrides_trace =
400  have_valid_stop_info && have_valid_completed_plan
401  && (m_stop_info_sp->GetStopReason() == eStopReasonTrace);
402 
403  if (have_valid_stop_info && !plan_overrides_trace && !plan_failed) {
404  return m_stop_info_sp;
405  } else if (completed_plan_sp) {
407  completed_plan_sp, GetReturnValueObject(), GetExpressionVariable());
408  } else {
410  return m_stop_info_sp;
411  }
412 }
413 
414 lldb::StopInfoSP Thread::GetPrivateStopInfo() {
415  if (m_destroy_called)
416  return m_stop_info_sp;
417 
418  ProcessSP process_sp(GetProcess());
419  if (process_sp) {
420  const uint32_t process_stop_id = process_sp->GetStopID();
421  if (m_stop_info_stop_id != process_stop_id) {
422  if (m_stop_info_sp) {
423  if (m_stop_info_sp->IsValid() || IsStillAtLastBreakpointHit() ||
426  else
427  m_stop_info_sp.reset();
428  }
429 
430  if (!m_stop_info_sp) {
431  if (!CalculateStopInfo())
432  SetStopInfo(StopInfoSP());
433  }
434  }
435 
436  // The stop info can be manually set by calling Thread::SetStopInfo() prior
437  // to this function ever getting called, so we can't rely on
438  // "m_stop_info_stop_id != process_stop_id" as the condition for the if
439  // statement below, we must also check the stop info to see if we need to
440  // override it. See the header documentation in
441  // Process::GetStopInfoOverrideCallback() for more information on the stop
442  // info override callback.
443  if (m_stop_info_override_stop_id != process_stop_id) {
444  m_stop_info_override_stop_id = process_stop_id;
445  if (m_stop_info_sp) {
446  if (const Architecture *arch =
447  process_sp->GetTarget().GetArchitecturePlugin())
448  arch->OverrideStopInfo(*this);
449  }
450  }
451  }
452  return m_stop_info_sp;
453 }
454 
456  lldb::StopInfoSP stop_info_sp(GetStopInfo());
457  if (stop_info_sp)
458  return stop_info_sp->GetStopReason();
459  return eStopReasonNone;
460 }
461 
463  ProcessSP process_sp(GetProcess());
464  if (process_sp)
465  return m_stop_info_stop_id == process_sp->GetStopID();
466  else
467  return true; // Process is no longer around so stop info is always up to
468  // date...
469 }
470 
472  if (m_stop_info_sp) {
473  m_stop_info_sp.reset();
474  }
475 }
476 
477 void Thread::SetStopInfo(const lldb::StopInfoSP &stop_info_sp) {
478  m_stop_info_sp = stop_info_sp;
479  if (m_stop_info_sp) {
480  m_stop_info_sp->MakeStopInfoValid();
481  // If we are overriding the ShouldReportStop, do that here:
483  m_stop_info_sp->OverrideShouldNotify(m_override_should_notify ==
484  eLazyBoolYes);
485  }
486 
487  ProcessSP process_sp(GetProcess());
488  if (process_sp)
489  m_stop_info_stop_id = process_sp->GetStopID();
490  else
493  if (log)
494  log->Printf("%p: tid = 0x%" PRIx64 ": stop info = %s (stop_id = %u)",
495  static_cast<void *>(this), GetID(),
496  stop_info_sp ? stop_info_sp->GetDescription() : "<NULL>",
498 }
499 
501  if (vote == eVoteNoOpinion)
502  return;
503  else {
505  if (m_stop_info_sp)
506  m_stop_info_sp->OverrideShouldNotify(m_override_should_notify ==
507  eLazyBoolYes);
508  }
509 }
510 
512  // Note, we can't just NULL out the private reason, or the native thread
513  // implementation will try to go calculate it again. For now, just set it to
514  // a Unix Signal with an invalid signal number.
515  SetStopInfo(
517 }
518 
520  return (bool)GetPrivateStopInfo();
521 }
522 
524  saved_state.register_backup_sp.reset();
525  lldb::StackFrameSP frame_sp(GetStackFrameAtIndex(0));
526  if (frame_sp) {
527  lldb::RegisterCheckpointSP reg_checkpoint_sp(
529  if (reg_checkpoint_sp) {
530  lldb::RegisterContextSP reg_ctx_sp(frame_sp->GetRegisterContext());
531  if (reg_ctx_sp && reg_ctx_sp->ReadAllRegisterValues(*reg_checkpoint_sp))
532  saved_state.register_backup_sp = reg_checkpoint_sp;
533  }
534  }
535  if (!saved_state.register_backup_sp)
536  return false;
537 
538  saved_state.stop_info_sp = GetStopInfo();
539  ProcessSP process_sp(GetProcess());
540  if (process_sp)
541  saved_state.orig_stop_id = process_sp->GetStopID();
544 
545  return true;
546 }
547 
549  ThreadStateCheckpoint &saved_state) {
550  if (saved_state.register_backup_sp) {
551  lldb::StackFrameSP frame_sp(GetStackFrameAtIndex(0));
552  if (frame_sp) {
553  lldb::RegisterContextSP reg_ctx_sp(frame_sp->GetRegisterContext());
554  if (reg_ctx_sp) {
555  bool ret =
556  reg_ctx_sp->WriteAllRegisterValues(*saved_state.register_backup_sp);
557 
558  // Clear out all stack frames as our world just changed.
560  reg_ctx_sp->InvalidateIfNeeded(true);
561  if (m_unwinder_up)
562  m_unwinder_up->Clear();
563  return ret;
564  }
565  }
566  }
567  return false;
568 }
569 
571  ThreadStateCheckpoint &saved_state) {
572  if (saved_state.stop_info_sp)
573  saved_state.stop_info_sp->MakeStopInfoValid();
574  SetStopInfo(saved_state.stop_info_sp);
575  GetStackFrameList()->SetCurrentInlinedDepth(
576  saved_state.current_inlined_depth);
578  return true;
579 }
580 
582  // If any other threads access this we will need a mutex for it
583  std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
584  return m_state;
585 }
586 
588  std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
589  m_state = state;
590 }
591 
593  ThreadPlan *current_plan = GetCurrentPlan();
594 
595  // FIXME: I may decide to disallow threads with no plans. In which
596  // case this should go to an assert.
597 
598  if (!current_plan)
599  return;
600 
601  current_plan->WillStop();
602 }
603 
605  if (GetResumeState() != eStateSuspended) {
606  // If we're at a breakpoint push the step-over breakpoint plan. Do this
607  // before telling the current plan it will resume, since we might change
608  // what the current plan is.
609 
610  lldb::RegisterContextSP reg_ctx_sp(GetRegisterContext());
611  if (reg_ctx_sp) {
612  const addr_t thread_pc = reg_ctx_sp->GetPC();
613  BreakpointSiteSP bp_site_sp =
614  GetProcess()->GetBreakpointSiteList().FindByAddress(thread_pc);
615  if (bp_site_sp) {
616  // Note, don't assume there's a ThreadPlanStepOverBreakpoint, the
617  // target may not require anything special to step over a breakpoint.
618 
619  ThreadPlan *cur_plan = GetCurrentPlan();
620 
621  bool push_step_over_bp_plan = false;
622  if (cur_plan->GetKind() == ThreadPlan::eKindStepOverBreakpoint) {
624  (ThreadPlanStepOverBreakpoint *)cur_plan;
625  if (bp_plan->GetBreakpointLoadAddress() != thread_pc)
626  push_step_over_bp_plan = true;
627  } else
628  push_step_over_bp_plan = true;
629 
630  if (push_step_over_bp_plan) {
631  ThreadPlanSP step_bp_plan_sp(new ThreadPlanStepOverBreakpoint(*this));
632  if (step_bp_plan_sp) {
633  step_bp_plan_sp->SetPrivate(true);
634 
635  if (GetCurrentPlan()->RunState() != eStateStepping) {
636  ThreadPlanStepOverBreakpoint *step_bp_plan =
637  static_cast<ThreadPlanStepOverBreakpoint *>(
638  step_bp_plan_sp.get());
639  step_bp_plan->SetAutoContinue(true);
640  }
641  QueueThreadPlan(step_bp_plan_sp, false);
642  }
643  }
644  }
645  }
646  }
647 }
648 
649 bool Thread::ShouldResume(StateType resume_state) {
650  // At this point clear the completed plan stack.
651  m_completed_plan_stack.clear();
652  m_discarded_plan_stack.clear();
654 
655  StateType prev_resume_state = GetTemporaryResumeState();
656 
657  SetTemporaryResumeState(resume_state);
658 
659  lldb::ThreadSP backing_thread_sp(GetBackingThread());
660  if (backing_thread_sp)
661  backing_thread_sp->SetTemporaryResumeState(resume_state);
662 
663  // Make sure m_stop_info_sp is valid. Don't do this for threads we suspended
664  // in the previous run.
665  if (prev_resume_state != eStateSuspended)
667 
668  // This is a little dubious, but we are trying to limit how often we actually
669  // fetch stop info from the target, 'cause that slows down single stepping.
670  // So assume that if we got to the point where we're about to resume, and we
671  // haven't yet had to fetch the stop reason, then it doesn't need to know
672  // about the fact that we are resuming...
673  const uint32_t process_stop_id = GetProcess()->GetStopID();
674  if (m_stop_info_stop_id == process_stop_id &&
675  (m_stop_info_sp && m_stop_info_sp->IsValid())) {
676  StopInfo *stop_info = GetPrivateStopInfo().get();
677  if (stop_info)
678  stop_info->WillResume(resume_state);
679  }
680 
681  // Tell all the plans that we are about to resume in case they need to clear
682  // any state. We distinguish between the plan on the top of the stack and the
683  // lower plans in case a plan needs to do any special business before it
684  // runs.
685 
686  bool need_to_resume = false;
687  ThreadPlan *plan_ptr = GetCurrentPlan();
688  if (plan_ptr) {
689  need_to_resume = plan_ptr->WillResume(resume_state, true);
690 
691  while ((plan_ptr = GetPreviousPlan(plan_ptr)) != nullptr) {
692  plan_ptr->WillResume(resume_state, false);
693  }
694 
695  // If the WillResume for the plan says we are faking a resume, then it will
696  // have set an appropriate stop info. In that case, don't reset it here.
697 
698  if (need_to_resume && resume_state != eStateSuspended) {
699  m_stop_info_sp.reset();
700  }
701  }
702 
703  if (need_to_resume) {
705  // Let Thread subclasses do any special work they need to prior to resuming
706  WillResume(resume_state);
707  }
708 
709  return need_to_resume;
710 }
711 
713 
715 
716 bool Thread::ShouldStop(Event *event_ptr) {
717  ThreadPlan *current_plan = GetCurrentPlan();
718 
719  bool should_stop = true;
720 
722 
723  if (GetResumeState() == eStateSuspended) {
724  if (log)
725  log->Printf("Thread::%s for tid = 0x%4.4" PRIx64 " 0x%4.4" PRIx64
726  ", should_stop = 0 (ignore since thread was suspended)",
727  __FUNCTION__, GetID(), GetProtocolID());
728  return false;
729  }
730 
732  if (log)
733  log->Printf("Thread::%s for tid = 0x%4.4" PRIx64 " 0x%4.4" PRIx64
734  ", should_stop = 0 (ignore since thread was suspended)",
735  __FUNCTION__, GetID(), GetProtocolID());
736  return false;
737  }
738 
739  // Based on the current thread plan and process stop info, check if this
740  // thread caused the process to stop. NOTE: this must take place before the
741  // plan is moved from the current plan stack to the completed plan stack.
742  if (!ThreadStoppedForAReason()) {
743  if (log)
744  log->Printf("Thread::%s for tid = 0x%4.4" PRIx64 " 0x%4.4" PRIx64
745  ", pc = 0x%16.16" PRIx64
746  ", should_stop = 0 (ignore since no stop reason)",
747  __FUNCTION__, GetID(), GetProtocolID(),
750  return false;
751  }
752 
753  if (log) {
754  log->Printf("Thread::%s(%p) for tid = 0x%4.4" PRIx64 " 0x%4.4" PRIx64
755  ", pc = 0x%16.16" PRIx64,
756  __FUNCTION__, static_cast<void *>(this), GetID(),
757  GetProtocolID(),
760  log->Printf("^^^^^^^^ Thread::ShouldStop Begin ^^^^^^^^");
761  StreamString s;
762  s.IndentMore();
763  DumpThreadPlans(&s);
764  log->Printf("Plan stack initial state:\n%s", s.GetData());
765  }
766 
767  // The top most plan always gets to do the trace log...
768  current_plan->DoTraceLog();
769 
770  // First query the stop info's ShouldStopSynchronous. This handles
771  // "synchronous" stop reasons, for example the breakpoint command on internal
772  // breakpoints. If a synchronous stop reason says we should not stop, then
773  // we don't have to do any more work on this stop.
774  StopInfoSP private_stop_info(GetPrivateStopInfo());
775  if (private_stop_info &&
776  !private_stop_info->ShouldStopSynchronous(event_ptr)) {
777  if (log)
778  log->Printf("StopInfo::ShouldStop async callback says we should not "
779  "stop, returning ShouldStop of false.");
780  return false;
781  }
782 
783  // If we've already been restarted, don't query the plans since the state
784  // they would examine is not current.
786  return false;
787 
788  // Before the plans see the state of the world, calculate the current inlined
789  // depth.
790  GetStackFrameList()->CalculateCurrentInlinedDepth();
791 
792  // If the base plan doesn't understand why we stopped, then we have to find a
793  // plan that does. If that plan is still working, then we don't need to do
794  // any more work. If the plan that explains the stop is done, then we should
795  // pop all the plans below it, and pop it, and then let the plans above it
796  // decide whether they still need to do more work.
797 
798  bool done_processing_current_plan = false;
799 
800  if (!current_plan->PlanExplainsStop(event_ptr)) {
801  if (current_plan->TracerExplainsStop()) {
802  done_processing_current_plan = true;
803  should_stop = false;
804  } else {
805  // If the current plan doesn't explain the stop, then find one that does
806  // and let it handle the situation.
807  ThreadPlan *plan_ptr = current_plan;
808  while ((plan_ptr = GetPreviousPlan(plan_ptr)) != nullptr) {
809  if (plan_ptr->PlanExplainsStop(event_ptr)) {
810  should_stop = plan_ptr->ShouldStop(event_ptr);
811 
812  // plan_ptr explains the stop, next check whether plan_ptr is done,
813  // if so, then we should take it and all the plans below it off the
814  // stack.
815 
816  if (plan_ptr->MischiefManaged()) {
817  // We're going to pop the plans up to and including the plan that
818  // explains the stop.
819  ThreadPlan *prev_plan_ptr = GetPreviousPlan(plan_ptr);
820 
821  do {
822  if (should_stop)
823  current_plan->WillStop();
824  PopPlan();
825  } while ((current_plan = GetCurrentPlan()) != prev_plan_ptr);
826  // Now, if the responsible plan was not "Okay to discard" then
827  // we're done, otherwise we forward this to the next plan in the
828  // stack below.
829  done_processing_current_plan =
830  (plan_ptr->IsMasterPlan() && !plan_ptr->OkayToDiscard());
831  } else
832  done_processing_current_plan = true;
833 
834  break;
835  }
836  }
837  }
838  }
839 
840  if (!done_processing_current_plan) {
841  bool over_ride_stop = current_plan->ShouldAutoContinue(event_ptr);
842 
843  if (log)
844  log->Printf("Plan %s explains stop, auto-continue %i.",
845  current_plan->GetName(), over_ride_stop);
846 
847  // We're starting from the base plan, so just let it decide;
848  if (PlanIsBasePlan(current_plan)) {
849  should_stop = current_plan->ShouldStop(event_ptr);
850  if (log)
851  log->Printf("Base plan says should stop: %i.", should_stop);
852  } else {
853  // Otherwise, don't let the base plan override what the other plans say
854  // to do, since presumably if there were other plans they would know what
855  // to do...
856  while (1) {
857  if (PlanIsBasePlan(current_plan))
858  break;
859 
860  should_stop = current_plan->ShouldStop(event_ptr);
861  if (log)
862  log->Printf("Plan %s should stop: %d.", current_plan->GetName(),
863  should_stop);
864  if (current_plan->MischiefManaged()) {
865  if (should_stop)
866  current_plan->WillStop();
867 
868  // If a Master Plan wants to stop, and wants to stick on the stack,
869  // we let it. Otherwise, see if the plan's parent wants to stop.
870 
871  if (should_stop && current_plan->IsMasterPlan() &&
872  !current_plan->OkayToDiscard()) {
873  PopPlan();
874  break;
875  } else {
876  PopPlan();
877 
878  current_plan = GetCurrentPlan();
879  if (current_plan == nullptr) {
880  break;
881  }
882  }
883  } else {
884  break;
885  }
886  }
887  }
888 
889  if (over_ride_stop)
890  should_stop = false;
891  }
892 
893  // One other potential problem is that we set up a master plan, then stop in
894  // before it is complete - for instance by hitting a breakpoint during a
895  // step-over - then do some step/finish/etc operations that wind up past the
896  // end point condition of the initial plan. We don't want to strand the
897  // original plan on the stack, This code clears stale plans off the stack.
898 
899  if (should_stop) {
900  ThreadPlan *plan_ptr = GetCurrentPlan();
901 
902  // Discard the stale plans and all plans below them in the stack, plus move
903  // the completed plans to the completed plan stack
904  while (!PlanIsBasePlan(plan_ptr)) {
905  bool stale = plan_ptr->IsPlanStale();
906  ThreadPlan *examined_plan = plan_ptr;
907  plan_ptr = GetPreviousPlan(examined_plan);
908 
909  if (stale) {
910  if (log)
911  log->Printf(
912  "Plan %s being discarded in cleanup, it says it is already done.",
913  examined_plan->GetName());
914  while (GetCurrentPlan() != examined_plan) {
915  DiscardPlan();
916  }
917  if (examined_plan->IsPlanComplete()) {
918  // plan is complete but does not explain the stop (example: step to a
919  // line with breakpoint), let us move the plan to
920  // completed_plan_stack anyway
921  PopPlan();
922  } else
923  DiscardPlan();
924  }
925  }
926  }
927 
928  if (log) {
929  StreamString s;
930  s.IndentMore();
931  DumpThreadPlans(&s);
932  log->Printf("Plan stack final state:\n%s", s.GetData());
933  log->Printf("vvvvvvvv Thread::ShouldStop End (returning %i) vvvvvvvv",
934  should_stop);
935  }
936  return should_stop;
937 }
938 
940  StateType thread_state = GetResumeState();
941  StateType temp_thread_state = GetTemporaryResumeState();
942 
944 
945  if (thread_state == eStateSuspended || thread_state == eStateInvalid) {
946  if (log)
947  log->Printf("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64
948  ": returning vote %i (state was suspended or invalid)",
949  GetID(), eVoteNoOpinion);
950  return eVoteNoOpinion;
951  }
952 
953  if (temp_thread_state == eStateSuspended ||
954  temp_thread_state == eStateInvalid) {
955  if (log)
956  log->Printf(
957  "Thread::ShouldReportStop() tid = 0x%4.4" PRIx64
958  ": returning vote %i (temporary state was suspended or invalid)",
959  GetID(), eVoteNoOpinion);
960  return eVoteNoOpinion;
961  }
962 
963  if (!ThreadStoppedForAReason()) {
964  if (log)
965  log->Printf("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64
966  ": returning vote %i (thread didn't stop for a reason.)",
967  GetID(), eVoteNoOpinion);
968  return eVoteNoOpinion;
969  }
970 
971  if (m_completed_plan_stack.size() > 0) {
972  // Don't use GetCompletedPlan here, since that suppresses private plans.
973  if (log)
974  log->Printf("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64
975  ": returning vote for complete stack's back plan",
976  GetID());
977  return m_completed_plan_stack.back()->ShouldReportStop(event_ptr);
978  } else {
979  Vote thread_vote = eVoteNoOpinion;
980  ThreadPlan *plan_ptr = GetCurrentPlan();
981  while (1) {
982  if (plan_ptr->PlanExplainsStop(event_ptr)) {
983  thread_vote = plan_ptr->ShouldReportStop(event_ptr);
984  break;
985  }
986  if (PlanIsBasePlan(plan_ptr))
987  break;
988  else
989  plan_ptr = GetPreviousPlan(plan_ptr);
990  }
991  if (log)
992  log->Printf("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64
993  ": returning vote %i for current plan",
994  GetID(), thread_vote);
995 
996  return thread_vote;
997  }
998 }
999 
1001  StateType thread_state = GetResumeState();
1002 
1003  if (thread_state == eStateSuspended || thread_state == eStateInvalid) {
1004  return eVoteNoOpinion;
1005  }
1006 
1008  if (m_completed_plan_stack.size() > 0) {
1009  // Don't use GetCompletedPlan here, since that suppresses private plans.
1010  if (log)
1011  log->Printf("Current Plan for thread %d(%p) (0x%4.4" PRIx64
1012  ", %s): %s being asked whether we should report run.",
1013  GetIndexID(), static_cast<void *>(this), GetID(),
1015  m_completed_plan_stack.back()->GetName());
1016 
1017  return m_completed_plan_stack.back()->ShouldReportRun(event_ptr);
1018  } else {
1019  if (log)
1020  log->Printf("Current Plan for thread %d(%p) (0x%4.4" PRIx64
1021  ", %s): %s being asked whether we should report run.",
1022  GetIndexID(), static_cast<void *>(this), GetID(),
1024  GetCurrentPlan()->GetName());
1025 
1026  return GetCurrentPlan()->ShouldReportRun(event_ptr);
1027  }
1028 }
1029 
1030 bool Thread::MatchesSpec(const ThreadSpec *spec) {
1031  return (spec == nullptr) ? true : spec->ThreadPassesBasicTests(*this);
1032 }
1033 
1034 void Thread::PushPlan(ThreadPlanSP &thread_plan_sp) {
1035  if (thread_plan_sp) {
1036  // If the thread plan doesn't already have a tracer, give it its parent's
1037  // tracer:
1038  if (!thread_plan_sp->GetThreadPlanTracer()) {
1039  assert(!m_plan_stack.empty());
1040  thread_plan_sp->SetThreadPlanTracer(
1041  m_plan_stack.back()->GetThreadPlanTracer());
1042  }
1043  m_plan_stack.push_back(thread_plan_sp);
1044 
1045  thread_plan_sp->DidPush();
1046 
1048  if (log) {
1049  StreamString s;
1050  thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelFull);
1051  log->Printf("Thread::PushPlan(0x%p): \"%s\", tid = 0x%4.4" PRIx64 ".",
1052  static_cast<void *>(this), s.GetData(),
1053  thread_plan_sp->GetThread().GetID());
1054  }
1055  }
1056 }
1057 
1060 
1061  if (m_plan_stack.size() <= 1)
1062  return;
1063  else {
1064  ThreadPlanSP &plan = m_plan_stack.back();
1065  if (log) {
1066  log->Printf("Popping plan: \"%s\", tid = 0x%4.4" PRIx64 ".",
1067  plan->GetName(), plan->GetThread().GetID());
1068  }
1069  m_completed_plan_stack.push_back(plan);
1070  plan->WillPop();
1071  m_plan_stack.pop_back();
1072  }
1073 }
1074 
1077  if (m_plan_stack.size() > 1) {
1078  ThreadPlanSP &plan = m_plan_stack.back();
1079  if (log)
1080  log->Printf("Discarding plan: \"%s\", tid = 0x%4.4" PRIx64 ".",
1081  plan->GetName(), plan->GetThread().GetID());
1082 
1083  m_discarded_plan_stack.push_back(plan);
1084  plan->WillPop();
1085  m_plan_stack.pop_back();
1086  }
1087 }
1088 
1090  // There will always be at least the base plan. If somebody is mucking with
1091  // a thread with an empty plan stack, we should assert right away.
1092  return m_plan_stack.empty() ? nullptr : m_plan_stack.back().get();
1093 }
1094 
1096  ThreadPlanSP empty_plan_sp;
1097  if (!m_completed_plan_stack.empty()) {
1098  for (int i = m_completed_plan_stack.size() - 1; i >= 0; i--) {
1099  ThreadPlanSP completed_plan_sp;
1100  completed_plan_sp = m_completed_plan_stack[i];
1101  if (!completed_plan_sp->GetPrivate())
1102  return completed_plan_sp;
1103  }
1104  }
1105  return empty_plan_sp;
1106 }
1107 
1109  if (!m_completed_plan_stack.empty()) {
1110  for (int i = m_completed_plan_stack.size() - 1; i >= 0; i--) {
1111  ValueObjectSP return_valobj_sp;
1112  return_valobj_sp = m_completed_plan_stack[i]->GetReturnValueObject();
1113  if (return_valobj_sp)
1114  return return_valobj_sp;
1115  }
1116  }
1117  return ValueObjectSP();
1118 }
1119 
1120 ExpressionVariableSP Thread::GetExpressionVariable() {
1121  if (!m_completed_plan_stack.empty()) {
1122  for (int i = m_completed_plan_stack.size() - 1; i >= 0; i--) {
1123  ExpressionVariableSP expression_variable_sp;
1124  expression_variable_sp =
1125  m_completed_plan_stack[i]->GetExpressionVariable();
1126  if (expression_variable_sp)
1127  return expression_variable_sp;
1128  }
1129  }
1130  return ExpressionVariableSP();
1131 }
1132 
1134  if (!m_completed_plan_stack.empty()) {
1135  for (int i = m_completed_plan_stack.size() - 1; i >= 0; i--) {
1136  if (m_completed_plan_stack[i].get() == plan)
1137  return true;
1138  }
1139  }
1140  return false;
1141 }
1142 
1144  if (!m_discarded_plan_stack.empty()) {
1145  for (int i = m_discarded_plan_stack.size() - 1; i >= 0; i--) {
1146  if (m_discarded_plan_stack[i].get() == plan)
1147  return true;
1148  }
1149  }
1150  return false;
1151 }
1152 
1154  return (!m_completed_plan_stack.empty()) ;
1155 }
1156 
1158  if (current_plan == nullptr)
1159  return nullptr;
1160 
1161  int stack_size = m_completed_plan_stack.size();
1162  for (int i = stack_size - 1; i > 0; i--) {
1163  if (current_plan == m_completed_plan_stack[i].get())
1164  return m_completed_plan_stack[i - 1].get();
1165  }
1166 
1167  if (stack_size > 0 && m_completed_plan_stack[0].get() == current_plan) {
1168  return GetCurrentPlan();
1169  }
1170 
1171  stack_size = m_plan_stack.size();
1172  for (int i = stack_size - 1; i > 0; i--) {
1173  if (current_plan == m_plan_stack[i].get())
1174  return m_plan_stack[i - 1].get();
1175  }
1176  return nullptr;
1177 }
1178 
1179 Status Thread::QueueThreadPlan(ThreadPlanSP &thread_plan_sp,
1180  bool abort_other_plans) {
1181  Status status;
1182  StreamString s;
1183  if (!thread_plan_sp->ValidatePlan(&s)) {
1184  DiscardThreadPlansUpToPlan(thread_plan_sp);
1185  thread_plan_sp.reset();
1186  status.SetErrorString(s.GetString());
1187  return status;
1188  }
1189 
1190  if (abort_other_plans)
1191  DiscardThreadPlans(true);
1192 
1193  PushPlan(thread_plan_sp);
1194 
1195  // This seems a little funny, but I don't want to have to split up the
1196  // constructor and the DidPush in the scripted plan, that seems annoying.
1197  // That means the constructor has to be in DidPush. So I have to validate the
1198  // plan AFTER pushing it, and then take it off again...
1199  if (!thread_plan_sp->ValidatePlan(&s)) {
1200  DiscardThreadPlansUpToPlan(thread_plan_sp);
1201  thread_plan_sp.reset();
1202  status.SetErrorString(s.GetString());
1203  return status;
1204  }
1205 
1206  return status;
1207 }
1208 
1209 void Thread::EnableTracer(bool value, bool single_stepping) {
1210  int stack_size = m_plan_stack.size();
1211  for (int i = 0; i < stack_size; i++) {
1212  if (m_plan_stack[i]->GetThreadPlanTracer()) {
1213  m_plan_stack[i]->GetThreadPlanTracer()->EnableTracing(value);
1214  m_plan_stack[i]->GetThreadPlanTracer()->EnableSingleStep(single_stepping);
1215  }
1216  }
1217 }
1218 
1219 void Thread::SetTracer(lldb::ThreadPlanTracerSP &tracer_sp) {
1220  int stack_size = m_plan_stack.size();
1221  for (int i = 0; i < stack_size; i++)
1222  m_plan_stack[i]->SetThreadPlanTracer(tracer_sp);
1223 }
1224 
1226  // Count the user thread plans from the back end to get the number of the one
1227  // we want to discard:
1228 
1229  uint32_t idx = 0;
1230  ThreadPlan *up_to_plan_ptr = nullptr;
1231 
1232  for (ThreadPlanSP plan_sp : m_plan_stack) {
1233  if (plan_sp->GetPrivate())
1234  continue;
1235  if (idx == thread_index) {
1236  up_to_plan_ptr = plan_sp.get();
1237  break;
1238  } else
1239  idx++;
1240  }
1241 
1242  if (up_to_plan_ptr == nullptr)
1243  return false;
1244 
1245  DiscardThreadPlansUpToPlan(up_to_plan_ptr);
1246  return true;
1247 }
1248 
1249 void Thread::DiscardThreadPlansUpToPlan(lldb::ThreadPlanSP &up_to_plan_sp) {
1250  DiscardThreadPlansUpToPlan(up_to_plan_sp.get());
1251 }
1252 
1255  if (log)
1256  log->Printf("Discarding thread plans for thread tid = 0x%4.4" PRIx64
1257  ", up to %p",
1258  GetID(), static_cast<void *>(up_to_plan_ptr));
1259 
1260  int stack_size = m_plan_stack.size();
1261 
1262  // If the input plan is nullptr, discard all plans. Otherwise make sure this
1263  // plan is in the stack, and if so discard up to and including it.
1264 
1265  if (up_to_plan_ptr == nullptr) {
1266  for (int i = stack_size - 1; i > 0; i--)
1267  DiscardPlan();
1268  } else {
1269  bool found_it = false;
1270  for (int i = stack_size - 1; i > 0; i--) {
1271  if (m_plan_stack[i].get() == up_to_plan_ptr)
1272  found_it = true;
1273  }
1274  if (found_it) {
1275  bool last_one = false;
1276  for (int i = stack_size - 1; i > 0 && !last_one; i--) {
1277  if (GetCurrentPlan() == up_to_plan_ptr)
1278  last_one = true;
1279  DiscardPlan();
1280  }
1281  }
1282  }
1283 }
1284 
1285 void Thread::DiscardThreadPlans(bool force) {
1287  if (log) {
1288  log->Printf("Discarding thread plans for thread (tid = 0x%4.4" PRIx64
1289  ", force %d)",
1290  GetID(), force);
1291  }
1292 
1293  if (force) {
1294  int stack_size = m_plan_stack.size();
1295  for (int i = stack_size - 1; i > 0; i--) {
1296  DiscardPlan();
1297  }
1298  return;
1299  }
1300 
1301  while (1) {
1302  int master_plan_idx;
1303  bool discard = true;
1304 
1305  // Find the first master plan, see if it wants discarding, and if yes
1306  // discard up to it.
1307  for (master_plan_idx = m_plan_stack.size() - 1; master_plan_idx >= 0;
1308  master_plan_idx--) {
1309  if (m_plan_stack[master_plan_idx]->IsMasterPlan()) {
1310  discard = m_plan_stack[master_plan_idx]->OkayToDiscard();
1311  break;
1312  }
1313  }
1314 
1315  if (discard) {
1316  // First pop all the dependent plans:
1317  for (int i = m_plan_stack.size() - 1; i > master_plan_idx; i--) {
1318  // FIXME: Do we need a finalize here, or is the rule that
1319  // "PrepareForStop"
1320  // for the plan leaves it in a state that it is safe to pop the plan
1321  // with no more notice?
1322  DiscardPlan();
1323  }
1324 
1325  // Now discard the master plan itself.
1326  // The bottom-most plan never gets discarded. "OkayToDiscard" for it
1327  // means discard it's dependent plans, but not it...
1328  if (master_plan_idx > 0) {
1329  DiscardPlan();
1330  }
1331  } else {
1332  // If the master plan doesn't want to get discarded, then we're done.
1333  break;
1334  }
1335  }
1336 }
1337 
1338 bool Thread::PlanIsBasePlan(ThreadPlan *plan_ptr) {
1339  if (plan_ptr->IsBasePlan())
1340  return true;
1341  else if (m_plan_stack.size() == 0)
1342  return false;
1343  else
1344  return m_plan_stack[0].get() == plan_ptr;
1345 }
1346 
1348  Status error;
1349  int stack_size = m_plan_stack.size();
1350 
1351  // If the input plan is nullptr, discard all plans. Otherwise make sure this
1352  // plan is in the stack, and if so discard up to and including it.
1353 
1354  for (int i = stack_size - 1; i > 0; i--) {
1355  if (m_plan_stack[i]->GetKind() == ThreadPlan::eKindCallFunction) {
1357  return error;
1358  }
1359  }
1360  error.SetErrorString("No expressions currently active on this thread");
1361  return error;
1362 }
1363 
1364 ThreadPlanSP Thread::QueueFundamentalPlan(bool abort_other_plans) {
1365  ThreadPlanSP thread_plan_sp(new ThreadPlanBase(*this));
1366  QueueThreadPlan(thread_plan_sp, abort_other_plans);
1367  return thread_plan_sp;
1368 }
1369 
1371  bool step_over, bool abort_other_plans, bool stop_other_threads,
1372  Status &status) {
1373  ThreadPlanSP thread_plan_sp(new ThreadPlanStepInstruction(
1374  *this, step_over, stop_other_threads, eVoteNoOpinion, eVoteNoOpinion));
1375  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
1376  return thread_plan_sp;
1377 }
1378 
1380  bool abort_other_plans, const AddressRange &range,
1381  const SymbolContext &addr_context, lldb::RunMode stop_other_threads,
1382  Status &status, LazyBool step_out_avoids_code_withoug_debug_info) {
1383  ThreadPlanSP thread_plan_sp;
1384  thread_plan_sp = std::make_shared<ThreadPlanStepOverRange>(
1385  *this, range, addr_context, stop_other_threads,
1386  step_out_avoids_code_withoug_debug_info);
1387 
1388  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
1389  return thread_plan_sp;
1390 }
1391 
1392 // Call the QueueThreadPlanForStepOverRange method which takes an address
1393 // range.
1395  bool abort_other_plans, const LineEntry &line_entry,
1396  const SymbolContext &addr_context, lldb::RunMode stop_other_threads,
1397  Status &status, LazyBool step_out_avoids_code_withoug_debug_info) {
1398  const bool include_inlined_functions = true;
1399  auto address_range =
1400  line_entry.GetSameLineContiguousAddressRange(include_inlined_functions);
1402  abort_other_plans, address_range, addr_context, stop_other_threads,
1403  status, step_out_avoids_code_withoug_debug_info);
1404 }
1405 
1407  bool abort_other_plans, const AddressRange &range,
1408  const SymbolContext &addr_context, const char *step_in_target,
1409  lldb::RunMode stop_other_threads, Status &status,
1410  LazyBool step_in_avoids_code_without_debug_info,
1411  LazyBool step_out_avoids_code_without_debug_info) {
1412  ThreadPlanSP thread_plan_sp(
1413  new ThreadPlanStepInRange(*this, range, addr_context, stop_other_threads,
1414  step_in_avoids_code_without_debug_info,
1415  step_out_avoids_code_without_debug_info));
1416  ThreadPlanStepInRange *plan =
1417  static_cast<ThreadPlanStepInRange *>(thread_plan_sp.get());
1418 
1419  if (step_in_target)
1420  plan->SetStepInTarget(step_in_target);
1421 
1422  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
1423  return thread_plan_sp;
1424 }
1425 
1426 // Call the QueueThreadPlanForStepInRange method which takes an address range.
1428  bool abort_other_plans, const LineEntry &line_entry,
1429  const SymbolContext &addr_context, const char *step_in_target,
1430  lldb::RunMode stop_other_threads, Status &status,
1431  LazyBool step_in_avoids_code_without_debug_info,
1432  LazyBool step_out_avoids_code_without_debug_info) {
1433  const bool include_inlined_functions = false;
1435  abort_other_plans,
1436  line_entry.GetSameLineContiguousAddressRange(include_inlined_functions),
1437  addr_context, step_in_target, stop_other_threads, status,
1438  step_in_avoids_code_without_debug_info,
1439  step_out_avoids_code_without_debug_info);
1440 }
1441 
1443  bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
1444  bool stop_other_threads, Vote stop_vote, Vote run_vote, uint32_t frame_idx,
1445  Status &status, LazyBool step_out_avoids_code_without_debug_info) {
1446  ThreadPlanSP thread_plan_sp(new ThreadPlanStepOut(
1447  *this, addr_context, first_insn, stop_other_threads, stop_vote, run_vote,
1448  frame_idx, step_out_avoids_code_without_debug_info));
1449 
1450  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
1451  return thread_plan_sp;
1452 }
1453 
1455  bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
1456  bool stop_other_threads, Vote stop_vote, Vote run_vote, uint32_t frame_idx,
1457  Status &status, bool continue_to_next_branch) {
1458  const bool calculate_return_value =
1459  false; // No need to calculate the return value here.
1460  ThreadPlanSP thread_plan_sp(new ThreadPlanStepOut(
1461  *this, addr_context, first_insn, stop_other_threads, stop_vote, run_vote,
1462  frame_idx, eLazyBoolNo, continue_to_next_branch, calculate_return_value));
1463 
1464  ThreadPlanStepOut *new_plan =
1465  static_cast<ThreadPlanStepOut *>(thread_plan_sp.get());
1466  new_plan->ClearShouldStopHereCallbacks();
1467 
1468  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
1469  return thread_plan_sp;
1470 }
1471 
1472 ThreadPlanSP Thread::QueueThreadPlanForStepThrough(StackID &return_stack_id,
1473  bool abort_other_plans,
1474  bool stop_other_threads,
1475  Status &status) {
1476  ThreadPlanSP thread_plan_sp(
1477  new ThreadPlanStepThrough(*this, return_stack_id, stop_other_threads));
1478  if (!thread_plan_sp || !thread_plan_sp->ValidatePlan(nullptr))
1479  return ThreadPlanSP();
1480 
1481  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
1482  return thread_plan_sp;
1483 }
1484 
1485 ThreadPlanSP Thread::QueueThreadPlanForRunToAddress(bool abort_other_plans,
1486  Address &target_addr,
1487  bool stop_other_threads,
1488  Status &status) {
1489  ThreadPlanSP thread_plan_sp(
1490  new ThreadPlanRunToAddress(*this, target_addr, stop_other_threads));
1491 
1492  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
1493  return thread_plan_sp;
1494 }
1495 
1497  bool abort_other_plans, lldb::addr_t *address_list, size_t num_addresses,
1498  bool stop_other_threads, uint32_t frame_idx, Status &status) {
1499  ThreadPlanSP thread_plan_sp(new ThreadPlanStepUntil(
1500  *this, address_list, num_addresses, stop_other_threads, frame_idx));
1501 
1502  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
1503  return thread_plan_sp;
1504 }
1505 
1507  bool abort_other_plans, const char *class_name, bool stop_other_threads,
1508  Status &status) {
1509  ThreadPlanSP thread_plan_sp(new ThreadPlanPython(*this, class_name));
1510 
1511  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
1512  return thread_plan_sp;
1513 }
1514 
1516 
1517 static void PrintPlanElement(Stream *s, const ThreadPlanSP &plan,
1518  lldb::DescriptionLevel desc_level,
1519  int32_t elem_idx) {
1520  s->IndentMore();
1521  s->Indent();
1522  s->Printf("Element %d: ", elem_idx);
1523  plan->GetDescription(s, desc_level);
1524  s->EOL();
1525  s->IndentLess();
1526 }
1527 
1528 static void PrintPlanStack(Stream *s,
1529  const std::vector<lldb::ThreadPlanSP> &plan_stack,
1530  lldb::DescriptionLevel desc_level,
1531  bool include_internal) {
1532  int32_t print_idx = 0;
1533  for (ThreadPlanSP plan_sp : plan_stack) {
1534  if (include_internal || !plan_sp->GetPrivate()) {
1535  PrintPlanElement(s, plan_sp, desc_level, print_idx++);
1536  }
1537  }
1538 }
1539 
1541  bool include_internal,
1542  bool ignore_boring_threads) const {
1543  uint32_t stack_size;
1544 
1545  if (ignore_boring_threads) {
1546  uint32_t stack_size = m_plan_stack.size();
1547  uint32_t completed_stack_size = m_completed_plan_stack.size();
1548  uint32_t discarded_stack_size = m_discarded_plan_stack.size();
1549  if (stack_size == 1 && completed_stack_size == 0 &&
1550  discarded_stack_size == 0) {
1551  s->Printf("thread #%u: tid = 0x%4.4" PRIx64 "\n", GetIndexID(), GetID());
1552  s->IndentMore();
1553  s->Indent();
1554  s->Printf("No active thread plans\n");
1555  s->IndentLess();
1556  return;
1557  }
1558  }
1559 
1560  s->Indent();
1561  s->Printf("thread #%u: tid = 0x%4.4" PRIx64 ":\n", GetIndexID(), GetID());
1562  s->IndentMore();
1563  s->Indent();
1564  s->Printf("Active plan stack:\n");
1565  PrintPlanStack(s, m_plan_stack, desc_level, include_internal);
1566 
1567  stack_size = m_completed_plan_stack.size();
1568  if (stack_size > 0) {
1569  s->Indent();
1570  s->Printf("Completed Plan Stack:\n");
1571  PrintPlanStack(s, m_completed_plan_stack, desc_level, include_internal);
1572  }
1573 
1574  stack_size = m_discarded_plan_stack.size();
1575  if (stack_size > 0) {
1576  s->Indent();
1577  s->Printf("Discarded Plan Stack:\n");
1578  PrintPlanStack(s, m_discarded_plan_stack, desc_level, include_internal);
1579  }
1580 
1581  s->IndentLess();
1582 }
1583 
1585  TargetSP target_sp;
1586  ProcessSP process_sp(GetProcess());
1587  if (process_sp)
1588  target_sp = process_sp->CalculateTarget();
1589  return target_sp;
1590 }
1591 
1592 ProcessSP Thread::CalculateProcess() { return GetProcess(); }
1593 
1594 ThreadSP Thread::CalculateThread() { return shared_from_this(); }
1595 
1596 StackFrameSP Thread::CalculateStackFrame() { return StackFrameSP(); }
1597 
1599  exe_ctx.SetContext(shared_from_this());
1600 }
1601 
1602 StackFrameListSP Thread::GetStackFrameList() {
1603  std::lock_guard<std::recursive_mutex> guard(m_frame_mutex);
1604 
1605  if (!m_curr_frames_sp)
1607  std::make_shared<StackFrameList>(*this, m_prev_frames_sp, true);
1608 
1609  return m_curr_frames_sp;
1610 }
1611 
1613  std::lock_guard<std::recursive_mutex> guard(m_frame_mutex);
1614 
1615  Unwind *unwinder = GetUnwinder();
1616  if (unwinder)
1617  unwinder->Clear();
1618 
1619  // Only store away the old "reference" StackFrameList if we got all its
1620  // frames:
1621  // FIXME: At some point we can try to splice in the frames we have fetched
1622  // into
1623  // the new frame as we make it, but let's not try that now.
1624  if (m_curr_frames_sp && m_curr_frames_sp->GetAllFramesFetched())
1626  m_curr_frames_sp.reset();
1627 
1628  m_extended_info.reset();
1629  m_extended_info_fetched = false;
1630 }
1631 
1632 lldb::StackFrameSP Thread::GetFrameWithConcreteFrameIndex(uint32_t unwind_idx) {
1633  return GetStackFrameList()->GetFrameWithConcreteFrameIndex(unwind_idx);
1634 }
1635 
1637  lldb::ValueObjectSP return_value_sp,
1638  bool broadcast) {
1639  StackFrameSP frame_sp = GetStackFrameAtIndex(frame_idx);
1640  Status return_error;
1641 
1642  if (!frame_sp) {
1643  return_error.SetErrorStringWithFormat(
1644  "Could not find frame with index %d in thread 0x%" PRIx64 ".",
1645  frame_idx, GetID());
1646  }
1647 
1648  return ReturnFromFrame(frame_sp, return_value_sp, broadcast);
1649 }
1650 
1651 Status Thread::ReturnFromFrame(lldb::StackFrameSP frame_sp,
1652  lldb::ValueObjectSP return_value_sp,
1653  bool broadcast) {
1654  Status return_error;
1655 
1656  if (!frame_sp) {
1657  return_error.SetErrorString("Can't return to a null frame.");
1658  return return_error;
1659  }
1660 
1661  Thread *thread = frame_sp->GetThread().get();
1662  uint32_t older_frame_idx = frame_sp->GetFrameIndex() + 1;
1663  StackFrameSP older_frame_sp = thread->GetStackFrameAtIndex(older_frame_idx);
1664  if (!older_frame_sp) {
1665  return_error.SetErrorString("No older frame to return to.");
1666  return return_error;
1667  }
1668 
1669  if (return_value_sp) {
1670  lldb::ABISP abi = thread->GetProcess()->GetABI();
1671  if (!abi) {
1672  return_error.SetErrorString("Could not find ABI to set return value.");
1673  return return_error;
1674  }
1675  SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextFunction);
1676 
1677  // FIXME: ValueObject::Cast doesn't currently work correctly, at least not
1678  // for scalars.
1679  // Turn that back on when that works.
1680  if (/* DISABLES CODE */ (0) && sc.function != nullptr) {
1681  Type *function_type = sc.function->GetType();
1682  if (function_type) {
1683  CompilerType return_type =
1685  if (return_type) {
1686  StreamString s;
1687  return_type.DumpTypeDescription(&s);
1688  ValueObjectSP cast_value_sp = return_value_sp->Cast(return_type);
1689  if (cast_value_sp) {
1690  cast_value_sp->SetFormat(eFormatHex);
1691  return_value_sp = cast_value_sp;
1692  }
1693  }
1694  }
1695  }
1696 
1697  return_error = abi->SetReturnValueObject(older_frame_sp, return_value_sp);
1698  if (!return_error.Success())
1699  return return_error;
1700  }
1701 
1702  // Now write the return registers for the chosen frame: Note, we can't use
1703  // ReadAllRegisterValues->WriteAllRegisterValues, since the read & write cook
1704  // their data
1705 
1706  StackFrameSP youngest_frame_sp = thread->GetStackFrameAtIndex(0);
1707  if (youngest_frame_sp) {
1708  lldb::RegisterContextSP reg_ctx_sp(youngest_frame_sp->GetRegisterContext());
1709  if (reg_ctx_sp) {
1710  bool copy_success = reg_ctx_sp->CopyFromRegisterContext(
1711  older_frame_sp->GetRegisterContext());
1712  if (copy_success) {
1713  thread->DiscardThreadPlans(true);
1714  thread->ClearStackFrames();
1717  new ThreadEventData(this->shared_from_this()));
1718  } else {
1719  return_error.SetErrorString("Could not reset register values.");
1720  }
1721  } else {
1722  return_error.SetErrorString("Frame has no register context.");
1723  }
1724  } else {
1725  return_error.SetErrorString("Returned past top frame.");
1726  }
1727  return return_error;
1728 }
1729 
1730 static void DumpAddressList(Stream &s, const std::vector<Address> &list,
1731  ExecutionContextScope *exe_scope) {
1732  for (size_t n = 0; n < list.size(); n++) {
1733  s << "\t";
1734  list[n].Dump(&s, exe_scope, Address::DumpStyleResolvedDescription,
1736  s << "\n";
1737  }
1738 }
1739 
1741  bool can_leave_function, std::string *warnings) {
1743  Target *target = exe_ctx.GetTargetPtr();
1744  TargetSP target_sp = exe_ctx.GetTargetSP();
1745  RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
1746  StackFrame *frame = exe_ctx.GetFramePtr();
1747  const SymbolContext &sc = frame->GetSymbolContext(eSymbolContextFunction);
1748 
1749  // Find candidate locations.
1750  std::vector<Address> candidates, within_function, outside_function;
1751  target->GetImages().FindAddressesForLine(target_sp, file, line, sc.function,
1752  within_function, outside_function);
1753 
1754  // If possible, we try and stay within the current function. Within a
1755  // function, we accept multiple locations (optimized code may do this,
1756  // there's no solution here so we do the best we can). However if we're
1757  // trying to leave the function, we don't know how to pick the right
1758  // location, so if there's more than one then we bail.
1759  if (!within_function.empty())
1760  candidates = within_function;
1761  else if (outside_function.size() == 1 && can_leave_function)
1762  candidates = outside_function;
1763 
1764  // Check if we got anything.
1765  if (candidates.empty()) {
1766  if (outside_function.empty()) {
1767  return Status("Cannot locate an address for %s:%i.",
1768  file.GetFilename().AsCString(), line);
1769  } else if (outside_function.size() == 1) {
1770  return Status("%s:%i is outside the current function.",
1771  file.GetFilename().AsCString(), line);
1772  } else {
1773  StreamString sstr;
1774  DumpAddressList(sstr, outside_function, target);
1775  return Status("%s:%i has multiple candidate locations:\n%s",
1776  file.GetFilename().AsCString(), line, sstr.GetData());
1777  }
1778  }
1779 
1780  // Accept the first location, warn about any others.
1781  Address dest = candidates[0];
1782  if (warnings && candidates.size() > 1) {
1783  StreamString sstr;
1784  sstr.Printf("%s:%i appears multiple times in this function, selecting the "
1785  "first location:\n",
1786  file.GetFilename().AsCString(), line);
1787  DumpAddressList(sstr, candidates, target);
1788  *warnings = sstr.GetString();
1789  }
1790 
1791  if (!reg_ctx->SetPC(dest))
1792  return Status("Cannot change PC to target address.");
1793 
1794  return Status();
1795 }
1796 
1798  bool stop_format) {
1799  ExecutionContext exe_ctx(shared_from_this());
1800  Process *process = exe_ctx.GetProcessPtr();
1801  if (process == nullptr)
1802  return;
1803 
1804  StackFrameSP frame_sp;
1805  SymbolContext frame_sc;
1806  if (frame_idx != LLDB_INVALID_FRAME_ID) {
1807  frame_sp = GetStackFrameAtIndex(frame_idx);
1808  if (frame_sp) {
1809  exe_ctx.SetFrameSP(frame_sp);
1810  frame_sc = frame_sp->GetSymbolContext(eSymbolContextEverything);
1811  }
1812  }
1813 
1814  const FormatEntity::Entry *thread_format;
1815  if (stop_format)
1816  thread_format = exe_ctx.GetTargetRef().GetDebugger().GetThreadStopFormat();
1817  else
1818  thread_format = exe_ctx.GetTargetRef().GetDebugger().GetThreadFormat();
1819 
1820  assert(thread_format);
1821 
1822  FormatEntity::Format(*thread_format, strm, frame_sp ? &frame_sc : nullptr,
1823  &exe_ctx, nullptr, nullptr, false, false);
1824 }
1825 
1827 
1829 
1831 
1832 addr_t Thread::GetThreadLocalData(const ModuleSP module,
1833  lldb::addr_t tls_file_addr) {
1834  // The default implementation is to ask the dynamic loader for it. This can
1835  // be overridden for specific platforms.
1836  DynamicLoader *loader = GetProcess()->GetDynamicLoader();
1837  if (loader)
1838  return loader->GetThreadLocalData(module, shared_from_this(),
1839  tls_file_addr);
1840  else
1841  return LLDB_INVALID_ADDRESS;
1842 }
1843 
1845  Process *process = GetProcess().get();
1846  if (process) {
1847  SystemRuntime *runtime = process->GetSystemRuntime();
1848  if (runtime) {
1849  return runtime->SafeToCallFunctionsOnThisThread(shared_from_this());
1850  }
1851  }
1852  return true;
1853 }
1854 
1855 lldb::StackFrameSP
1857  return GetStackFrameList()->GetStackFrameSPForStackFramePtr(stack_frame_ptr);
1858 }
1859 
1861  switch (reason) {
1862  case eStopReasonInvalid:
1863  return "invalid";
1864  case eStopReasonNone:
1865  return "none";
1866  case eStopReasonTrace:
1867  return "trace";
1868  case eStopReasonBreakpoint:
1869  return "breakpoint";
1870  case eStopReasonWatchpoint:
1871  return "watchpoint";
1872  case eStopReasonSignal:
1873  return "signal";
1874  case eStopReasonException:
1875  return "exception";
1876  case eStopReasonExec:
1877  return "exec";
1879  return "plan complete";
1881  return "thread exiting";
1883  return "instrumentation break";
1884  }
1885 
1886  static char unknown_state_string[64];
1887  snprintf(unknown_state_string, sizeof(unknown_state_string),
1888  "StopReason = %i", reason);
1889  return unknown_state_string;
1890 }
1891 
1893  switch (mode) {
1894  case eOnlyThisThread:
1895  return "only this thread";
1896  case eAllThreads:
1897  return "all threads";
1898  case eOnlyDuringStepping:
1899  return "only during stepping";
1900  }
1901 
1902  static char unknown_state_string[64];
1903  snprintf(unknown_state_string, sizeof(unknown_state_string), "RunMode = %i",
1904  mode);
1905  return unknown_state_string;
1906 }
1907 
1908 size_t Thread::GetStatus(Stream &strm, uint32_t start_frame,
1909  uint32_t num_frames, uint32_t num_frames_with_source,
1910  bool stop_format, bool only_stacks) {
1911 
1912  if (!only_stacks) {
1913  ExecutionContext exe_ctx(shared_from_this());
1914  Target *target = exe_ctx.GetTargetPtr();
1915  Process *process = exe_ctx.GetProcessPtr();
1916  strm.Indent();
1917  bool is_selected = false;
1918  if (process) {
1919  if (process->GetThreadList().GetSelectedThread().get() == this)
1920  is_selected = true;
1921  }
1922  strm.Printf("%c ", is_selected ? '*' : ' ');
1923  if (target && target->GetDebugger().GetUseExternalEditor()) {
1924  StackFrameSP frame_sp = GetStackFrameAtIndex(start_frame);
1925  if (frame_sp) {
1926  SymbolContext frame_sc(
1927  frame_sp->GetSymbolContext(eSymbolContextLineEntry));
1928  if (frame_sc.line_entry.line != 0 && frame_sc.line_entry.file) {
1929  Host::OpenFileInExternalEditor(frame_sc.line_entry.file,
1930  frame_sc.line_entry.line);
1931  }
1932  }
1933  }
1934 
1935  DumpUsingSettingsFormat(strm, start_frame, stop_format);
1936  }
1937 
1938  size_t num_frames_shown = 0;
1939  if (num_frames > 0) {
1940  strm.IndentMore();
1941 
1942  const bool show_frame_info = true;
1943  const bool show_frame_unique = only_stacks;
1944  const char *selected_frame_marker = nullptr;
1945  if (num_frames == 1 || only_stacks ||
1946  (GetID() != GetProcess()->GetThreadList().GetSelectedThread()->GetID()))
1947  strm.IndentMore();
1948  else
1949  selected_frame_marker = "* ";
1950 
1951  num_frames_shown = GetStackFrameList()->GetStatus(
1952  strm, start_frame, num_frames, show_frame_info, num_frames_with_source,
1953  show_frame_unique, selected_frame_marker);
1954  if (num_frames == 1)
1955  strm.IndentLess();
1956  strm.IndentLess();
1957  }
1958  return num_frames_shown;
1959 }
1960 
1962  bool print_json_thread, bool print_json_stopinfo) {
1963  const bool stop_format = false;
1964  DumpUsingSettingsFormat(strm, 0, stop_format);
1965  strm.Printf("\n");
1966 
1967  StructuredData::ObjectSP thread_info = GetExtendedInfo();
1968 
1969  if (print_json_thread || print_json_stopinfo) {
1970  if (thread_info && print_json_thread) {
1971  thread_info->Dump(strm);
1972  strm.Printf("\n");
1973  }
1974 
1975  if (print_json_stopinfo && m_stop_info_sp) {
1976  StructuredData::ObjectSP stop_info = m_stop_info_sp->GetExtendedInfo();
1977  if (stop_info) {
1978  stop_info->Dump(strm);
1979  strm.Printf("\n");
1980  }
1981  }
1982 
1983  return true;
1984  }
1985 
1986  if (thread_info) {
1987  StructuredData::ObjectSP activity =
1988  thread_info->GetObjectForDotSeparatedPath("activity");
1989  StructuredData::ObjectSP breadcrumb =
1990  thread_info->GetObjectForDotSeparatedPath("breadcrumb");
1991  StructuredData::ObjectSP messages =
1992  thread_info->GetObjectForDotSeparatedPath("trace_messages");
1993 
1994  bool printed_activity = false;
1995  if (activity && activity->GetType() == eStructuredDataTypeDictionary) {
1996  StructuredData::Dictionary *activity_dict = activity->GetAsDictionary();
1997  StructuredData::ObjectSP id = activity_dict->GetValueForKey("id");
1998  StructuredData::ObjectSP name = activity_dict->GetValueForKey("name");
1999  if (name && name->GetType() == eStructuredDataTypeString && id &&
2000  id->GetType() == eStructuredDataTypeInteger) {
2001  strm.Format(" Activity '{0}', {1:x}\n",
2002  name->GetAsString()->GetValue(),
2003  id->GetAsInteger()->GetValue());
2004  }
2005  printed_activity = true;
2006  }
2007  bool printed_breadcrumb = false;
2008  if (breadcrumb && breadcrumb->GetType() == eStructuredDataTypeDictionary) {
2009  if (printed_activity)
2010  strm.Printf("\n");
2011  StructuredData::Dictionary *breadcrumb_dict =
2012  breadcrumb->GetAsDictionary();
2013  StructuredData::ObjectSP breadcrumb_text =
2014  breadcrumb_dict->GetValueForKey("name");
2015  if (breadcrumb_text &&
2016  breadcrumb_text->GetType() == eStructuredDataTypeString) {
2017  strm.Format(" Current Breadcrumb: {0}\n",
2018  breadcrumb_text->GetAsString()->GetValue());
2019  }
2020  printed_breadcrumb = true;
2021  }
2022  if (messages && messages->GetType() == eStructuredDataTypeArray) {
2023  if (printed_breadcrumb)
2024  strm.Printf("\n");
2025  StructuredData::Array *messages_array = messages->GetAsArray();
2026  const size_t msg_count = messages_array->GetSize();
2027  if (msg_count > 0) {
2028  strm.Printf(" %zu trace messages:\n", msg_count);
2029  for (size_t i = 0; i < msg_count; i++) {
2030  StructuredData::ObjectSP message = messages_array->GetItemAtIndex(i);
2031  if (message && message->GetType() == eStructuredDataTypeDictionary) {
2032  StructuredData::Dictionary *message_dict =
2033  message->GetAsDictionary();
2034  StructuredData::ObjectSP message_text =
2035  message_dict->GetValueForKey("message");
2036  if (message_text &&
2037  message_text->GetType() == eStructuredDataTypeString) {
2038  strm.Format(" {0}\n", message_text->GetAsString()->GetValue());
2039  }
2040  }
2041  }
2042  }
2043  }
2044  }
2045 
2046  return true;
2047 }
2048 
2049 size_t Thread::GetStackFrameStatus(Stream &strm, uint32_t first_frame,
2050  uint32_t num_frames, bool show_frame_info,
2051  uint32_t num_frames_with_source) {
2052  return GetStackFrameList()->GetStatus(
2053  strm, first_frame, num_frames, show_frame_info, num_frames_with_source);
2054 }
2055 
2057  if (!m_unwinder_up) {
2058  const ArchSpec target_arch(CalculateTarget()->GetArchitecture());
2059  const llvm::Triple::ArchType machine = target_arch.GetMachine();
2060  switch (machine) {
2061  case llvm::Triple::x86_64:
2062  case llvm::Triple::x86:
2063  case llvm::Triple::arm:
2064  case llvm::Triple::aarch64:
2065  case llvm::Triple::thumb:
2066  case llvm::Triple::mips:
2067  case llvm::Triple::mipsel:
2068  case llvm::Triple::mips64:
2069  case llvm::Triple::mips64el:
2070  case llvm::Triple::ppc:
2071  case llvm::Triple::ppc64:
2072  case llvm::Triple::ppc64le:
2073  case llvm::Triple::systemz:
2074  case llvm::Triple::hexagon:
2075  m_unwinder_up.reset(new UnwindLLDB(*this));
2076  break;
2077 
2078  default:
2079  if (target_arch.GetTriple().getVendor() == llvm::Triple::Apple)
2080  m_unwinder_up.reset(new UnwindMacOSXFrameBackchain(*this));
2081  break;
2082  }
2083  }
2084  return m_unwinder_up.get();
2085 }
2086 
2088  ClearStackFrames();
2089  m_reg_context_sp.reset();
2090 }
2091 
2093  // If we are currently stopped at a breakpoint, always return that stopinfo
2094  // and don't reset it. This allows threads to maintain their breakpoint
2095  // stopinfo, such as when thread-stepping in multithreaded programs.
2096  if (m_stop_info_sp) {
2097  StopReason stop_reason = m_stop_info_sp->GetStopReason();
2098  if (stop_reason == lldb::eStopReasonBreakpoint) {
2099  uint64_t value = m_stop_info_sp->GetValue();
2100  lldb::RegisterContextSP reg_ctx_sp(GetRegisterContext());
2101  if (reg_ctx_sp) {
2102  lldb::addr_t pc = reg_ctx_sp->GetPC();
2103  BreakpointSiteSP bp_site_sp =
2104  GetProcess()->GetBreakpointSiteList().FindByAddress(pc);
2105  if (bp_site_sp && static_cast<break_id_t>(value) == bp_site_sp->GetID())
2106  return true;
2107  }
2108  }
2109  }
2110  return false;
2111 }
2112 
2113 Status Thread::StepIn(bool source_step,
2114  LazyBool step_in_avoids_code_without_debug_info,
2115  LazyBool step_out_avoids_code_without_debug_info)
2116 
2117 {
2118  Status error;
2119  Process *process = GetProcess().get();
2120  if (StateIsStoppedState(process->GetState(), true)) {
2121  StackFrameSP frame_sp = GetStackFrameAtIndex(0);
2122  ThreadPlanSP new_plan_sp;
2123  const lldb::RunMode run_mode = eOnlyThisThread;
2124  const bool abort_other_plans = false;
2125 
2126  if (source_step && frame_sp && frame_sp->HasDebugInformation()) {
2127  SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
2128  new_plan_sp = QueueThreadPlanForStepInRange(
2129  abort_other_plans, sc.line_entry, sc, nullptr, run_mode, error,
2130  step_in_avoids_code_without_debug_info,
2131  step_out_avoids_code_without_debug_info);
2132  } else {
2134  false, abort_other_plans, run_mode, error);
2135  }
2136 
2137  new_plan_sp->SetIsMasterPlan(true);
2138  new_plan_sp->SetOkayToDiscard(false);
2139 
2140  // Why do we need to set the current thread by ID here???
2142  error = process->Resume();
2143  } else {
2144  error.SetErrorString("process not stopped");
2145  }
2146  return error;
2147 }
2148 
2149 Status Thread::StepOver(bool source_step,
2150  LazyBool step_out_avoids_code_without_debug_info) {
2151  Status error;
2152  Process *process = GetProcess().get();
2153  if (StateIsStoppedState(process->GetState(), true)) {
2154  StackFrameSP frame_sp = GetStackFrameAtIndex(0);
2155  ThreadPlanSP new_plan_sp;
2156 
2157  const lldb::RunMode run_mode = eOnlyThisThread;
2158  const bool abort_other_plans = false;
2159 
2160  if (source_step && frame_sp && frame_sp->HasDebugInformation()) {
2161  SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
2162  new_plan_sp = QueueThreadPlanForStepOverRange(
2163  abort_other_plans, sc.line_entry, sc, run_mode, error,
2164  step_out_avoids_code_without_debug_info);
2165  } else {
2167  true, abort_other_plans, run_mode, error);
2168  }
2169 
2170  new_plan_sp->SetIsMasterPlan(true);
2171  new_plan_sp->SetOkayToDiscard(false);
2172 
2173  // Why do we need to set the current thread by ID here???
2175  error = process->Resume();
2176  } else {
2177  error.SetErrorString("process not stopped");
2178  }
2179  return error;
2180 }
2181 
2183  Status error;
2184  Process *process = GetProcess().get();
2185  if (StateIsStoppedState(process->GetState(), true)) {
2186  const bool first_instruction = false;
2187  const bool stop_other_threads = false;
2188  const bool abort_other_plans = false;
2189 
2190  ThreadPlanSP new_plan_sp(QueueThreadPlanForStepOut(
2191  abort_other_plans, nullptr, first_instruction, stop_other_threads,
2192  eVoteYes, eVoteNoOpinion, 0, error));
2193 
2194  new_plan_sp->SetIsMasterPlan(true);
2195  new_plan_sp->SetOkayToDiscard(false);
2196 
2197  // Why do we need to set the current thread by ID here???
2199  error = process->Resume();
2200  } else {
2201  error.SetErrorString("process not stopped");
2202  }
2203  return error;
2204 }
2205 
2207  if (auto frame_sp = GetStackFrameAtIndex(0))
2208  if (auto recognized_frame = frame_sp->GetRecognizedFrame())
2209  if (auto e = recognized_frame->GetExceptionObject())
2210  return e;
2211 
2212  // FIXME: For now, only ObjC exceptions are supported. This should really
2213  // iterate over all language runtimes and ask them all to give us the current
2214  // exception.
2215  if (auto runtime = GetProcess()->GetObjCLanguageRuntime())
2216  if (auto e = runtime->GetExceptionObjectForThread(shared_from_this()))
2217  return e;
2218 
2219  return ValueObjectSP();
2220 }
2221 
2223  ValueObjectSP exception = GetCurrentException();
2224  if (!exception) return ThreadSP();
2225 
2226  // FIXME: For now, only ObjC exceptions are supported. This should really
2227  // iterate over all language runtimes and ask them all to give us the current
2228  // exception.
2229  auto runtime = GetProcess()->GetObjCLanguageRuntime();
2230  if (!runtime) return ThreadSP();
2231 
2232  return runtime->GetBacktraceThreadFromException(exception);
2233 }
static lldb::StopInfoSP CreateStopReasonWithPlan(lldb::ThreadPlanSP &plan, lldb::ValueObjectSP return_valobj_sp, lldb::ExpressionVariableSP expression_variable_sp)
Definition: StopInfo.cpp:1131
static const DynamicLoaderDarwinKernelPropertiesSP & GetGlobalProperties()
static lldb::StackFrameSP GetStackFrameFromEvent(const Event *event_ptr)
Definition: Thread.cpp:222
ConstString & GetFilename()
Filename string get accessor.
Definition: FileSpec.cpp:369
A line table entry class.
Definition: LineEntry.h:20
lldb::StateType m_temporary_resume_state
This state records what the thread was told to do by the thread plan logic for the current resume...
Definition: Thread.h:1243
StructuredData::ObjectSP GetExtendedInfo()
Retrieve a dictionary of information about this thread.
Definition: Thread.h:269
virtual Status StepOut()
Default implementation for stepping out.
Definition: Thread.cpp:2182
static void SettingsTerminate()
Definition: Thread.cpp:1828
ThreadPlan * GetPreviousPlan(ThreadPlan *plan)
Definition: Thread.cpp:1157
lldb::StackFrameSP GetSelectedFrame()
Definition: Thread.cpp:317
#define LIBLLDB_LOG_OBJECT
Definition: Logging.h:25
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
lldb::ThreadSP GetSelectedThread()
Definition: ThreadList.cpp:649
uint32_t m_stop_info_stop_id
Definition: Thread.h:1211
std::unique_ptr< lldb_private::Unwind > m_unwinder_up
It gets set in Thread::ShouldResume.
Definition: Thread.h:1248
virtual lldb::ThreadPlanSP QueueThreadPlanForStepOutNoShouldStop(bool abort_other_plans, SymbolContext *addr_context, bool first_insn, bool stop_other_threads, Vote stop_vote, Vote run_vote, uint32_t frame_idx, Status &status, bool continue_to_next_branch=false)
Queue the plan used to step out of the function at the current PC of a thread.
Definition: Thread.cpp:1454
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:224
std::vector< lldb::ThreadPlanSP > m_completed_plan_stack
Definition: Thread.h:122
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
lldb::StateType GetResumeState() const
Gets the USER resume state for this thread.
Definition: Thread.h:200
lldb::StackFrameListSP m_prev_frames_sp
The previous stack frames from the last time this thread stopped.
Definition: Thread.h:1236
static void PrintPlanElement(Stream *s, const ThreadPlanSP &plan, lldb::DescriptionLevel desc_level, int32_t elem_idx)
Definition: Thread.cpp:1517
lldb::StateType m_resume_state
This state is used to force a thread to be suspended from outside the ThreadPlan logic.
Definition: Thread.h:1240
Status UnwindInnermostExpression()
Unwinds the thread stack for the innermost expression plan currently on the thread plan stack...
Definition: Thread.cpp:1347
lldb::OptionValuePropertiesSP m_collection_sp
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
lldb::ThreadSP CalculateThread() override
Definition: Thread.cpp:1594
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
virtual void DidStop()
Definition: Thread.cpp:714
virtual bool CalculateStopInfo()=0
static bool GetRestartedFromEvent(const Event *event_ptr)
Definition: Process.cpp:4128
void SetContext(const lldb::TargetSP &target_sp, bool get_process)
void DiscardThreadPlans(bool force)
Discards the plans queued on the plan stack of the current thread.
Definition: Thread.cpp:1285
virtual bool CheckpointThreadState(ThreadStateCheckpoint &saved_state)
Definition: Thread.cpp:523
static const ThreadEventData * GetEventDataFromEvent(const Event *event_ptr)
Definition: Thread.cpp:195
Status ReturnFromFrameWithIndex(uint32_t frame_idx, lldb::ValueObjectSP return_value_sp, bool broadcast=false)
Definition: Thread.cpp:1636
virtual Status StepIn(bool source_step, LazyBool step_in_avoids_code_without_debug_info=eLazyBoolCalculate, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
Default implementation for stepping into.
Definition: Thread.cpp:2113
#define LLDB_INVALID_SIGNAL_NUMBER
Definition: lldb-defines.h:95
lldb::RegisterCheckpointSP register_backup_sp
Definition: Thread.h:124
AddressRange GetSameLineContiguousAddressRange(bool include_inlined_functions) const
Give the range for this LineEntry + any additional LineEntries for this same source line that are con...
Definition: LineEntry.cpp:193
void SetState(lldb::StateType state)
Definition: Thread.cpp:587
static constexpr PropertyDefinition g_properties[]
Definition: Thread.cpp:66
lldb::StopReason GetStopReason()
Definition: Thread.cpp:455
bool DiscardUserThreadPlansUpToIndex(uint32_t thread_index)
Discards the plans queued on the plan stack of the current thread up to and including the plan in tha...
Definition: Thread.cpp:1225
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:49
A mix in class that contains a generic user ID.
Definition: UserID.h:33
lldb::StackFrameSP CalculateStackFrame() override
Definition: Thread.cpp:1596
void FunctionOptimizationWarning(lldb_private::StackFrame *frame)
Definition: Thread.cpp:372
A file utility class.
Definition: FileSpec.h:55
"lldb/Utility/RegularExpression.h" A C++ wrapper class for regex.
virtual lldb::StackFrameSP GetFrameWithConcreteFrameIndex(uint32_t unwind_idx)
Definition: Thread.cpp:1632
An architecture specification class.
Definition: ArchSpec.h:32
ThreadList & GetThreadList()
Definition: Process.h:2045
lldb::StateType GetState()
Get accessor for the current process state.
Definition: Process.cpp:1347
virtual lldb::ThreadPlanSP QueueThreadPlanForStepInRange(bool abort_other_plans, const AddressRange &range, const SymbolContext &addr_context, const char *step_in_target, lldb::RunMode stop_other_threads, Status &status, LazyBool step_in_avoids_code_without_debug_info=eLazyBoolCalculate, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
Queues the plan used to step through an address range, stepping into functions.
Definition: Thread.cpp:1406
void CalculateExecutionContext(ExecutionContext &exe_ctx) override
Reconstruct the object&#39;s execution context into sc.
Definition: Thread.cpp:1598
An event broadcasting class.
Definition: Broadcaster.h:250
virtual lldb::StopInfoSP GetPrivateStopInfo()
Definition: Thread.cpp:414
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
std::vector< lldb::ThreadPlanSP > plan_stack
Definition: Thread.h:1180
bool StopInfoIsUpToDate() const
Definition: Thread.cpp:462
void SetStopInfoToNothing()
Definition: Thread.cpp:511
Process or thread is stopped and can be examined.
lldb::StateType m_state
The state of our process.
Definition: Thread.h:1222
const char * GetData() const
Definition: StreamString.h:43
virtual lldb::ThreadPlanSP QueueThreadPlanForStepThrough(StackID &return_stack_id, bool abort_other_plans, bool stop_other_threads, Status &status)
Gets the plan used to step through the code that steps from a function call site at the current PC in...
Definition: Thread.cpp:1472
virtual lldb::user_id_t GetProtocolID() const
Definition: Thread.h:1060
lldb::StateType GetState() const
Definition: Thread.cpp:581
lldb::RegisterContextSP m_reg_context_sp
The register context for this thread&#39;s current register state.
Definition: Thread.h:1220
virtual lldb::ThreadPlanSP QueueThreadPlanForStepSingleInstruction(bool step_over, bool abort_other_plans, bool stop_other_threads, Status &status)
Queues the plan used to step one instruction from the current PC of thread.
Definition: Thread.cpp:1370
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
virtual lldb::addr_t GetThreadLocalData(const lldb::ModuleSP module, lldb::addr_t tls_file_addr)
Retrieves the per-module TLS block for a thread.
Definition: Thread.cpp:1832
static const ThreadPropertiesSP & GetGlobalProperties()
Definition: Thread.cpp:58
bool GetDescription(Stream &s, lldb::DescriptionLevel level, bool print_json_thread, bool print_json_stopinfo)
Definition: Thread.cpp:1961
lldb::ValueObjectSP GetCurrentException()
Definition: Thread.cpp:2206
plan_stack m_discarded_plan_stack
Plans that have been discarded by this stop.
Definition: Thread.h:1229
int m_resume_signal
The signal that should be used when continuing this thread.
Definition: Thread.h:1238
virtual bool ShouldStop(Event *event_ptr)=0
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:431
Type * GetType()
Get accessor for the type that describes the function return value type, and parameter types...
Definition: Function.cpp:443
std::recursive_mutex m_state_mutex
Multithreaded protection for m_state.
Definition: Thread.h:1224
virtual bool RestoreThreadStateFromCheckpoint(ThreadStateCheckpoint &saved_state)
Definition: Thread.cpp:570
void BroadcastEvent(lldb::EventSP &event_sp)
Broadcast an event which has no associated data.
Definition: Broadcaster.h:283
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame&#39;s current pc value.
Definition: StackFrame.cpp:267
ThreadPlan * GetCurrentPlan()
Gets the plan which will execute next on the plan stack.
Definition: Thread.cpp:1089
Function * function
The Function for a given query.
void SetFrameSP(const lldb::StackFrameSP &frame_sp)
Set accessor to set only the frame shared pointer.
void EnableTracer(bool value, bool single_step)
Definition: Thread.cpp:1209
virtual lldb::addr_t GetThreadPointer()
Retrieves the per-thread data area.
Definition: Thread.cpp:1830
#define UINT32_MAX
Definition: lldb-defines.h:31
plan_stack m_plan_stack
The stack of plans this thread is executing.
Definition: Thread.h:1225
virtual lldb::ThreadSP GetBackingThread() const
Definition: Thread.h:456
lldb::ThreadPlanSP GetCompletedPlan()
Gets the outer-most plan that was popped off the plan stack in the most recent stop.
Definition: Thread.cpp:1095
ThreadPlanKind GetKind() const
Definition: ThreadPlan.h:468
virtual lldb_private::Unwind * GetUnwinder()
Definition: Thread.cpp:2056
void Format(const char *format, Args &&... args)
Definition: Stream.h:422
lldb::StopInfoSP m_stop_info_sp
The private stop reason for this thread.
Definition: Thread.h:1210
Target * GetTargetPtr() const
Returns a pointer to the target object.
const FormatEntity::Entry * GetThreadFormat() const
Definition: Debugger.cpp:420
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:86
virtual lldb::ThreadPlanSP QueueFundamentalPlan(bool abort_other_plans)
Queues the base plan for a thread.
Definition: Thread.cpp:1364
LazyBool m_override_should_notify
Definition: Thread.h:1251
bool StateIsStoppedState(lldb::StateType state, bool must_exist)
Check if a state represents a state where the process or thread is stopped.
Definition: State.cpp:89
virtual const char * GetName()
Definition: Thread.h:277
size_t GetStatus(Stream &strm, uint32_t start_frame, uint32_t num_frames, uint32_t num_frames_with_source, bool stop_format, bool only_stacks=false)
Definition: Thread.cpp:1908
Vote ShouldReportStop(Event *event_ptr)
Definition: Thread.cpp:939
const Property * GetPropertyAtIndex(const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const override
Definition: Thread.cpp:104
Status JumpToLine(const FileSpec &file, uint32_t line, bool can_leave_function, std::string *warnings=nullptr)
Definition: Thread.cpp:1740
lldb::ProcessWP m_process_wp
The process that owns this thread.
Definition: Thread.h:1209
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:57
lldb::StackFrameListSP GetStackFrameList()
Definition: Thread.cpp:1602
void SetStopInfo(const lldb::StopInfoSP &stop_info_sp)
Definition: Thread.cpp:477
#define LIBLLDB_LOG_THREAD
Definition: Logging.h:16
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:127
bool SetSelectedFrameByIndexNoisily(uint32_t frame_idx, Stream &output_stream)
Definition: Thread.cpp:346
lldb::StackFrameListSP m_curr_frames_sp
The stack frames that get lazily populated after a thread stops.
Definition: Thread.h:1234
bool IsThreadPlanDone(ThreadPlan *plan)
Checks whether the given plan is in the completed plans for this stop.
Definition: Thread.cpp:1133
lldb::TargetSP CalculateTarget() override
Definition: Thread.cpp:1584
~Thread() override
Definition: Thread.cpp:268
static ConstString & GetStaticBroadcasterClass()
Definition: Thread.cpp:237
bool ShouldStop(Event *event_ptr)
Definition: Thread.cpp:716
#define LLDB_INVALID_FRAME_ID
Definition: lldb-defines.h:94
static lldb::ThreadSP GetThreadFromEvent(const Event *event_ptr)
Definition: Thread.cpp:205
ObjectSP GetValueForKey(llvm::StringRef key) const
uint64_t tid_t
Definition: lldb-types.h:86
virtual bool IsStillAtLastBreakpointHit()
Definition: Thread.cpp:2092
llvm::StringRef GetString() const
virtual void DidResume()
Definition: Thread.cpp:712
virtual lldb::RegisterContextSP GetRegisterContext()=0
RegisterContext * GetRegisterContext() const
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
virtual bool MischiefManaged()
Definition: ThreadPlan.cpp:57
void PushPlan(lldb::ThreadPlanSP &plan_sp)
Definition: Thread.cpp:1034
static StackID GetStackIDFromEvent(const Event *event_ptr)
Definition: Thread.cpp:213
uint32_t GetCurrentInlinedDepth()
Definition: Thread.h:406
A plug-in interface definition class for debugging a process.
Definition: Process.h:353
Process * GetProcessPtr() const
Returns a pointer to the process object.
void IndentLess(int amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:221
virtual void DestroyThread()
Definition: Thread.cpp:278
std::recursive_mutex m_frame_mutex
Multithreaded protection for m_state.
Definition: Thread.h:1233
lldb::ProcessSP CalculateProcess() override
Definition: Thread.cpp:1592
Display as the section name + offset.
Definition: Address.h:86
virtual bool SafeToCallFunctionsOnThisThread(lldb::ThreadSP thread_sp)
Determine whether it is safe to run an expression on a given thread.
bool WillResume(lldb::StateType resume_state, bool current_plan)
Definition: ThreadPlan.cpp:99
virtual bool MatchesSpec(const ThreadSpec *spec)
Definition: Thread.cpp:1030
virtual bool OkayToDiscard()
Definition: ThreadPlan.cpp:133
Status Resume()
Resumes all of a process&#39;s threads as configured using the Thread run control functions.
Definition: Process.cpp:1385
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
void SetTracer(lldb::ThreadPlanTracerSP &tracer_sp)
Definition: Thread.cpp:1219
friend class ThreadEventData
Definition: Thread.h:1162
bool Success() const
Test for success condition.
Definition: Status.cpp:287
FileSpecList GetLibrariesToAvoid() const
Definition: Thread.cpp:141
Process or thread is in the process of stepping and can not be examined.
A section + offset based address class.
Definition: Address.h:80
bool SetSelectedFrameByIndex(uint32_t frame_idx, bool broadcast=false)
Definition: Thread.cpp:334
static bool OpenFileInExternalEditor(const FileSpec &file_spec, uint32_t line_no)
virtual void ClearStackFrames()
Definition: Thread.cpp:1612
Process is object is valid, but not currently loaded.
lldb::ProcessSP GetProcess() const
Definition: Thread.h:154
static bool Format(const Entry &entry, Stream &s, const SymbolContext *sc, const ExecutionContext *exe_ctx, const Address *addr, ValueObject *valobj, bool function_changed, bool initial_function)
const uint32_t m_index_id
A unique 1 based index assigned to each thread for easy UI/command line access.
Definition: Thread.h:1218
A plug-in interface definition class for dynamic loaders.
Definition: DynamicLoader.h:64
virtual bool IsBasePlan()
Definition: ThreadPlan.h:478
void FindAddressesForLine(const lldb::TargetSP target_sp, const FileSpec &file, uint32_t line, Function *function, std::vector< Address > &output_local, std::vector< Address > &output_extern)
Find addresses by file/line.
Definition: ModuleList.cpp:586
virtual Status StepOver(bool source_step, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
Default implementation for stepping over.
Definition: Thread.cpp:2149
CompilerType GetCompilerType()
Definition: Function.cpp:469
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:899
Property * ProtectedGetPropertyAtIndex(uint32_t idx)
bool EventTypeHasListeners(uint32_t event_type)
Definition: Broadcaster.h:369
const char * GetName() const
Returns the name of this thread plan.
Definition: ThreadPlan.h:366
static const char * RunModeAsCString(lldb::RunMode mode)
Definition: Thread.cpp:1892
Display the details about what an address resolves to.
Definition: Address.h:108
virtual lldb::ThreadPlanSP QueueThreadPlanForStepScripted(bool abort_other_plans, const char *class_name, bool stop_other_threads, Status &status)
Definition: Thread.cpp:1506
Status QueueThreadPlan(lldb::ThreadPlanSP &plan_sp, bool abort_other_plans)
Queues a generic thread plan.
Definition: Thread.cpp:1179
virtual Vote ShouldReportStop(Event *event_ptr)
Definition: ThreadPlan.cpp:64
bool WasThreadPlanDiscarded(ThreadPlan *plan)
Checks whether the given plan is in the discarded plans for this stop.
Definition: Thread.cpp:1143
uint64_t addr_t
Definition: lldb-types.h:83
uint32_t m_stop_info_override_stop_id
Definition: Thread.h:1215
const RegularExpression * GetSymbolsToAvoidRegexp()
The regular expression returned determines symbols that this thread won&#39;t stop in during "step-in" op...
Definition: Thread.cpp:136
Thread(Process &process, lldb::tid_t tid, bool use_invalid_index_id=false)
Constructor.
Definition: Thread.cpp:242
void SetStepInTarget(const char *target)
virtual lldb::ThreadPlanSP QueueThreadPlanForRunToAddress(bool abort_other_plans, Address &target_addr, bool stop_other_threads, Status &status)
Gets the plan used to continue from the current PC.
Definition: Thread.cpp:1485
bool ThreadPassesBasicTests(Thread &thread) const
Definition: ThreadSpec.cpp:121
Thread * GetThreadPtr() const
Returns a pointer to the thread object.
void DumpThreadPlans(Stream *s, lldb::DescriptionLevel desc_level=lldb::eDescriptionLevelVerbose, bool include_internal=true, bool ignore_boring=false) const
Prints the current plan stack.
Definition: Thread.cpp:1540
A uniqued constant string class.
Definition: ConstString.h:38
plan_stack m_completed_plan_stack
Plans that have been completed by this stop.
Definition: Thread.h:1226
virtual bool IsVirtualStep()
Definition: ThreadPlan.h:527
void SetTemporaryResumeState(lldb::StateType new_state)
Definition: Thread.h:1202
virtual lldb::ThreadPlanSP QueueThreadPlanForStepOverRange(bool abort_other_plans, const AddressRange &range, const SymbolContext &addr_context, lldb::RunMode stop_other_threads, Status &status, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
Queues the plan used to step through an address range, stepping over function calls.
Definition: Thread.cpp:1379
bool ThreadStoppedForAReason()
Definition: Thread.cpp:519
bool CompletedPlanOverridesBreakpoint()
Check if we have completed plan to override breakpoint stop reason.
Definition: Thread.cpp:1153
uint32_t SetSelectedFrame(lldb_private::StackFrame *frame, bool broadcast=false)
Definition: Thread.cpp:325
Target & GetTargetRef() const
Returns a reference to the target object.
bool GetTraceEnabledState() const
Definition: Thread.cpp:150
virtual lldb::ThreadPlanSP QueueThreadPlanForStepUntil(bool abort_other_plans, lldb::addr_t *address_list, size_t num_addresses, bool stop_others, uint32_t frame_idx, Status &status)
Definition: Thread.cpp:1496
EventData * GetData()
Definition: Event.h:198
ObjectSP GetItemAtIndex(size_t idx) const
Definition: SBAddress.h:15
virtual void WillResume(lldb::StateType resume_state)
Definition: Thread.h:212
CompilerType GetFunctionReturnType() const
virtual bool SafeToCallFunctions()
Check whether this thread is safe to run functions.
Definition: Thread.cpp:1844
size_t Indent(const char *s=nullptr)
Indent the current line in the stream.
Definition: Stream.cpp:131
static ConstString GetFlavorString()
Definition: Thread.cpp:176
ThreadOptionValueProperties(ConstString name)
Definition: Thread.cpp:95
virtual bool IsPlanStale()
Definition: ThreadPlan.h:474
std::shared_ptr< Object > ObjectSP
lldb::ExpressionVariableSP GetExpressionVariable()
Gets the outer-most expression variable from the completed plans.
Definition: Thread.cpp:1120
static void SettingsInitialize()
Definition: Thread.cpp:1826
ThreadOptionValueProperties(ThreadProperties *global_properties)
Definition: Thread.cpp:101
bool PlanExplainsStop(Event *event_ptr)
Definition: ThreadPlan.cpp:36
static lldb::StopInfoSP CreateStopReasonWithSignal(Thread &thread, int signo, const char *description=nullptr)
Definition: StopInfo.cpp:1122
virtual Vote ShouldReportRun(Event *event_ptr)
Definition: ThreadPlan.cpp:79
virtual lldb::OptionValuePropertiesSP GetValueProperties() const
virtual bool ShouldAutoContinue(Event *event_ptr)
Definition: ThreadPlan.h:415
void DiscardThreadPlansUpToPlan(lldb::ThreadPlanSP &up_to_plan_sp)
Discards the plans queued on the plan stack of the current thread up to and including up_to_plan_sp...
Definition: Thread.cpp:1249
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
lldb::ThreadSP GetThread() const
Definition: Thread.h:106
lldb::StateType GetTemporaryResumeState() const
Definition: Thread.h:1127
Vote ShouldReportRun(Event *event_ptr)
Definition: Thread.cpp:1000
void IndentMore(int amount=2)
Increment the current indentation level.
Definition: Stream.cpp:218
bool HasDebugInformation()
Determine whether this StackFrame has debug information available or not.
bool GetUseExternalEditor() const
Definition: Debugger.cpp:453
uint32_t GetIndexID() const
Definition: Thread.cpp:1515
void SetShouldReportStop(Vote vote)
Definition: Thread.cpp:500
virtual void WillResume(lldb::StateType resume_state)
Definition: StopInfo.h:64
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:395
bool GetStepOutAvoidsNoDebug() const
Definition: Thread.cpp:162
const FormatEntity::Entry * GetThreadStopFormat() const
Definition: Debugger.cpp:425
lldb::ValueObjectSP GetReturnValueObject()
Gets the outer-most return value from the completed plans.
Definition: Thread.cpp:1108
void Dump(Stream *s) const override
Definition: Thread.cpp:192
lldb::ThreadSP GetCurrentExceptionBacktrace()
Definition: Thread.cpp:2222
virtual SystemRuntime * GetSystemRuntime()
Get the system runtime plug-in for this process.
Definition: Process.cpp:2703
lldb::StackFrameSP GetStackFrameSPForStackFramePtr(StackFrame *stack_frame_ptr)
Definition: Thread.cpp:1856
#define LIBLLDB_LOG_STEP
Definition: Logging.h:21
virtual ConstString GetFlavor() const =0
void Printf(const char *format,...) __attribute__((format(printf
Definition: Log.cpp:113
void SetResumeSignal(int signal)
Definition: Thread.h:158
A section + offset based address range class.
Definition: AddressRange.h:32
bool ShouldResume(lldb::StateType resume_state)
Definition: Thread.cpp:649
static void DumpAddressList(Stream &s, const std::vector< Address > &list, ExecutionContextScope *exe_scope)
Definition: Thread.cpp:1730
uint64_t GetMaxBacktraceDepth() const
Definition: Thread.cpp:168
virtual bool WillStop()=0
lldb::StopInfoSP GetStopInfo()
Definition: Thread.cpp:381
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
Definition: ArchSpec.cpp:726
virtual bool RestoreRegisterStateFromCheckpoint(ThreadStateCheckpoint &saved_state)
Definition: Thread.cpp:548
size_t GetStackFrameStatus(Stream &strm, uint32_t first_frame, uint32_t num_frames, bool show_frame_info, uint32_t num_frames_with_source)
Definition: Thread.cpp:2049
static const char * StopReasonAsCString(lldb::StopReason reason)
Definition: Thread.cpp:1860
This base class provides an interface to stack frames.
Definition: StackFrame.h:40
virtual lldb::ThreadPlanSP QueueThreadPlanForStepOut(bool abort_other_plans, SymbolContext *addr_context, bool first_insn, bool stop_other_threads, Vote stop_vote, Vote run_vote, uint32_t frame_idx, Status &status, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
Queue the plan used to step out of the function at the current PC of thread.
Definition: Thread.cpp:1442
Debugger & GetDebugger()
Definition: Target.h:974
static void PrintPlanStack(Stream *s, const std::vector< lldb::ThreadPlanSP > &plan_stack, lldb::DescriptionLevel desc_level, bool include_internal)
Definition: Thread.cpp:1528
void DumpUsingSettingsFormat(Stream &strm, uint32_t frame_idx, bool stop_format)
Definition: Thread.cpp:1797
bool SetSelectedThreadByID(lldb::tid_t tid, bool notify=false)
Definition: ThreadList.cpp:661
An error handling class.
Definition: Status.h:44
virtual lldb::addr_t GetThreadLocalData(const lldb::ModuleSP module, const lldb::ThreadSP thread, lldb::addr_t tls_file_addr)
Retrieves the per-module TLS block for a given thread.
Status ReturnFromFrame(lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return_value_sp, bool broadcast=false)
Definition: Thread.cpp:1651
bool GetStepInAvoidsNoDebug() const
Definition: Thread.cpp:156
A plug-in interface definition class for system runtimes.
Definition: SystemRuntime.h:42
Process or thread is running and can&#39;t be examined.
std::shared_ptr< ThreadProperties > ThreadPropertiesSP
Definition: Thread.h:57