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