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 ; 705 step_bp_plan_sp->SetPrivate (true); 706 707 if (GetCurrentPlan()->RunState() != eStateStepping) 708 { 709 ThreadPlanStepOverBreakpoint *step_bp_plan 710 = static_cast<ThreadPlanStepOverBreakpoint *>(step_bp_plan_sp.get()); 711 step_bp_plan->SetAutoContinue(true); 712 } 713 QueueThreadPlan (step_bp_plan_sp, false); 714 } 715 } 716 } 717 } 718 } 719 } 720 721 bool 722 Thread::ShouldResume (StateType resume_state) 723 { 724 // At this point clear the completed plan stack. 725 m_completed_plan_stack.clear(); 726 m_discarded_plan_stack.clear(); 727 m_override_should_notify = eLazyBoolCalculate; 728 729 StateType prev_resume_state = GetTemporaryResumeState(); 730 731 SetTemporaryResumeState(resume_state); 732 733 lldb::ThreadSP backing_thread_sp (GetBackingThread ()); 734 if (backing_thread_sp) 735 backing_thread_sp->SetTemporaryResumeState(resume_state); 736 737 // Make sure m_stop_info_sp is valid. Don't do this for threads we suspended in the previous run. 738 if (prev_resume_state != eStateSuspended) 739 GetPrivateStopInfo(); 740 741 // This is a little dubious, but we are trying to limit how often we actually fetch stop info from 742 // the target, 'cause that slows down single stepping. So assume that if we got to the point where 743 // we're about to resume, and we haven't yet had to fetch the stop reason, then it doesn't need to know 744 // about the fact that we are resuming... 745 const uint32_t process_stop_id = GetProcess()->GetStopID(); 746 if (m_stop_info_stop_id == process_stop_id && 747 (m_stop_info_sp && m_stop_info_sp->IsValid())) 748 { 749 StopInfo *stop_info = GetPrivateStopInfo().get(); 750 if (stop_info) 751 stop_info->WillResume (resume_state); 752 } 753 754 // Tell all the plans that we are about to resume in case they need to clear any state. 755 // We distinguish between the plan on the top of the stack and the lower 756 // plans in case a plan needs to do any special business before it runs. 757 758 bool need_to_resume = false; 759 ThreadPlan *plan_ptr = GetCurrentPlan(); 760 if (plan_ptr) 761 { 762 need_to_resume = plan_ptr->WillResume(resume_state, true); 763 764 while ((plan_ptr = GetPreviousPlan(plan_ptr)) != nullptr) 765 { 766 plan_ptr->WillResume (resume_state, false); 767 } 768 769 // If the WillResume for the plan says we are faking a resume, then it will have set an appropriate stop info. 770 // In that case, don't reset it here. 771 772 if (need_to_resume && resume_state != eStateSuspended) 773 { 774 m_stop_info_sp.reset(); 775 } 776 } 777 778 if (need_to_resume) 779 { 780 ClearStackFrames(); 781 // Let Thread subclasses do any special work they need to prior to resuming 782 WillResume (resume_state); 783 } 784 785 return need_to_resume; 786 } 787 788 void 789 Thread::DidResume () 790 { 791 SetResumeSignal (LLDB_INVALID_SIGNAL_NUMBER); 792 } 793 794 void 795 Thread::DidStop () 796 { 797 SetState (eStateStopped); 798 } 799 800 bool 801 Thread::ShouldStop (Event* event_ptr) 802 { 803 ThreadPlan *current_plan = GetCurrentPlan(); 804 805 bool should_stop = true; 806 807 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 808 809 if (GetResumeState () == eStateSuspended) 810 { 811 if (log) 812 log->Printf ("Thread::%s for tid = 0x%4.4" PRIx64 " 0x%4.4" PRIx64 ", should_stop = 0 (ignore since thread was suspended)", 813 __FUNCTION__, GetID (), GetProtocolID()); 814 return false; 815 } 816 817 if (GetTemporaryResumeState () == eStateSuspended) 818 { 819 if (log) 820 log->Printf ("Thread::%s for tid = 0x%4.4" PRIx64 " 0x%4.4" PRIx64 ", should_stop = 0 (ignore since thread was suspended)", 821 __FUNCTION__, GetID (), GetProtocolID()); 822 return false; 823 } 824 825 // Based on the current thread plan and process stop info, check if this 826 // thread caused the process to stop. NOTE: this must take place before 827 // the plan is moved from the current plan stack to the completed plan 828 // stack. 829 if (!ThreadStoppedForAReason()) 830 { 831 if (log) 832 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)", 833 __FUNCTION__, GetID (), GetProtocolID(), 834 GetRegisterContext() ? GetRegisterContext()->GetPC() : LLDB_INVALID_ADDRESS); 835 return false; 836 } 837 838 if (log) 839 { 840 log->Printf ("Thread::%s(%p) for tid = 0x%4.4" PRIx64 " 0x%4.4" PRIx64 ", pc = 0x%16.16" PRIx64, 841 __FUNCTION__, static_cast<void*>(this), GetID (), 842 GetProtocolID (), 843 GetRegisterContext() 844 ? GetRegisterContext()->GetPC() 845 : LLDB_INVALID_ADDRESS); 846 log->Printf ("^^^^^^^^ Thread::ShouldStop Begin ^^^^^^^^"); 847 StreamString s; 848 s.IndentMore(); 849 DumpThreadPlans(&s); 850 log->Printf ("Plan stack initial state:\n%s", s.GetData()); 851 } 852 853 // The top most plan always gets to do the trace log... 854 current_plan->DoTraceLog (); 855 856 // First query the stop info's ShouldStopSynchronous. This handles "synchronous" stop reasons, for example the breakpoint 857 // command on internal breakpoints. If a synchronous stop reason says we should not stop, then we don't have to 858 // do any more work on this stop. 859 StopInfoSP private_stop_info (GetPrivateStopInfo()); 860 if (private_stop_info && !private_stop_info->ShouldStopSynchronous(event_ptr)) 861 { 862 if (log) 863 log->Printf ("StopInfo::ShouldStop async callback says we should not stop, returning ShouldStop of false."); 864 return false; 865 } 866 867 // If we've already been restarted, don't query the plans since the state they would examine is not current. 868 if (Process::ProcessEventData::GetRestartedFromEvent(event_ptr)) 869 return false; 870 871 // Before the plans see the state of the world, calculate the current inlined depth. 872 GetStackFrameList()->CalculateCurrentInlinedDepth(); 873 874 // If the base plan doesn't understand why we stopped, then we have to find a plan that does. 875 // If that plan is still working, then we don't need to do any more work. If the plan that explains 876 // the stop is done, then we should pop all the plans below it, and pop it, and then let the plans above it decide 877 // whether they still need to do more work. 878 879 bool done_processing_current_plan = false; 880 881 if (!current_plan->PlanExplainsStop(event_ptr)) 882 { 883 if (current_plan->TracerExplainsStop()) 884 { 885 done_processing_current_plan = true; 886 should_stop = false; 887 } 888 else 889 { 890 // If the current plan doesn't explain the stop, then find one that 891 // does and let it handle the situation. 892 ThreadPlan *plan_ptr = current_plan; 893 while ((plan_ptr = GetPreviousPlan(plan_ptr)) != nullptr) 894 { 895 if (plan_ptr->PlanExplainsStop(event_ptr)) 896 { 897 should_stop = plan_ptr->ShouldStop (event_ptr); 898 899 // plan_ptr explains the stop, next check whether plan_ptr is done, if so, then we should take it 900 // and all the plans below it off the stack. 901 902 if (plan_ptr->MischiefManaged()) 903 { 904 // We're going to pop the plans up to and including the plan that explains the stop. 905 ThreadPlan *prev_plan_ptr = GetPreviousPlan (plan_ptr); 906 907 do 908 { 909 if (should_stop) 910 current_plan->WillStop(); 911 PopPlan(); 912 } 913 while ((current_plan = GetCurrentPlan()) != prev_plan_ptr); 914 // Now, if the responsible plan was not "Okay to discard" then we're done, 915 // otherwise we forward this to the next plan in the stack below. 916 done_processing_current_plan = (plan_ptr->IsMasterPlan() && !plan_ptr->OkayToDiscard()); 917 } 918 else 919 done_processing_current_plan = true; 920 921 break; 922 } 923 } 924 } 925 } 926 927 if (!done_processing_current_plan) 928 { 929 bool over_ride_stop = current_plan->ShouldAutoContinue(event_ptr); 930 931 if (log) 932 log->Printf("Plan %s explains stop, auto-continue %i.", 933 current_plan->GetName(), over_ride_stop); 934 935 // We're starting from the base plan, so just let it decide; 936 if (PlanIsBasePlan(current_plan)) 937 { 938 should_stop = current_plan->ShouldStop (event_ptr); 939 if (log) 940 log->Printf("Base plan says should stop: %i.", should_stop); 941 } 942 else 943 { 944 // Otherwise, don't let the base plan override what the other plans say to do, since 945 // presumably if there were other plans they would know what to do... 946 while (1) 947 { 948 if (PlanIsBasePlan(current_plan)) 949 break; 950 951 should_stop = current_plan->ShouldStop(event_ptr); 952 if (log) 953 log->Printf("Plan %s should stop: %d.", 954 current_plan->GetName(), should_stop); 955 if (current_plan->MischiefManaged()) 956 { 957 if (should_stop) 958 current_plan->WillStop(); 959 960 // If a Master Plan wants to stop, and wants to stick on the stack, we let it. 961 // Otherwise, see if the plan's parent wants to stop. 962 963 if (should_stop && current_plan->IsMasterPlan() && !current_plan->OkayToDiscard()) 964 { 965 PopPlan(); 966 break; 967 } 968 else 969 { 970 PopPlan(); 971 972 current_plan = GetCurrentPlan(); 973 if (current_plan == nullptr) 974 { 975 break; 976 } 977 } 978 } 979 else 980 { 981 break; 982 } 983 } 984 } 985 986 if (over_ride_stop) 987 should_stop = false; 988 } 989 990 // One other potential problem is that we set up a master plan, then stop in before it is complete - for instance 991 // by hitting a breakpoint during a step-over - then do some step/finish/etc operations that wind up 992 // past the end point condition of the initial plan. We don't want to strand the original plan on the stack, 993 // This code clears stale plans off the stack. 994 995 if (should_stop) 996 { 997 ThreadPlan *plan_ptr = GetCurrentPlan(); 998 while (!PlanIsBasePlan(plan_ptr)) 999 { 1000 bool stale = plan_ptr->IsPlanStale (); 1001 ThreadPlan *examined_plan = plan_ptr; 1002 plan_ptr = GetPreviousPlan (examined_plan); 1003 1004 if (stale) 1005 { 1006 if (log) 1007 log->Printf("Plan %s being discarded in cleanup, it says it is already done.", 1008 examined_plan->GetName()); 1009 DiscardThreadPlansUpToPlan(examined_plan); 1010 } 1011 } 1012 } 1013 1014 if (log) 1015 { 1016 StreamString s; 1017 s.IndentMore(); 1018 DumpThreadPlans(&s); 1019 log->Printf ("Plan stack final state:\n%s", s.GetData()); 1020 log->Printf ("vvvvvvvv Thread::ShouldStop End (returning %i) vvvvvvvv", should_stop); 1021 } 1022 return should_stop; 1023 } 1024 1025 Vote 1026 Thread::ShouldReportStop (Event* event_ptr) 1027 { 1028 StateType thread_state = GetResumeState (); 1029 StateType temp_thread_state = GetTemporaryResumeState(); 1030 1031 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 1032 1033 if (thread_state == eStateSuspended || thread_state == eStateInvalid) 1034 { 1035 if (log) 1036 log->Printf ("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64 ": returning vote %i (state was suspended or invalid)", GetID(), eVoteNoOpinion); 1037 return eVoteNoOpinion; 1038 } 1039 1040 if (temp_thread_state == eStateSuspended || temp_thread_state == eStateInvalid) 1041 { 1042 if (log) 1043 log->Printf ("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64 ": returning vote %i (temporary state was suspended or invalid)", GetID(), eVoteNoOpinion); 1044 return eVoteNoOpinion; 1045 } 1046 1047 if (!ThreadStoppedForAReason()) 1048 { 1049 if (log) 1050 log->Printf ("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64 ": returning vote %i (thread didn't stop for a reason.)", GetID(), eVoteNoOpinion); 1051 return eVoteNoOpinion; 1052 } 1053 1054 if (m_completed_plan_stack.size() > 0) 1055 { 1056 // Don't use GetCompletedPlan here, since that suppresses private plans. 1057 if (log) 1058 log->Printf ("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64 ": returning vote for complete stack's back plan", GetID()); 1059 return m_completed_plan_stack.back()->ShouldReportStop (event_ptr); 1060 } 1061 else 1062 { 1063 Vote thread_vote = eVoteNoOpinion; 1064 ThreadPlan *plan_ptr = GetCurrentPlan(); 1065 while (1) 1066 { 1067 if (plan_ptr->PlanExplainsStop(event_ptr)) 1068 { 1069 thread_vote = plan_ptr->ShouldReportStop(event_ptr); 1070 break; 1071 } 1072 if (PlanIsBasePlan(plan_ptr)) 1073 break; 1074 else 1075 plan_ptr = GetPreviousPlan(plan_ptr); 1076 } 1077 if (log) 1078 log->Printf ("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64 ": returning vote %i for current plan", GetID(), thread_vote); 1079 1080 return thread_vote; 1081 } 1082 } 1083 1084 Vote 1085 Thread::ShouldReportRun (Event* event_ptr) 1086 { 1087 StateType thread_state = GetResumeState (); 1088 1089 if (thread_state == eStateSuspended 1090 || thread_state == eStateInvalid) 1091 { 1092 return eVoteNoOpinion; 1093 } 1094 1095 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 1096 if (m_completed_plan_stack.size() > 0) 1097 { 1098 // Don't use GetCompletedPlan here, since that suppresses private plans. 1099 if (log) 1100 log->Printf ("Current Plan for thread %d(%p) (0x%4.4" PRIx64 ", %s): %s being asked whether we should report run.", 1101 GetIndexID(), static_cast<void*>(this), GetID(), 1102 StateAsCString(GetTemporaryResumeState()), 1103 m_completed_plan_stack.back()->GetName()); 1104 1105 return m_completed_plan_stack.back()->ShouldReportRun (event_ptr); 1106 } 1107 else 1108 { 1109 if (log) 1110 log->Printf ("Current Plan for thread %d(%p) (0x%4.4" PRIx64 ", %s): %s being asked whether we should report run.", 1111 GetIndexID(), static_cast<void*>(this), GetID(), 1112 StateAsCString(GetTemporaryResumeState()), 1113 GetCurrentPlan()->GetName()); 1114 1115 return GetCurrentPlan()->ShouldReportRun (event_ptr); 1116 } 1117 } 1118 1119 bool 1120 Thread::MatchesSpec (const ThreadSpec *spec) 1121 { 1122 return (spec == nullptr) ? true : spec->ThreadPassesBasicTests(*this); 1123 } 1124 1125 void 1126 Thread::PushPlan (ThreadPlanSP &thread_plan_sp) 1127 { 1128 if (thread_plan_sp) 1129 { 1130 // If the thread plan doesn't already have a tracer, give it its parent's tracer: 1131 if (!thread_plan_sp->GetThreadPlanTracer()) 1132 thread_plan_sp->SetThreadPlanTracer(m_plan_stack.back()->GetThreadPlanTracer()); 1133 m_plan_stack.push_back (thread_plan_sp); 1134 1135 thread_plan_sp->DidPush(); 1136 1137 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 1138 if (log) 1139 { 1140 StreamString s; 1141 thread_plan_sp->GetDescription (&s, lldb::eDescriptionLevelFull); 1142 log->Printf("Thread::PushPlan(0x%p): \"%s\", tid = 0x%4.4" PRIx64 ".", 1143 static_cast<void*>(this), s.GetData(), 1144 thread_plan_sp->GetThread().GetID()); 1145 } 1146 } 1147 } 1148 1149 void 1150 Thread::PopPlan () 1151 { 1152 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 1153 1154 if (m_plan_stack.size() <= 1) 1155 return; 1156 else 1157 { 1158 ThreadPlanSP &plan = m_plan_stack.back(); 1159 if (log) 1160 { 1161 log->Printf("Popping plan: \"%s\", tid = 0x%4.4" PRIx64 ".", plan->GetName(), plan->GetThread().GetID()); 1162 } 1163 m_completed_plan_stack.push_back (plan); 1164 plan->WillPop(); 1165 m_plan_stack.pop_back(); 1166 } 1167 } 1168 1169 void 1170 Thread::DiscardPlan () 1171 { 1172 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 1173 if (m_plan_stack.size() > 1) 1174 { 1175 ThreadPlanSP &plan = m_plan_stack.back(); 1176 if (log) 1177 log->Printf("Discarding plan: \"%s\", tid = 0x%4.4" PRIx64 ".", plan->GetName(), plan->GetThread().GetID()); 1178 1179 m_discarded_plan_stack.push_back (plan); 1180 plan->WillPop(); 1181 m_plan_stack.pop_back(); 1182 } 1183 } 1184 1185 ThreadPlan * 1186 Thread::GetCurrentPlan () 1187 { 1188 // There will always be at least the base plan. If somebody is mucking with a 1189 // thread with an empty plan stack, we should assert right away. 1190 return m_plan_stack.empty() ? nullptr : m_plan_stack.back().get(); 1191 } 1192 1193 ThreadPlanSP 1194 Thread::GetCompletedPlan () 1195 { 1196 ThreadPlanSP empty_plan_sp; 1197 if (!m_completed_plan_stack.empty()) 1198 { 1199 for (int i = m_completed_plan_stack.size() - 1; i >= 0; i--) 1200 { 1201 ThreadPlanSP completed_plan_sp; 1202 completed_plan_sp = m_completed_plan_stack[i]; 1203 if (!completed_plan_sp->GetPrivate ()) 1204 return completed_plan_sp; 1205 } 1206 } 1207 return empty_plan_sp; 1208 } 1209 1210 ValueObjectSP 1211 Thread::GetReturnValueObject () 1212 { 1213 if (!m_completed_plan_stack.empty()) 1214 { 1215 for (int i = m_completed_plan_stack.size() - 1; i >= 0; i--) 1216 { 1217 ValueObjectSP return_valobj_sp; 1218 return_valobj_sp = m_completed_plan_stack[i]->GetReturnValueObject(); 1219 if (return_valobj_sp) 1220 return return_valobj_sp; 1221 } 1222 } 1223 return ValueObjectSP(); 1224 } 1225 1226 ExpressionVariableSP 1227 Thread::GetExpressionVariable () 1228 { 1229 if (!m_completed_plan_stack.empty()) 1230 { 1231 for (int i = m_completed_plan_stack.size() - 1; i >= 0; i--) 1232 { 1233 ExpressionVariableSP expression_variable_sp; 1234 expression_variable_sp = m_completed_plan_stack[i]->GetExpressionVariable(); 1235 if (expression_variable_sp) 1236 return expression_variable_sp; 1237 } 1238 } 1239 return ExpressionVariableSP(); 1240 } 1241 1242 bool 1243 Thread::IsThreadPlanDone (ThreadPlan *plan) 1244 { 1245 if (!m_completed_plan_stack.empty()) 1246 { 1247 for (int i = m_completed_plan_stack.size() - 1; i >= 0; i--) 1248 { 1249 if (m_completed_plan_stack[i].get() == plan) 1250 return true; 1251 } 1252 } 1253 return false; 1254 } 1255 1256 bool 1257 Thread::WasThreadPlanDiscarded (ThreadPlan *plan) 1258 { 1259 if (!m_discarded_plan_stack.empty()) 1260 { 1261 for (int i = m_discarded_plan_stack.size() - 1; i >= 0; i--) 1262 { 1263 if (m_discarded_plan_stack[i].get() == plan) 1264 return true; 1265 } 1266 } 1267 return false; 1268 } 1269 1270 ThreadPlan * 1271 Thread::GetPreviousPlan (ThreadPlan *current_plan) 1272 { 1273 if (current_plan == nullptr) 1274 return nullptr; 1275 1276 int stack_size = m_completed_plan_stack.size(); 1277 for (int i = stack_size - 1; i > 0; i--) 1278 { 1279 if (current_plan == m_completed_plan_stack[i].get()) 1280 return m_completed_plan_stack[i-1].get(); 1281 } 1282 1283 if (stack_size > 0 && m_completed_plan_stack[0].get() == current_plan) 1284 { 1285 return GetCurrentPlan(); 1286 } 1287 1288 stack_size = m_plan_stack.size(); 1289 for (int i = stack_size - 1; i > 0; i--) 1290 { 1291 if (current_plan == m_plan_stack[i].get()) 1292 return m_plan_stack[i-1].get(); 1293 } 1294 return nullptr; 1295 } 1296 1297 void 1298 Thread::QueueThreadPlan (ThreadPlanSP &thread_plan_sp, bool abort_other_plans) 1299 { 1300 if (abort_other_plans) 1301 DiscardThreadPlans(true); 1302 1303 PushPlan (thread_plan_sp); 1304 } 1305 1306 void 1307 Thread::EnableTracer (bool value, bool single_stepping) 1308 { 1309 int stack_size = m_plan_stack.size(); 1310 for (int i = 0; i < stack_size; i++) 1311 { 1312 if (m_plan_stack[i]->GetThreadPlanTracer()) 1313 { 1314 m_plan_stack[i]->GetThreadPlanTracer()->EnableTracing(value); 1315 m_plan_stack[i]->GetThreadPlanTracer()->EnableSingleStep(single_stepping); 1316 } 1317 } 1318 } 1319 1320 void 1321 Thread::SetTracer (lldb::ThreadPlanTracerSP &tracer_sp) 1322 { 1323 int stack_size = m_plan_stack.size(); 1324 for (int i = 0; i < stack_size; i++) 1325 m_plan_stack[i]->SetThreadPlanTracer(tracer_sp); 1326 } 1327 1328 bool 1329 Thread::DiscardUserThreadPlansUpToIndex (uint32_t thread_index) 1330 { 1331 // Count the user thread plans from the back end to get the number of the one we want 1332 // to discard: 1333 1334 uint32_t idx = 0; 1335 ThreadPlan *up_to_plan_ptr = nullptr; 1336 1337 for (ThreadPlanSP plan_sp : m_plan_stack) 1338 { 1339 if (plan_sp->GetPrivate()) 1340 continue; 1341 if (idx == thread_index) 1342 { 1343 up_to_plan_ptr = plan_sp.get(); 1344 break; 1345 } 1346 else 1347 idx++; 1348 } 1349 1350 if (up_to_plan_ptr == nullptr) 1351 return false; 1352 1353 DiscardThreadPlansUpToPlan(up_to_plan_ptr); 1354 return true; 1355 } 1356 1357 void 1358 Thread::DiscardThreadPlansUpToPlan (lldb::ThreadPlanSP &up_to_plan_sp) 1359 { 1360 DiscardThreadPlansUpToPlan (up_to_plan_sp.get()); 1361 } 1362 1363 void 1364 Thread::DiscardThreadPlansUpToPlan (ThreadPlan *up_to_plan_ptr) 1365 { 1366 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 1367 if (log) 1368 log->Printf("Discarding thread plans for thread tid = 0x%4.4" PRIx64 ", up to %p", 1369 GetID(), static_cast<void*>(up_to_plan_ptr)); 1370 1371 int stack_size = m_plan_stack.size(); 1372 1373 // If the input plan is nullptr, discard all plans. Otherwise make sure this plan is in the 1374 // stack, and if so discard up to and including it. 1375 1376 if (up_to_plan_ptr == nullptr) 1377 { 1378 for (int i = stack_size - 1; i > 0; i--) 1379 DiscardPlan(); 1380 } 1381 else 1382 { 1383 bool found_it = false; 1384 for (int i = stack_size - 1; i > 0; i--) 1385 { 1386 if (m_plan_stack[i].get() == up_to_plan_ptr) 1387 found_it = true; 1388 } 1389 if (found_it) 1390 { 1391 bool last_one = false; 1392 for (int i = stack_size - 1; i > 0 && !last_one ; i--) 1393 { 1394 if (GetCurrentPlan() == up_to_plan_ptr) 1395 last_one = true; 1396 DiscardPlan(); 1397 } 1398 } 1399 } 1400 } 1401 1402 void 1403 Thread::DiscardThreadPlans(bool force) 1404 { 1405 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 1406 if (log) 1407 { 1408 log->Printf("Discarding thread plans for thread (tid = 0x%4.4" PRIx64 ", force %d)", GetID(), force); 1409 } 1410 1411 if (force) 1412 { 1413 int stack_size = m_plan_stack.size(); 1414 for (int i = stack_size - 1; i > 0; i--) 1415 { 1416 DiscardPlan(); 1417 } 1418 return; 1419 } 1420 1421 while (1) 1422 { 1423 int master_plan_idx; 1424 bool discard = true; 1425 1426 // Find the first master plan, see if it wants discarding, and if yes discard up to it. 1427 for (master_plan_idx = m_plan_stack.size() - 1; master_plan_idx >= 0; master_plan_idx--) 1428 { 1429 if (m_plan_stack[master_plan_idx]->IsMasterPlan()) 1430 { 1431 discard = m_plan_stack[master_plan_idx]->OkayToDiscard(); 1432 break; 1433 } 1434 } 1435 1436 if (discard) 1437 { 1438 // First pop all the dependent plans: 1439 for (int i = m_plan_stack.size() - 1; i > master_plan_idx; i--) 1440 { 1441 // FIXME: Do we need a finalize here, or is the rule that "PrepareForStop" 1442 // for the plan leaves it in a state that it is safe to pop the plan 1443 // with no more notice? 1444 DiscardPlan(); 1445 } 1446 1447 // Now discard the master plan itself. 1448 // The bottom-most plan never gets discarded. "OkayToDiscard" for it means 1449 // discard it's dependent plans, but not it... 1450 if (master_plan_idx > 0) 1451 { 1452 DiscardPlan(); 1453 } 1454 } 1455 else 1456 { 1457 // If the master plan doesn't want to get discarded, then we're done. 1458 break; 1459 } 1460 } 1461 } 1462 1463 bool 1464 Thread::PlanIsBasePlan (ThreadPlan *plan_ptr) 1465 { 1466 if (plan_ptr->IsBasePlan()) 1467 return true; 1468 else if (m_plan_stack.size() == 0) 1469 return false; 1470 else 1471 return m_plan_stack[0].get() == plan_ptr; 1472 } 1473 1474 Error 1475 Thread::UnwindInnermostExpression() 1476 { 1477 Error error; 1478 int stack_size = m_plan_stack.size(); 1479 1480 // If the input plan is nullptr, discard all plans. Otherwise make sure this plan is in the 1481 // stack, and if so discard up to and including it. 1482 1483 for (int i = stack_size - 1; i > 0; i--) 1484 { 1485 if (m_plan_stack[i]->GetKind() == ThreadPlan::eKindCallFunction) 1486 { 1487 DiscardThreadPlansUpToPlan(m_plan_stack[i].get()); 1488 return error; 1489 } 1490 } 1491 error.SetErrorString("No expressions currently active on this thread"); 1492 return error; 1493 } 1494 1495 ThreadPlanSP 1496 Thread::QueueFundamentalPlan (bool abort_other_plans) 1497 { 1498 ThreadPlanSP thread_plan_sp (new ThreadPlanBase(*this)); 1499 QueueThreadPlan (thread_plan_sp, abort_other_plans); 1500 return thread_plan_sp; 1501 } 1502 1503 ThreadPlanSP 1504 Thread::QueueThreadPlanForStepSingleInstruction(bool step_over, 1505 bool abort_other_plans, 1506 bool stop_other_threads) 1507 { 1508 ThreadPlanSP thread_plan_sp (new ThreadPlanStepInstruction (*this, step_over, stop_other_threads, eVoteNoOpinion, eVoteNoOpinion)); 1509 QueueThreadPlan (thread_plan_sp, abort_other_plans); 1510 return thread_plan_sp; 1511 } 1512 1513 ThreadPlanSP 1514 Thread::QueueThreadPlanForStepOverRange(bool abort_other_plans, 1515 const AddressRange &range, 1516 const SymbolContext &addr_context, 1517 lldb::RunMode stop_other_threads, 1518 LazyBool step_out_avoids_code_withoug_debug_info) 1519 { 1520 ThreadPlanSP thread_plan_sp; 1521 thread_plan_sp.reset (new ThreadPlanStepOverRange (*this, range, addr_context, stop_other_threads, step_out_avoids_code_withoug_debug_info)); 1522 1523 QueueThreadPlan (thread_plan_sp, abort_other_plans); 1524 return thread_plan_sp; 1525 } 1526 1527 // Call the QueueThreadPlanForStepOverRange method which takes an address range. 1528 ThreadPlanSP 1529 Thread::QueueThreadPlanForStepOverRange(bool abort_other_plans, 1530 const LineEntry &line_entry, 1531 const SymbolContext &addr_context, 1532 lldb::RunMode stop_other_threads, 1533 LazyBool step_out_avoids_code_withoug_debug_info) 1534 { 1535 return QueueThreadPlanForStepOverRange (abort_other_plans, 1536 line_entry.GetSameLineContiguousAddressRange(), 1537 addr_context, 1538 stop_other_threads, 1539 step_out_avoids_code_withoug_debug_info); 1540 } 1541 1542 ThreadPlanSP 1543 Thread::QueueThreadPlanForStepInRange(bool abort_other_plans, 1544 const AddressRange &range, 1545 const SymbolContext &addr_context, 1546 const char *step_in_target, 1547 lldb::RunMode stop_other_threads, 1548 LazyBool step_in_avoids_code_without_debug_info, 1549 LazyBool step_out_avoids_code_without_debug_info) 1550 { 1551 ThreadPlanSP thread_plan_sp (new ThreadPlanStepInRange (*this, 1552 range, 1553 addr_context, 1554 stop_other_threads, 1555 step_in_avoids_code_without_debug_info, 1556 step_out_avoids_code_without_debug_info)); 1557 ThreadPlanStepInRange *plan = static_cast<ThreadPlanStepInRange *>(thread_plan_sp.get()); 1558 1559 if (step_in_target) 1560 plan->SetStepInTarget(step_in_target); 1561 1562 QueueThreadPlan (thread_plan_sp, abort_other_plans); 1563 return thread_plan_sp; 1564 } 1565 1566 // Call the QueueThreadPlanForStepInRange method which takes an address range. 1567 ThreadPlanSP 1568 Thread::QueueThreadPlanForStepInRange(bool abort_other_plans, 1569 const LineEntry &line_entry, 1570 const SymbolContext &addr_context, 1571 const char *step_in_target, 1572 lldb::RunMode stop_other_threads, 1573 LazyBool step_in_avoids_code_without_debug_info, 1574 LazyBool step_out_avoids_code_without_debug_info) 1575 { 1576 return QueueThreadPlanForStepInRange (abort_other_plans, 1577 line_entry.GetSameLineContiguousAddressRange(), 1578 addr_context, 1579 step_in_target, 1580 stop_other_threads, 1581 step_in_avoids_code_without_debug_info, 1582 step_out_avoids_code_without_debug_info); 1583 } 1584 1585 1586 ThreadPlanSP 1587 Thread::QueueThreadPlanForStepOut(bool abort_other_plans, 1588 SymbolContext *addr_context, 1589 bool first_insn, 1590 bool stop_other_threads, 1591 Vote stop_vote, 1592 Vote run_vote, 1593 uint32_t frame_idx, 1594 LazyBool step_out_avoids_code_without_debug_info) 1595 { 1596 ThreadPlanSP thread_plan_sp (new ThreadPlanStepOut (*this, 1597 addr_context, 1598 first_insn, 1599 stop_other_threads, 1600 stop_vote, 1601 run_vote, 1602 frame_idx, 1603 step_out_avoids_code_without_debug_info)); 1604 1605 if (thread_plan_sp->ValidatePlan(nullptr)) 1606 { 1607 QueueThreadPlan (thread_plan_sp, abort_other_plans); 1608 return thread_plan_sp; 1609 } 1610 else 1611 { 1612 return ThreadPlanSP(); 1613 } 1614 } 1615 1616 ThreadPlanSP 1617 Thread::QueueThreadPlanForStepOutNoShouldStop(bool abort_other_plans, 1618 SymbolContext *addr_context, 1619 bool first_insn, 1620 bool stop_other_threads, 1621 Vote stop_vote, 1622 Vote run_vote, 1623 uint32_t frame_idx, 1624 bool continue_to_next_branch) 1625 { 1626 ThreadPlanSP thread_plan_sp(new ThreadPlanStepOut (*this, 1627 addr_context, 1628 first_insn, 1629 stop_other_threads, 1630 stop_vote, 1631 run_vote, 1632 frame_idx, 1633 eLazyBoolNo, 1634 continue_to_next_branch)); 1635 1636 ThreadPlanStepOut *new_plan = static_cast<ThreadPlanStepOut *>(thread_plan_sp.get()); 1637 new_plan->ClearShouldStopHereCallbacks(); 1638 1639 if (thread_plan_sp->ValidatePlan(nullptr)) 1640 { 1641 QueueThreadPlan (thread_plan_sp, abort_other_plans); 1642 return thread_plan_sp; 1643 } 1644 else 1645 { 1646 return ThreadPlanSP(); 1647 } 1648 } 1649 1650 ThreadPlanSP 1651 Thread::QueueThreadPlanForStepThrough (StackID &return_stack_id, bool abort_other_plans, bool stop_other_threads) 1652 { 1653 ThreadPlanSP thread_plan_sp(new ThreadPlanStepThrough (*this, return_stack_id, stop_other_threads)); 1654 if (!thread_plan_sp || !thread_plan_sp->ValidatePlan(nullptr)) 1655 return ThreadPlanSP(); 1656 1657 QueueThreadPlan (thread_plan_sp, abort_other_plans); 1658 return thread_plan_sp; 1659 } 1660 1661 ThreadPlanSP 1662 Thread::QueueThreadPlanForRunToAddress (bool abort_other_plans, 1663 Address &target_addr, 1664 bool stop_other_threads) 1665 { 1666 ThreadPlanSP thread_plan_sp (new ThreadPlanRunToAddress (*this, target_addr, stop_other_threads)); 1667 QueueThreadPlan (thread_plan_sp, abort_other_plans); 1668 return thread_plan_sp; 1669 } 1670 1671 ThreadPlanSP 1672 Thread::QueueThreadPlanForStepUntil (bool abort_other_plans, 1673 lldb::addr_t *address_list, 1674 size_t num_addresses, 1675 bool stop_other_threads, 1676 uint32_t frame_idx) 1677 { 1678 ThreadPlanSP thread_plan_sp (new ThreadPlanStepUntil (*this, address_list, num_addresses, stop_other_threads, frame_idx)); 1679 QueueThreadPlan (thread_plan_sp, abort_other_plans); 1680 return thread_plan_sp; 1681 1682 } 1683 1684 lldb::ThreadPlanSP 1685 Thread::QueueThreadPlanForStepScripted (bool abort_other_plans, 1686 const char *class_name, 1687 bool stop_other_threads) 1688 { 1689 ThreadPlanSP thread_plan_sp (new ThreadPlanPython (*this, class_name)); 1690 QueueThreadPlan (thread_plan_sp, abort_other_plans); 1691 // This seems a little funny, but I don't want to have to split up the constructor and the 1692 // DidPush in the scripted plan, that seems annoying. 1693 // That means the constructor has to be in DidPush. 1694 // So I have to validate the plan AFTER pushing it, and then take it off again... 1695 if (!thread_plan_sp->ValidatePlan(nullptr)) 1696 { 1697 DiscardThreadPlansUpToPlan(thread_plan_sp); 1698 return ThreadPlanSP(); 1699 } 1700 else 1701 return thread_plan_sp; 1702 } 1703 1704 uint32_t 1705 Thread::GetIndexID () const 1706 { 1707 return m_index_id; 1708 } 1709 1710 static void 1711 PrintPlanElement (Stream *s, const ThreadPlanSP &plan, lldb::DescriptionLevel desc_level, int32_t elem_idx) 1712 { 1713 s->IndentMore(); 1714 s->Indent(); 1715 s->Printf ("Element %d: ", elem_idx); 1716 plan->GetDescription (s, desc_level); 1717 s->EOL(); 1718 s->IndentLess(); 1719 } 1720 1721 static void 1722 PrintPlanStack (Stream *s, const std::vector<lldb::ThreadPlanSP> &plan_stack, lldb::DescriptionLevel desc_level, bool include_internal) 1723 { 1724 int32_t print_idx = 0; 1725 for (ThreadPlanSP plan_sp : plan_stack) 1726 { 1727 if (include_internal || !plan_sp->GetPrivate()) 1728 { 1729 PrintPlanElement (s, plan_sp, desc_level, print_idx++); 1730 } 1731 } 1732 } 1733 1734 void 1735 Thread::DumpThreadPlans (Stream *s, 1736 lldb::DescriptionLevel desc_level, 1737 bool include_internal, 1738 bool ignore_boring_threads) const 1739 { 1740 uint32_t stack_size; 1741 1742 if (ignore_boring_threads) 1743 { 1744 uint32_t stack_size = m_plan_stack.size(); 1745 uint32_t completed_stack_size = m_completed_plan_stack.size(); 1746 uint32_t discarded_stack_size = m_discarded_plan_stack.size(); 1747 if (stack_size == 1 && completed_stack_size == 0 && discarded_stack_size == 0) 1748 { 1749 s->Printf ("thread #%u: tid = 0x%4.4" PRIx64 "\n", GetIndexID(), GetID()); 1750 s->IndentMore(); 1751 s->Indent(); 1752 s->Printf("No active thread plans\n"); 1753 s->IndentLess(); 1754 return; 1755 } 1756 } 1757 1758 s->Indent(); 1759 s->Printf ("thread #%u: tid = 0x%4.4" PRIx64 ":\n", GetIndexID(), GetID()); 1760 s->IndentMore(); 1761 s->Indent(); 1762 s->Printf ("Active plan stack:\n"); 1763 PrintPlanStack (s, m_plan_stack, desc_level, include_internal); 1764 1765 stack_size = m_completed_plan_stack.size(); 1766 if (stack_size > 0) 1767 { 1768 s->Indent(); 1769 s->Printf ("Completed Plan Stack:\n"); 1770 PrintPlanStack (s, m_completed_plan_stack, desc_level, include_internal); 1771 } 1772 1773 stack_size = m_discarded_plan_stack.size(); 1774 if (stack_size > 0) 1775 { 1776 s->Indent(); 1777 s->Printf ("Discarded Plan Stack:\n"); 1778 PrintPlanStack (s, m_discarded_plan_stack, desc_level, include_internal); 1779 } 1780 1781 s->IndentLess(); 1782 } 1783 1784 TargetSP 1785 Thread::CalculateTarget () 1786 { 1787 TargetSP target_sp; 1788 ProcessSP process_sp(GetProcess()); 1789 if (process_sp) 1790 target_sp = process_sp->CalculateTarget(); 1791 return target_sp; 1792 } 1793 1794 ProcessSP 1795 Thread::CalculateProcess () 1796 { 1797 return GetProcess(); 1798 } 1799 1800 ThreadSP 1801 Thread::CalculateThread () 1802 { 1803 return shared_from_this(); 1804 } 1805 1806 StackFrameSP 1807 Thread::CalculateStackFrame () 1808 { 1809 return StackFrameSP(); 1810 } 1811 1812 void 1813 Thread::CalculateExecutionContext (ExecutionContext &exe_ctx) 1814 { 1815 exe_ctx.SetContext (shared_from_this()); 1816 } 1817 1818 StackFrameListSP 1819 Thread::GetStackFrameList () 1820 { 1821 StackFrameListSP frame_list_sp; 1822 Mutex::Locker locker(m_frame_mutex); 1823 if (m_curr_frames_sp) 1824 { 1825 frame_list_sp = m_curr_frames_sp; 1826 } 1827 else 1828 { 1829 frame_list_sp.reset(new StackFrameList (*this, m_prev_frames_sp, true)); 1830 m_curr_frames_sp = frame_list_sp; 1831 } 1832 return frame_list_sp; 1833 } 1834 1835 void 1836 Thread::ClearStackFrames () 1837 { 1838 Mutex::Locker locker(m_frame_mutex); 1839 1840 Unwind *unwinder = GetUnwinder (); 1841 if (unwinder) 1842 unwinder->Clear(); 1843 1844 // Only store away the old "reference" StackFrameList if we got all its frames: 1845 // FIXME: At some point we can try to splice in the frames we have fetched into 1846 // the new frame as we make it, but let's not try that now. 1847 if (m_curr_frames_sp && m_curr_frames_sp->GetAllFramesFetched()) 1848 m_prev_frames_sp.swap (m_curr_frames_sp); 1849 m_curr_frames_sp.reset(); 1850 1851 m_extended_info.reset(); 1852 m_extended_info_fetched = false; 1853 } 1854 1855 lldb::StackFrameSP 1856 Thread::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx) 1857 { 1858 return GetStackFrameList()->GetFrameWithConcreteFrameIndex (unwind_idx); 1859 } 1860 1861 Error 1862 Thread::ReturnFromFrameWithIndex (uint32_t frame_idx, lldb::ValueObjectSP return_value_sp, bool broadcast) 1863 { 1864 StackFrameSP frame_sp = GetStackFrameAtIndex (frame_idx); 1865 Error return_error; 1866 1867 if (!frame_sp) 1868 { 1869 return_error.SetErrorStringWithFormat("Could not find frame with index %d in thread 0x%" PRIx64 ".", frame_idx, GetID()); 1870 } 1871 1872 return ReturnFromFrame(frame_sp, return_value_sp, broadcast); 1873 } 1874 1875 Error 1876 Thread::ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return_value_sp, bool broadcast) 1877 { 1878 Error return_error; 1879 1880 if (!frame_sp) 1881 { 1882 return_error.SetErrorString("Can't return to a null frame."); 1883 return return_error; 1884 } 1885 1886 Thread *thread = frame_sp->GetThread().get(); 1887 uint32_t older_frame_idx = frame_sp->GetFrameIndex() + 1; 1888 StackFrameSP older_frame_sp = thread->GetStackFrameAtIndex(older_frame_idx); 1889 if (!older_frame_sp) 1890 { 1891 return_error.SetErrorString("No older frame to return to."); 1892 return return_error; 1893 } 1894 1895 if (return_value_sp) 1896 { 1897 lldb::ABISP abi = thread->GetProcess()->GetABI(); 1898 if (!abi) 1899 { 1900 return_error.SetErrorString("Could not find ABI to set return value."); 1901 return return_error; 1902 } 1903 SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextFunction); 1904 1905 // FIXME: ValueObject::Cast doesn't currently work correctly, at least not for scalars. 1906 // Turn that back on when that works. 1907 if (/* DISABLES CODE */ (0) && sc.function != nullptr) 1908 { 1909 Type *function_type = sc.function->GetType(); 1910 if (function_type) 1911 { 1912 CompilerType return_type = sc.function->GetCompilerType().GetFunctionReturnType(); 1913 if (return_type) 1914 { 1915 StreamString s; 1916 return_type.DumpTypeDescription(&s); 1917 ValueObjectSP cast_value_sp = return_value_sp->Cast(return_type); 1918 if (cast_value_sp) 1919 { 1920 cast_value_sp->SetFormat(eFormatHex); 1921 return_value_sp = cast_value_sp; 1922 } 1923 } 1924 } 1925 } 1926 1927 return_error = abi->SetReturnValueObject(older_frame_sp, return_value_sp); 1928 if (!return_error.Success()) 1929 return return_error; 1930 } 1931 1932 // Now write the return registers for the chosen frame: 1933 // Note, we can't use ReadAllRegisterValues->WriteAllRegisterValues, since the read & write 1934 // cook their data 1935 1936 StackFrameSP youngest_frame_sp = thread->GetStackFrameAtIndex(0); 1937 if (youngest_frame_sp) 1938 { 1939 lldb::RegisterContextSP reg_ctx_sp (youngest_frame_sp->GetRegisterContext()); 1940 if (reg_ctx_sp) 1941 { 1942 bool copy_success = reg_ctx_sp->CopyFromRegisterContext(older_frame_sp->GetRegisterContext()); 1943 if (copy_success) 1944 { 1945 thread->DiscardThreadPlans(true); 1946 thread->ClearStackFrames(); 1947 if (broadcast && EventTypeHasListeners(eBroadcastBitStackChanged)) 1948 BroadcastEvent(eBroadcastBitStackChanged, new ThreadEventData (this->shared_from_this())); 1949 } 1950 else 1951 { 1952 return_error.SetErrorString("Could not reset register values."); 1953 } 1954 } 1955 else 1956 { 1957 return_error.SetErrorString("Frame has no register context."); 1958 } 1959 } 1960 else 1961 { 1962 return_error.SetErrorString("Returned past top frame."); 1963 } 1964 return return_error; 1965 } 1966 1967 static void DumpAddressList (Stream &s, const std::vector<Address> &list, ExecutionContextScope *exe_scope) 1968 { 1969 for (size_t n=0;n<list.size();n++) 1970 { 1971 s << "\t"; 1972 list[n].Dump (&s, exe_scope, Address::DumpStyleResolvedDescription, Address::DumpStyleSectionNameOffset); 1973 s << "\n"; 1974 } 1975 } 1976 1977 Error 1978 Thread::JumpToLine (const FileSpec &file, uint32_t line, bool can_leave_function, std::string *warnings) 1979 { 1980 ExecutionContext exe_ctx (GetStackFrameAtIndex(0)); 1981 Target *target = exe_ctx.GetTargetPtr(); 1982 TargetSP target_sp = exe_ctx.GetTargetSP(); 1983 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext(); 1984 StackFrame *frame = exe_ctx.GetFramePtr(); 1985 const SymbolContext &sc = frame->GetSymbolContext(eSymbolContextFunction); 1986 1987 // Find candidate locations. 1988 std::vector<Address> candidates, within_function, outside_function; 1989 target->GetImages().FindAddressesForLine (target_sp, file, line, sc.function, within_function, outside_function); 1990 1991 // If possible, we try and stay within the current function. 1992 // Within a function, we accept multiple locations (optimized code may do this, 1993 // there's no solution here so we do the best we can). 1994 // However if we're trying to leave the function, we don't know how to pick the 1995 // right location, so if there's more than one then we bail. 1996 if (!within_function.empty()) 1997 candidates = within_function; 1998 else if (outside_function.size() == 1 && can_leave_function) 1999 candidates = outside_function; 2000 2001 // Check if we got anything. 2002 if (candidates.empty()) 2003 { 2004 if (outside_function.empty()) 2005 { 2006 return Error("Cannot locate an address for %s:%i.", 2007 file.GetFilename().AsCString(), line); 2008 } 2009 else if (outside_function.size() == 1) 2010 { 2011 return Error("%s:%i is outside the current function.", 2012 file.GetFilename().AsCString(), line); 2013 } 2014 else 2015 { 2016 StreamString sstr; 2017 DumpAddressList(sstr, outside_function, target); 2018 return Error("%s:%i has multiple candidate locations:\n%s", 2019 file.GetFilename().AsCString(), line, sstr.GetString().c_str()); 2020 } 2021 } 2022 2023 // Accept the first location, warn about any others. 2024 Address dest = candidates[0]; 2025 if (warnings && candidates.size() > 1) 2026 { 2027 StreamString sstr; 2028 sstr.Printf("%s:%i appears multiple times in this function, selecting the first location:\n", 2029 file.GetFilename().AsCString(), line); 2030 DumpAddressList(sstr, candidates, target); 2031 *warnings = sstr.GetString(); 2032 } 2033 2034 if (!reg_ctx->SetPC (dest)) 2035 return Error("Cannot change PC to target address."); 2036 2037 return Error(); 2038 } 2039 2040 void 2041 Thread::DumpUsingSettingsFormat (Stream &strm, uint32_t frame_idx) 2042 { 2043 ExecutionContext exe_ctx (shared_from_this()); 2044 Process *process = exe_ctx.GetProcessPtr(); 2045 if (process == nullptr) 2046 return; 2047 2048 StackFrameSP frame_sp; 2049 SymbolContext frame_sc; 2050 if (frame_idx != LLDB_INVALID_FRAME_ID) 2051 { 2052 frame_sp = GetStackFrameAtIndex (frame_idx); 2053 if (frame_sp) 2054 { 2055 exe_ctx.SetFrameSP(frame_sp); 2056 frame_sc = frame_sp->GetSymbolContext(eSymbolContextEverything); 2057 } 2058 } 2059 2060 const FormatEntity::Entry *thread_format = exe_ctx.GetTargetRef().GetDebugger().GetThreadFormat(); 2061 assert (thread_format); 2062 2063 FormatEntity::Format(*thread_format, 2064 strm, 2065 frame_sp ? &frame_sc : nullptr, 2066 &exe_ctx, 2067 nullptr, 2068 nullptr, 2069 false, 2070 false); 2071 } 2072 2073 void 2074 Thread::SettingsInitialize () 2075 { 2076 } 2077 2078 void 2079 Thread::SettingsTerminate () 2080 { 2081 } 2082 2083 lldb::addr_t 2084 Thread::GetThreadPointer () 2085 { 2086 return LLDB_INVALID_ADDRESS; 2087 } 2088 2089 addr_t 2090 Thread::GetThreadLocalData (const ModuleSP module) 2091 { 2092 // The default implementation is to ask the dynamic loader for it. 2093 // This can be overridden for specific platforms. 2094 DynamicLoader *loader = GetProcess()->GetDynamicLoader(); 2095 if (loader) 2096 return loader->GetThreadLocalData (module, shared_from_this()); 2097 else 2098 return LLDB_INVALID_ADDRESS; 2099 } 2100 2101 bool 2102 Thread::SafeToCallFunctions () 2103 { 2104 Process *process = GetProcess().get(); 2105 if (process) 2106 { 2107 SystemRuntime *runtime = process->GetSystemRuntime (); 2108 if (runtime) 2109 { 2110 return runtime->SafeToCallFunctionsOnThisThread (shared_from_this()); 2111 } 2112 } 2113 return true; 2114 } 2115 2116 lldb::StackFrameSP 2117 Thread::GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr) 2118 { 2119 return GetStackFrameList()->GetStackFrameSPForStackFramePtr (stack_frame_ptr); 2120 } 2121 2122 const char * 2123 Thread::StopReasonAsCString (lldb::StopReason reason) 2124 { 2125 switch (reason) 2126 { 2127 case eStopReasonInvalid: return "invalid"; 2128 case eStopReasonNone: return "none"; 2129 case eStopReasonTrace: return "trace"; 2130 case eStopReasonBreakpoint: return "breakpoint"; 2131 case eStopReasonWatchpoint: return "watchpoint"; 2132 case eStopReasonSignal: return "signal"; 2133 case eStopReasonException: return "exception"; 2134 case eStopReasonExec: return "exec"; 2135 case eStopReasonPlanComplete: return "plan complete"; 2136 case eStopReasonThreadExiting: return "thread exiting"; 2137 case eStopReasonInstrumentation: return "instrumentation break"; 2138 } 2139 2140 static char unknown_state_string[64]; 2141 snprintf(unknown_state_string, sizeof (unknown_state_string), "StopReason = %i", reason); 2142 return unknown_state_string; 2143 } 2144 2145 const char * 2146 Thread::RunModeAsCString (lldb::RunMode mode) 2147 { 2148 switch (mode) 2149 { 2150 case eOnlyThisThread: return "only this thread"; 2151 case eAllThreads: return "all threads"; 2152 case eOnlyDuringStepping: return "only during stepping"; 2153 } 2154 2155 static char unknown_state_string[64]; 2156 snprintf(unknown_state_string, sizeof (unknown_state_string), "RunMode = %i", mode); 2157 return unknown_state_string; 2158 } 2159 2160 size_t 2161 Thread::GetStatus (Stream &strm, uint32_t start_frame, uint32_t num_frames, uint32_t num_frames_with_source) 2162 { 2163 ExecutionContext exe_ctx (shared_from_this()); 2164 Target *target = exe_ctx.GetTargetPtr(); 2165 Process *process = exe_ctx.GetProcessPtr(); 2166 size_t num_frames_shown = 0; 2167 strm.Indent(); 2168 bool is_selected = false; 2169 if (process) 2170 { 2171 if (process->GetThreadList().GetSelectedThread().get() == this) 2172 is_selected = true; 2173 } 2174 strm.Printf("%c ", is_selected ? '*' : ' '); 2175 if (target && target->GetDebugger().GetUseExternalEditor()) 2176 { 2177 StackFrameSP frame_sp = GetStackFrameAtIndex(start_frame); 2178 if (frame_sp) 2179 { 2180 SymbolContext frame_sc(frame_sp->GetSymbolContext (eSymbolContextLineEntry)); 2181 if (frame_sc.line_entry.line != 0 && frame_sc.line_entry.file) 2182 { 2183 Host::OpenFileInExternalEditor (frame_sc.line_entry.file, frame_sc.line_entry.line); 2184 } 2185 } 2186 } 2187 2188 DumpUsingSettingsFormat (strm, start_frame); 2189 2190 if (num_frames > 0) 2191 { 2192 strm.IndentMore(); 2193 2194 const bool show_frame_info = true; 2195 2196 const char *selected_frame_marker = nullptr; 2197 if (num_frames == 1 || (GetID() != GetProcess()->GetThreadList().GetSelectedThread()->GetID())) 2198 strm.IndentMore (); 2199 else 2200 selected_frame_marker = "* "; 2201 2202 num_frames_shown = GetStackFrameList ()->GetStatus (strm, 2203 start_frame, 2204 num_frames, 2205 show_frame_info, 2206 num_frames_with_source, 2207 selected_frame_marker); 2208 if (num_frames == 1) 2209 strm.IndentLess(); 2210 strm.IndentLess(); 2211 } 2212 return num_frames_shown; 2213 } 2214 2215 bool 2216 Thread::GetDescription (Stream &strm, lldb::DescriptionLevel level, bool print_json_thread, bool print_json_stopinfo) 2217 { 2218 DumpUsingSettingsFormat (strm, 0); 2219 strm.Printf("\n"); 2220 2221 StructuredData::ObjectSP thread_info = GetExtendedInfo(); 2222 2223 if (print_json_thread || print_json_stopinfo) 2224 { 2225 if (thread_info && print_json_thread) 2226 { 2227 thread_info->Dump (strm); 2228 strm.Printf("\n"); 2229 } 2230 2231 if (print_json_stopinfo && m_stop_info_sp) 2232 { 2233 StructuredData::ObjectSP stop_info = m_stop_info_sp->GetExtendedInfo(); 2234 if (stop_info) 2235 { 2236 stop_info->Dump (strm); 2237 strm.Printf("\n"); 2238 } 2239 } 2240 2241 return true; 2242 } 2243 2244 if (thread_info) 2245 { 2246 StructuredData::ObjectSP activity = thread_info->GetObjectForDotSeparatedPath("activity"); 2247 StructuredData::ObjectSP breadcrumb = thread_info->GetObjectForDotSeparatedPath("breadcrumb"); 2248 StructuredData::ObjectSP messages = thread_info->GetObjectForDotSeparatedPath("trace_messages"); 2249 2250 bool printed_activity = false; 2251 if (activity && activity->GetType() == StructuredData::Type::eTypeDictionary) 2252 { 2253 StructuredData::Dictionary *activity_dict = activity->GetAsDictionary(); 2254 StructuredData::ObjectSP id = activity_dict->GetValueForKey("id"); 2255 StructuredData::ObjectSP name = activity_dict->GetValueForKey("name"); 2256 if (name && name->GetType() == StructuredData::Type::eTypeString 2257 && id && id->GetType() == StructuredData::Type::eTypeInteger) 2258 { 2259 strm.Printf(" Activity '%s', 0x%" PRIx64 "\n", name->GetAsString()->GetValue().c_str(), id->GetAsInteger()->GetValue()); 2260 } 2261 printed_activity = true; 2262 } 2263 bool printed_breadcrumb = false; 2264 if (breadcrumb && breadcrumb->GetType() == StructuredData::Type::eTypeDictionary) 2265 { 2266 if (printed_activity) 2267 strm.Printf ("\n"); 2268 StructuredData::Dictionary *breadcrumb_dict = breadcrumb->GetAsDictionary(); 2269 StructuredData::ObjectSP breadcrumb_text = breadcrumb_dict->GetValueForKey ("name"); 2270 if (breadcrumb_text && breadcrumb_text->GetType() == StructuredData::Type::eTypeString) 2271 { 2272 strm.Printf (" Current Breadcrumb: %s\n", breadcrumb_text->GetAsString()->GetValue().c_str()); 2273 } 2274 printed_breadcrumb = true; 2275 } 2276 if (messages && messages->GetType() == StructuredData::Type::eTypeArray) 2277 { 2278 if (printed_breadcrumb) 2279 strm.Printf("\n"); 2280 StructuredData::Array *messages_array = messages->GetAsArray(); 2281 const size_t msg_count = messages_array->GetSize(); 2282 if (msg_count > 0) 2283 { 2284 strm.Printf (" %zu trace messages:\n", msg_count); 2285 for (size_t i = 0; i < msg_count; i++) 2286 { 2287 StructuredData::ObjectSP message = messages_array->GetItemAtIndex(i); 2288 if (message && message->GetType() == StructuredData::Type::eTypeDictionary) 2289 { 2290 StructuredData::Dictionary *message_dict = message->GetAsDictionary(); 2291 StructuredData::ObjectSP message_text = message_dict->GetValueForKey ("message"); 2292 if (message_text && message_text->GetType() == StructuredData::Type::eTypeString) 2293 { 2294 strm.Printf (" %s\n", message_text->GetAsString()->GetValue().c_str()); 2295 } 2296 } 2297 } 2298 } 2299 } 2300 } 2301 2302 return true; 2303 } 2304 2305 size_t 2306 Thread::GetStackFrameStatus (Stream& strm, 2307 uint32_t first_frame, 2308 uint32_t num_frames, 2309 bool show_frame_info, 2310 uint32_t num_frames_with_source) 2311 { 2312 return GetStackFrameList()->GetStatus (strm, 2313 first_frame, 2314 num_frames, 2315 show_frame_info, 2316 num_frames_with_source); 2317 } 2318 2319 Unwind * 2320 Thread::GetUnwinder () 2321 { 2322 if (!m_unwinder_ap) 2323 { 2324 const ArchSpec target_arch (CalculateTarget()->GetArchitecture ()); 2325 const llvm::Triple::ArchType machine = target_arch.GetMachine(); 2326 switch (machine) 2327 { 2328 case llvm::Triple::x86_64: 2329 case llvm::Triple::x86: 2330 case llvm::Triple::arm: 2331 case llvm::Triple::aarch64: 2332 case llvm::Triple::thumb: 2333 case llvm::Triple::mips: 2334 case llvm::Triple::mipsel: 2335 case llvm::Triple::mips64: 2336 case llvm::Triple::mips64el: 2337 case llvm::Triple::ppc: 2338 case llvm::Triple::ppc64: 2339 case llvm::Triple::hexagon: 2340 m_unwinder_ap.reset (new UnwindLLDB (*this)); 2341 break; 2342 2343 default: 2344 if (target_arch.GetTriple().getVendor() == llvm::Triple::Apple) 2345 m_unwinder_ap.reset (new UnwindMacOSXFrameBackchain (*this)); 2346 break; 2347 } 2348 } 2349 return m_unwinder_ap.get(); 2350 } 2351 2352 void 2353 Thread::Flush () 2354 { 2355 ClearStackFrames (); 2356 m_reg_context_sp.reset(); 2357 } 2358 2359 bool 2360 Thread::IsStillAtLastBreakpointHit () 2361 { 2362 // If we are currently stopped at a breakpoint, always return that stopinfo and don't reset it. 2363 // This allows threads to maintain their breakpoint stopinfo, such as when thread-stepping in 2364 // multithreaded programs. 2365 if (m_stop_info_sp) { 2366 StopReason stop_reason = m_stop_info_sp->GetStopReason(); 2367 if (stop_reason == lldb::eStopReasonBreakpoint) { 2368 uint64_t value = m_stop_info_sp->GetValue(); 2369 lldb::RegisterContextSP reg_ctx_sp (GetRegisterContext()); 2370 if (reg_ctx_sp) 2371 { 2372 lldb::addr_t pc = reg_ctx_sp->GetPC(); 2373 BreakpointSiteSP bp_site_sp = GetProcess()->GetBreakpointSiteList().FindByAddress(pc); 2374 if (bp_site_sp && 2375 static_cast<break_id_t>(value) == bp_site_sp->GetID()) 2376 return true; 2377 } 2378 } 2379 } 2380 return false; 2381 } 2382 2383 Error 2384 Thread::StepIn (bool source_step, 2385 LazyBool step_in_avoids_code_without_debug_info, 2386 LazyBool step_out_avoids_code_without_debug_info) 2387 2388 { 2389 Error error; 2390 Process *process = GetProcess().get(); 2391 if (StateIsStoppedState (process->GetState(), true)) 2392 { 2393 StackFrameSP frame_sp = GetStackFrameAtIndex (0); 2394 ThreadPlanSP new_plan_sp; 2395 const lldb::RunMode run_mode = eOnlyThisThread; 2396 const bool abort_other_plans = false; 2397 2398 if (source_step && frame_sp && frame_sp->HasDebugInformation ()) 2399 { 2400 SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything)); 2401 new_plan_sp = QueueThreadPlanForStepInRange(abort_other_plans, 2402 sc.line_entry, 2403 sc, 2404 nullptr, 2405 run_mode, 2406 step_in_avoids_code_without_debug_info, 2407 step_out_avoids_code_without_debug_info); 2408 } 2409 else 2410 { 2411 new_plan_sp = QueueThreadPlanForStepSingleInstruction (false, 2412 abort_other_plans, 2413 run_mode); 2414 } 2415 2416 new_plan_sp->SetIsMasterPlan(true); 2417 new_plan_sp->SetOkayToDiscard(false); 2418 2419 // Why do we need to set the current thread by ID here??? 2420 process->GetThreadList().SetSelectedThreadByID (GetID()); 2421 error = process->Resume(); 2422 } 2423 else 2424 { 2425 error.SetErrorString("process not stopped"); 2426 } 2427 return error; 2428 } 2429 2430 Error 2431 Thread::StepOver (bool source_step, 2432 LazyBool step_out_avoids_code_without_debug_info) 2433 { 2434 Error error; 2435 Process *process = GetProcess().get(); 2436 if (StateIsStoppedState (process->GetState(), true)) 2437 { 2438 StackFrameSP frame_sp = GetStackFrameAtIndex (0); 2439 ThreadPlanSP new_plan_sp; 2440 2441 const lldb::RunMode run_mode = eOnlyThisThread; 2442 const bool abort_other_plans = false; 2443 2444 if (source_step && frame_sp && frame_sp->HasDebugInformation ()) 2445 { 2446 SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything)); 2447 new_plan_sp = QueueThreadPlanForStepOverRange (abort_other_plans, 2448 sc.line_entry, 2449 sc, 2450 run_mode, 2451 step_out_avoids_code_without_debug_info); 2452 } 2453 else 2454 { 2455 new_plan_sp = QueueThreadPlanForStepSingleInstruction (true, 2456 abort_other_plans, 2457 run_mode); 2458 } 2459 2460 new_plan_sp->SetIsMasterPlan(true); 2461 new_plan_sp->SetOkayToDiscard(false); 2462 2463 // Why do we need to set the current thread by ID here??? 2464 process->GetThreadList().SetSelectedThreadByID (GetID()); 2465 error = process->Resume(); 2466 } 2467 else 2468 { 2469 error.SetErrorString("process not stopped"); 2470 } 2471 return error; 2472 } 2473 2474 Error 2475 Thread::StepOut () 2476 { 2477 Error error; 2478 Process *process = GetProcess().get(); 2479 if (StateIsStoppedState (process->GetState(), true)) 2480 { 2481 const bool first_instruction = false; 2482 const bool stop_other_threads = false; 2483 const bool abort_other_plans = false; 2484 2485 ThreadPlanSP new_plan_sp(QueueThreadPlanForStepOut(abort_other_plans, 2486 nullptr, 2487 first_instruction, 2488 stop_other_threads, 2489 eVoteYes, 2490 eVoteNoOpinion, 2491 0)); 2492 2493 new_plan_sp->SetIsMasterPlan(true); 2494 new_plan_sp->SetOkayToDiscard(false); 2495 2496 // Why do we need to set the current thread by ID here??? 2497 process->GetThreadList().SetSelectedThreadByID (GetID()); 2498 error = process->Resume(); 2499 } 2500 else 2501 { 2502 error.SetErrorString("process not stopped"); 2503 } 2504 return error; 2505 } 2506