contrib/llvm/tools/lldb/source/Target/Thread.cpp

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