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