1 //===-- SBThread.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 #include "lldb/lldb-python.h" 11 12 #include "lldb/API/SBThread.h" 13 14 #include "lldb/API/SBSymbolContext.h" 15 #include "lldb/API/SBFileSpec.h" 16 #include "lldb/API/SBStream.h" 17 #include "lldb/Breakpoint/BreakpointLocation.h" 18 #include "lldb/Core/Debugger.h" 19 #include "lldb/Core/State.h" 20 #include "lldb/Core/Stream.h" 21 #include "lldb/Core/StreamFile.h" 22 #include "lldb/Interpreter/CommandInterpreter.h" 23 #include "lldb/Target/SystemRuntime.h" 24 #include "lldb/Target/Thread.h" 25 #include "lldb/Target/Process.h" 26 #include "lldb/Symbol/SymbolContext.h" 27 #include "lldb/Symbol/CompileUnit.h" 28 #include "lldb/Target/StopInfo.h" 29 #include "lldb/Target/Target.h" 30 #include "lldb/Target/ThreadPlan.h" 31 #include "lldb/Target/ThreadPlanStepInstruction.h" 32 #include "lldb/Target/ThreadPlanStepOut.h" 33 #include "lldb/Target/ThreadPlanStepRange.h" 34 #include "lldb/Target/ThreadPlanStepInRange.h" 35 36 37 #include "lldb/API/SBAddress.h" 38 #include "lldb/API/SBDebugger.h" 39 #include "lldb/API/SBEvent.h" 40 #include "lldb/API/SBFrame.h" 41 #include "lldb/API/SBProcess.h" 42 #include "lldb/API/SBValue.h" 43 44 using namespace lldb; 45 using namespace lldb_private; 46 47 const char * 48 SBThread::GetBroadcasterClassName () 49 { 50 return Thread::GetStaticBroadcasterClass().AsCString(); 51 } 52 53 //---------------------------------------------------------------------- 54 // Constructors 55 //---------------------------------------------------------------------- 56 SBThread::SBThread () : 57 m_opaque_sp (new ExecutionContextRef()) 58 { 59 } 60 61 SBThread::SBThread (const ThreadSP& lldb_object_sp) : 62 m_opaque_sp (new ExecutionContextRef(lldb_object_sp)) 63 { 64 } 65 66 SBThread::SBThread (const SBThread &rhs) : 67 m_opaque_sp (new ExecutionContextRef(*rhs.m_opaque_sp)) 68 { 69 70 } 71 72 //---------------------------------------------------------------------- 73 // Assignment operator 74 //---------------------------------------------------------------------- 75 76 const lldb::SBThread & 77 SBThread::operator = (const SBThread &rhs) 78 { 79 if (this != &rhs) 80 *m_opaque_sp = *rhs.m_opaque_sp; 81 return *this; 82 } 83 84 //---------------------------------------------------------------------- 85 // Destructor 86 //---------------------------------------------------------------------- 87 SBThread::~SBThread() 88 { 89 } 90 91 bool 92 SBThread::IsValid() const 93 { 94 return m_opaque_sp->GetThreadSP().get() != NULL; 95 } 96 97 void 98 SBThread::Clear () 99 { 100 m_opaque_sp->Clear(); 101 } 102 103 104 StopReason 105 SBThread::GetStopReason() 106 { 107 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 108 109 StopReason reason = eStopReasonInvalid; 110 Mutex::Locker api_locker; 111 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 112 113 if (exe_ctx.HasThreadScope()) 114 { 115 Process::StopLocker stop_locker; 116 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 117 { 118 return exe_ctx.GetThreadPtr()->GetStopReason(); 119 } 120 else 121 { 122 if (log) 123 log->Printf ("SBThread(%p)::GetStopReason() => error: process is running", exe_ctx.GetThreadPtr()); 124 } 125 } 126 127 if (log) 128 log->Printf ("SBThread(%p)::GetStopReason () => %s", exe_ctx.GetThreadPtr(), 129 Thread::StopReasonAsCString (reason)); 130 131 return reason; 132 } 133 134 size_t 135 SBThread::GetStopReasonDataCount () 136 { 137 Mutex::Locker api_locker; 138 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 139 140 if (exe_ctx.HasThreadScope()) 141 { 142 Process::StopLocker stop_locker; 143 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 144 { 145 StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo (); 146 if (stop_info_sp) 147 { 148 StopReason reason = stop_info_sp->GetStopReason(); 149 switch (reason) 150 { 151 case eStopReasonInvalid: 152 case eStopReasonNone: 153 case eStopReasonTrace: 154 case eStopReasonExec: 155 case eStopReasonPlanComplete: 156 case eStopReasonThreadExiting: 157 // There is no data for these stop reasons. 158 return 0; 159 160 case eStopReasonBreakpoint: 161 { 162 break_id_t site_id = stop_info_sp->GetValue(); 163 lldb::BreakpointSiteSP bp_site_sp (exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID (site_id)); 164 if (bp_site_sp) 165 return bp_site_sp->GetNumberOfOwners () * 2; 166 else 167 return 0; // Breakpoint must have cleared itself... 168 } 169 break; 170 171 case eStopReasonWatchpoint: 172 return 1; 173 174 case eStopReasonSignal: 175 return 1; 176 177 case eStopReasonException: 178 return 1; 179 } 180 } 181 } 182 else 183 { 184 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 185 if (log) 186 log->Printf ("SBThread(%p)::GetStopReasonDataCount() => error: process is running", exe_ctx.GetThreadPtr()); 187 } 188 } 189 return 0; 190 } 191 192 uint64_t 193 SBThread::GetStopReasonDataAtIndex (uint32_t idx) 194 { 195 Mutex::Locker api_locker; 196 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 197 198 if (exe_ctx.HasThreadScope()) 199 { 200 Process::StopLocker stop_locker; 201 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 202 { 203 Thread *thread = exe_ctx.GetThreadPtr(); 204 StopInfoSP stop_info_sp = thread->GetStopInfo (); 205 if (stop_info_sp) 206 { 207 StopReason reason = stop_info_sp->GetStopReason(); 208 switch (reason) 209 { 210 case eStopReasonInvalid: 211 case eStopReasonNone: 212 case eStopReasonTrace: 213 case eStopReasonExec: 214 case eStopReasonPlanComplete: 215 case eStopReasonThreadExiting: 216 // There is no data for these stop reasons. 217 return 0; 218 219 case eStopReasonBreakpoint: 220 { 221 break_id_t site_id = stop_info_sp->GetValue(); 222 lldb::BreakpointSiteSP bp_site_sp (exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID (site_id)); 223 if (bp_site_sp) 224 { 225 uint32_t bp_index = idx / 2; 226 BreakpointLocationSP bp_loc_sp (bp_site_sp->GetOwnerAtIndex (bp_index)); 227 if (bp_loc_sp) 228 { 229 if (bp_index & 1) 230 { 231 // Odd idx, return the breakpoint location ID 232 return bp_loc_sp->GetID(); 233 } 234 else 235 { 236 // Even idx, return the breakpoint ID 237 return bp_loc_sp->GetBreakpoint().GetID(); 238 } 239 } 240 } 241 return LLDB_INVALID_BREAK_ID; 242 } 243 break; 244 245 case eStopReasonWatchpoint: 246 return stop_info_sp->GetValue(); 247 248 case eStopReasonSignal: 249 return stop_info_sp->GetValue(); 250 251 case eStopReasonException: 252 return stop_info_sp->GetValue(); 253 } 254 } 255 } 256 else 257 { 258 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 259 if (log) 260 log->Printf ("SBThread(%p)::GetStopReasonDataAtIndex() => error: process is running", exe_ctx.GetThreadPtr()); 261 } 262 } 263 return 0; 264 } 265 266 size_t 267 SBThread::GetStopDescription (char *dst, size_t dst_len) 268 { 269 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 270 271 Mutex::Locker api_locker; 272 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 273 274 if (exe_ctx.HasThreadScope()) 275 { 276 Process::StopLocker stop_locker; 277 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 278 { 279 280 StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo (); 281 if (stop_info_sp) 282 { 283 const char *stop_desc = stop_info_sp->GetDescription(); 284 if (stop_desc) 285 { 286 if (log) 287 log->Printf ("SBThread(%p)::GetStopDescription (dst, dst_len) => \"%s\"", 288 exe_ctx.GetThreadPtr(), stop_desc); 289 if (dst) 290 return ::snprintf (dst, dst_len, "%s", stop_desc); 291 else 292 { 293 // NULL dst passed in, return the length needed to contain the description 294 return ::strlen (stop_desc) + 1; // Include the NULL byte for size 295 } 296 } 297 else 298 { 299 size_t stop_desc_len = 0; 300 switch (stop_info_sp->GetStopReason()) 301 { 302 case eStopReasonTrace: 303 case eStopReasonPlanComplete: 304 { 305 static char trace_desc[] = "step"; 306 stop_desc = trace_desc; 307 stop_desc_len = sizeof(trace_desc); // Include the NULL byte for size 308 } 309 break; 310 311 case eStopReasonBreakpoint: 312 { 313 static char bp_desc[] = "breakpoint hit"; 314 stop_desc = bp_desc; 315 stop_desc_len = sizeof(bp_desc); // Include the NULL byte for size 316 } 317 break; 318 319 case eStopReasonWatchpoint: 320 { 321 static char wp_desc[] = "watchpoint hit"; 322 stop_desc = wp_desc; 323 stop_desc_len = sizeof(wp_desc); // Include the NULL byte for size 324 } 325 break; 326 327 case eStopReasonSignal: 328 { 329 stop_desc = exe_ctx.GetProcessPtr()->GetUnixSignals ().GetSignalAsCString (stop_info_sp->GetValue()); 330 if (stop_desc == NULL || stop_desc[0] == '\0') 331 { 332 static char signal_desc[] = "signal"; 333 stop_desc = signal_desc; 334 stop_desc_len = sizeof(signal_desc); // Include the NULL byte for size 335 } 336 } 337 break; 338 339 case eStopReasonException: 340 { 341 char exc_desc[] = "exception"; 342 stop_desc = exc_desc; 343 stop_desc_len = sizeof(exc_desc); // Include the NULL byte for size 344 } 345 break; 346 347 case eStopReasonExec: 348 { 349 char exc_desc[] = "exec"; 350 stop_desc = exc_desc; 351 stop_desc_len = sizeof(exc_desc); // Include the NULL byte for size 352 } 353 break; 354 355 case eStopReasonThreadExiting: 356 { 357 char limbo_desc[] = "thread exiting"; 358 stop_desc = limbo_desc; 359 stop_desc_len = sizeof(limbo_desc); 360 } 361 break; 362 default: 363 break; 364 } 365 366 if (stop_desc && stop_desc[0]) 367 { 368 if (log) 369 log->Printf ("SBThread(%p)::GetStopDescription (dst, dst_len) => '%s'", 370 exe_ctx.GetThreadPtr(), stop_desc); 371 372 if (dst) 373 return ::snprintf (dst, dst_len, "%s", stop_desc) + 1; // Include the NULL byte 374 375 if (stop_desc_len == 0) 376 stop_desc_len = ::strlen (stop_desc) + 1; // Include the NULL byte 377 378 return stop_desc_len; 379 } 380 } 381 } 382 } 383 else 384 { 385 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 386 if (log) 387 log->Printf ("SBThread(%p)::GetStopDescription() => error: process is running", exe_ctx.GetThreadPtr()); 388 } 389 } 390 if (dst) 391 *dst = 0; 392 return 0; 393 } 394 395 SBValue 396 SBThread::GetStopReturnValue () 397 { 398 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 399 ValueObjectSP return_valobj_sp; 400 Mutex::Locker api_locker; 401 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 402 403 if (exe_ctx.HasThreadScope()) 404 { 405 Process::StopLocker stop_locker; 406 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 407 { 408 StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo (); 409 if (stop_info_sp) 410 { 411 return_valobj_sp = StopInfo::GetReturnValueObject (stop_info_sp); 412 } 413 } 414 else 415 { 416 if (log) 417 log->Printf ("SBThread(%p)::GetStopReturnValue() => error: process is running", exe_ctx.GetThreadPtr()); 418 } 419 } 420 421 if (log) 422 log->Printf ("SBThread(%p)::GetStopReturnValue () => %s", exe_ctx.GetThreadPtr(), 423 return_valobj_sp.get() 424 ? return_valobj_sp->GetValueAsCString() 425 : "<no return value>"); 426 427 return SBValue (return_valobj_sp); 428 } 429 430 void 431 SBThread::SetThread (const ThreadSP& lldb_object_sp) 432 { 433 m_opaque_sp->SetThreadSP (lldb_object_sp); 434 } 435 436 437 lldb::tid_t 438 SBThread::GetThreadID () const 439 { 440 ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); 441 if (thread_sp) 442 return thread_sp->GetID(); 443 return LLDB_INVALID_THREAD_ID; 444 } 445 446 uint32_t 447 SBThread::GetIndexID () const 448 { 449 ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); 450 if (thread_sp) 451 return thread_sp->GetIndexID(); 452 return LLDB_INVALID_INDEX32; 453 } 454 455 const char * 456 SBThread::GetName () const 457 { 458 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 459 const char *name = NULL; 460 Mutex::Locker api_locker; 461 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 462 463 if (exe_ctx.HasThreadScope()) 464 { 465 Process::StopLocker stop_locker; 466 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 467 { 468 name = exe_ctx.GetThreadPtr()->GetName(); 469 } 470 else 471 { 472 if (log) 473 log->Printf ("SBThread(%p)::GetName() => error: process is running", exe_ctx.GetThreadPtr()); 474 } 475 } 476 477 if (log) 478 log->Printf ("SBThread(%p)::GetName () => %s", exe_ctx.GetThreadPtr(), name ? name : "NULL"); 479 480 return name; 481 } 482 483 const char * 484 SBThread::GetQueueName () const 485 { 486 const char *name = NULL; 487 Mutex::Locker api_locker; 488 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 489 490 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 491 if (exe_ctx.HasThreadScope()) 492 { 493 Process::StopLocker stop_locker; 494 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 495 { 496 name = exe_ctx.GetThreadPtr()->GetQueueName(); 497 } 498 else 499 { 500 if (log) 501 log->Printf ("SBThread(%p)::GetQueueName() => error: process is running", exe_ctx.GetThreadPtr()); 502 } 503 } 504 505 if (log) 506 log->Printf ("SBThread(%p)::GetQueueName () => %s", exe_ctx.GetThreadPtr(), name ? name : "NULL"); 507 508 return name; 509 } 510 511 lldb::queue_id_t 512 SBThread::GetQueueID () const 513 { 514 queue_id_t id = LLDB_INVALID_QUEUE_ID; 515 Mutex::Locker api_locker; 516 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 517 518 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 519 if (exe_ctx.HasThreadScope()) 520 { 521 Process::StopLocker stop_locker; 522 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 523 { 524 id = exe_ctx.GetThreadPtr()->GetQueueID(); 525 } 526 else 527 { 528 if (log) 529 log->Printf ("SBThread(%p)::GetQueueID() => error: process is running", exe_ctx.GetThreadPtr()); 530 } 531 } 532 533 if (log) 534 log->Printf ("SBThread(%p)::GetQueueID () => 0x%" PRIx64, exe_ctx.GetThreadPtr(), id); 535 536 return id; 537 } 538 539 SBError 540 SBThread::ResumeNewPlan (ExecutionContext &exe_ctx, ThreadPlan *new_plan) 541 { 542 SBError sb_error; 543 544 Process *process = exe_ctx.GetProcessPtr(); 545 if (!process) 546 { 547 sb_error.SetErrorString("No process in SBThread::ResumeNewPlan"); 548 return sb_error; 549 } 550 551 Thread *thread = exe_ctx.GetThreadPtr(); 552 if (!thread) 553 { 554 sb_error.SetErrorString("No thread in SBThread::ResumeNewPlan"); 555 return sb_error; 556 } 557 558 // User level plans should be Master Plans so they can be interrupted, other plans executed, and 559 // then a "continue" will resume the plan. 560 if (new_plan != NULL) 561 { 562 new_plan->SetIsMasterPlan(true); 563 new_plan->SetOkayToDiscard(false); 564 } 565 566 // Why do we need to set the current thread by ID here??? 567 process->GetThreadList().SetSelectedThreadByID (thread->GetID()); 568 sb_error.ref() = process->Resume(); 569 570 if (sb_error.Success()) 571 { 572 // If we are doing synchronous mode, then wait for the 573 // process to stop yet again! 574 if (process->GetTarget().GetDebugger().GetAsyncExecution () == false) 575 process->WaitForProcessToStop (NULL); 576 } 577 578 return sb_error; 579 } 580 581 void 582 SBThread::StepOver (lldb::RunMode stop_other_threads) 583 { 584 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 585 586 Mutex::Locker api_locker; 587 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 588 589 590 if (log) 591 log->Printf ("SBThread(%p)::StepOver (stop_other_threads='%s')", exe_ctx.GetThreadPtr(), 592 Thread::RunModeAsCString (stop_other_threads)); 593 594 if (exe_ctx.HasThreadScope()) 595 { 596 Thread *thread = exe_ctx.GetThreadPtr(); 597 bool abort_other_plans = false; 598 StackFrameSP frame_sp(thread->GetStackFrameAtIndex (0)); 599 600 ThreadPlanSP new_plan_sp; 601 if (frame_sp) 602 { 603 if (frame_sp->HasDebugInformation ()) 604 { 605 SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything)); 606 new_plan_sp = thread->QueueThreadPlanForStepOverRange (abort_other_plans, 607 sc.line_entry.range, 608 sc, 609 stop_other_threads); 610 } 611 else 612 { 613 new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction (true, 614 abort_other_plans, 615 stop_other_threads); 616 } 617 } 618 619 // This returns an error, we should use it! 620 ResumeNewPlan (exe_ctx, new_plan_sp.get()); 621 } 622 } 623 624 void 625 SBThread::StepInto (lldb::RunMode stop_other_threads) 626 { 627 StepInto (NULL, stop_other_threads); 628 } 629 630 void 631 SBThread::StepInto (const char *target_name, lldb::RunMode stop_other_threads) 632 { 633 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 634 635 Mutex::Locker api_locker; 636 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 637 638 if (log) 639 log->Printf ("SBThread(%p)::StepInto (target_name='%s', stop_other_threads='%s')", 640 exe_ctx.GetThreadPtr(), 641 target_name? target_name: "<NULL>", 642 Thread::RunModeAsCString (stop_other_threads)); 643 644 if (exe_ctx.HasThreadScope()) 645 { 646 bool abort_other_plans = false; 647 648 Thread *thread = exe_ctx.GetThreadPtr(); 649 StackFrameSP frame_sp(thread->GetStackFrameAtIndex (0)); 650 ThreadPlanSP new_plan_sp; 651 652 if (frame_sp && frame_sp->HasDebugInformation ()) 653 { 654 bool avoid_code_without_debug_info = true; 655 SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything)); 656 new_plan_sp = thread->QueueThreadPlanForStepInRange (abort_other_plans, 657 sc.line_entry.range, 658 sc, 659 target_name, 660 stop_other_threads, 661 avoid_code_without_debug_info); 662 } 663 else 664 { 665 new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction (false, 666 abort_other_plans, 667 stop_other_threads); 668 } 669 670 // This returns an error, we should use it! 671 ResumeNewPlan (exe_ctx, new_plan_sp.get()); 672 } 673 } 674 675 void 676 SBThread::StepOut () 677 { 678 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 679 680 Mutex::Locker api_locker; 681 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 682 683 684 if (log) 685 log->Printf ("SBThread(%p)::StepOut ()", exe_ctx.GetThreadPtr()); 686 687 if (exe_ctx.HasThreadScope()) 688 { 689 bool abort_other_plans = false; 690 bool stop_other_threads = false; 691 692 Thread *thread = exe_ctx.GetThreadPtr(); 693 694 ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut (abort_other_plans, 695 NULL, 696 false, 697 stop_other_threads, 698 eVoteYes, 699 eVoteNoOpinion, 700 0)); 701 702 // This returns an error, we should use it! 703 ResumeNewPlan (exe_ctx, new_plan_sp.get()); 704 } 705 } 706 707 void 708 SBThread::StepOutOfFrame (lldb::SBFrame &sb_frame) 709 { 710 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 711 712 Mutex::Locker api_locker; 713 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 714 715 StackFrameSP frame_sp (sb_frame.GetFrameSP()); 716 if (log) 717 { 718 SBStream frame_desc_strm; 719 sb_frame.GetDescription (frame_desc_strm); 720 log->Printf ("SBThread(%p)::StepOutOfFrame (frame = SBFrame(%p): %s)", exe_ctx.GetThreadPtr(), frame_sp.get(), frame_desc_strm.GetData()); 721 } 722 723 if (exe_ctx.HasThreadScope()) 724 { 725 bool abort_other_plans = false; 726 bool stop_other_threads = false; 727 Thread *thread = exe_ctx.GetThreadPtr(); 728 729 ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut (abort_other_plans, 730 NULL, 731 false, 732 stop_other_threads, 733 eVoteYes, 734 eVoteNoOpinion, 735 frame_sp->GetFrameIndex())); 736 737 // This returns an error, we should use it! 738 ResumeNewPlan (exe_ctx, new_plan_sp.get()); 739 } 740 } 741 742 void 743 SBThread::StepInstruction (bool step_over) 744 { 745 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 746 747 Mutex::Locker api_locker; 748 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 749 750 751 752 if (log) 753 log->Printf ("SBThread(%p)::StepInstruction (step_over=%i)", exe_ctx.GetThreadPtr(), step_over); 754 755 if (exe_ctx.HasThreadScope()) 756 { 757 Thread *thread = exe_ctx.GetThreadPtr(); 758 ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepSingleInstruction (step_over, true, true)); 759 760 // This returns an error, we should use it! 761 ResumeNewPlan (exe_ctx, new_plan_sp.get()); 762 } 763 } 764 765 void 766 SBThread::RunToAddress (lldb::addr_t addr) 767 { 768 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 769 770 Mutex::Locker api_locker; 771 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 772 773 774 if (log) 775 log->Printf ("SBThread(%p)::RunToAddress (addr=0x%" PRIx64 ")", exe_ctx.GetThreadPtr(), addr); 776 777 if (exe_ctx.HasThreadScope()) 778 { 779 bool abort_other_plans = false; 780 bool stop_other_threads = true; 781 782 Address target_addr (addr); 783 784 Thread *thread = exe_ctx.GetThreadPtr(); 785 786 ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForRunToAddress (abort_other_plans, target_addr, stop_other_threads)); 787 788 // This returns an error, we should use it! 789 ResumeNewPlan (exe_ctx, new_plan_sp.get()); 790 } 791 } 792 793 SBError 794 SBThread::StepOverUntil (lldb::SBFrame &sb_frame, 795 lldb::SBFileSpec &sb_file_spec, 796 uint32_t line) 797 { 798 SBError sb_error; 799 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 800 char path[PATH_MAX]; 801 802 Mutex::Locker api_locker; 803 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 804 805 StackFrameSP frame_sp (sb_frame.GetFrameSP()); 806 807 if (log) 808 { 809 SBStream frame_desc_strm; 810 sb_frame.GetDescription (frame_desc_strm); 811 sb_file_spec->GetPath (path, sizeof(path)); 812 log->Printf ("SBThread(%p)::StepOverUntil (frame = SBFrame(%p): %s, file+line = %s:%u)", 813 exe_ctx.GetThreadPtr(), 814 frame_sp.get(), 815 frame_desc_strm.GetData(), 816 path, line); 817 } 818 819 if (exe_ctx.HasThreadScope()) 820 { 821 Target *target = exe_ctx.GetTargetPtr(); 822 Thread *thread = exe_ctx.GetThreadPtr(); 823 824 if (line == 0) 825 { 826 sb_error.SetErrorString("invalid line argument"); 827 return sb_error; 828 } 829 830 if (!frame_sp) 831 { 832 frame_sp = thread->GetSelectedFrame (); 833 if (!frame_sp) 834 frame_sp = thread->GetStackFrameAtIndex (0); 835 } 836 837 SymbolContext frame_sc; 838 if (!frame_sp) 839 { 840 sb_error.SetErrorString("no valid frames in thread to step"); 841 return sb_error; 842 } 843 844 // If we have a frame, get its line 845 frame_sc = frame_sp->GetSymbolContext (eSymbolContextCompUnit | 846 eSymbolContextFunction | 847 eSymbolContextLineEntry | 848 eSymbolContextSymbol ); 849 850 if (frame_sc.comp_unit == NULL) 851 { 852 sb_error.SetErrorStringWithFormat("frame %u doesn't have debug information", frame_sp->GetFrameIndex()); 853 return sb_error; 854 } 855 856 FileSpec step_file_spec; 857 if (sb_file_spec.IsValid()) 858 { 859 // The file spec passed in was valid, so use it 860 step_file_spec = sb_file_spec.ref(); 861 } 862 else 863 { 864 if (frame_sc.line_entry.IsValid()) 865 step_file_spec = frame_sc.line_entry.file; 866 else 867 { 868 sb_error.SetErrorString("invalid file argument or no file for frame"); 869 return sb_error; 870 } 871 } 872 873 // Grab the current function, then we will make sure the "until" address is 874 // within the function. We discard addresses that are out of the current 875 // function, and then if there are no addresses remaining, give an appropriate 876 // error message. 877 878 bool all_in_function = true; 879 AddressRange fun_range = frame_sc.function->GetAddressRange(); 880 881 std::vector<addr_t> step_over_until_addrs; 882 const bool abort_other_plans = false; 883 const bool stop_other_threads = false; 884 const bool check_inlines = true; 885 const bool exact = false; 886 887 SymbolContextList sc_list; 888 const uint32_t num_matches = frame_sc.comp_unit->ResolveSymbolContext (step_file_spec, 889 line, 890 check_inlines, 891 exact, 892 eSymbolContextLineEntry, 893 sc_list); 894 if (num_matches > 0) 895 { 896 SymbolContext sc; 897 for (uint32_t i=0; i<num_matches; ++i) 898 { 899 if (sc_list.GetContextAtIndex(i, sc)) 900 { 901 addr_t step_addr = sc.line_entry.range.GetBaseAddress().GetLoadAddress(target); 902 if (step_addr != LLDB_INVALID_ADDRESS) 903 { 904 if (fun_range.ContainsLoadAddress(step_addr, target)) 905 step_over_until_addrs.push_back(step_addr); 906 else 907 all_in_function = false; 908 } 909 } 910 } 911 } 912 913 if (step_over_until_addrs.empty()) 914 { 915 if (all_in_function) 916 { 917 step_file_spec.GetPath (path, sizeof(path)); 918 sb_error.SetErrorStringWithFormat("No line entries for %s:%u", path, line); 919 } 920 else 921 sb_error.SetErrorString ("step until target not in current function"); 922 } 923 else 924 { 925 ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepUntil (abort_other_plans, 926 &step_over_until_addrs[0], 927 step_over_until_addrs.size(), 928 stop_other_threads, 929 frame_sp->GetFrameIndex())); 930 931 sb_error = ResumeNewPlan (exe_ctx, new_plan_sp.get()); 932 } 933 } 934 else 935 { 936 sb_error.SetErrorString("this SBThread object is invalid"); 937 } 938 return sb_error; 939 } 940 941 SBError 942 SBThread::JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line) 943 { 944 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 945 SBError sb_error; 946 947 Mutex::Locker api_locker; 948 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 949 950 if (log) 951 log->Printf ("SBThread(%p)::JumpToLine (file+line = %s:%u)", exe_ctx.GetThreadPtr(), file_spec->GetPath().c_str(), line); 952 953 if (!exe_ctx.HasThreadScope()) 954 { 955 sb_error.SetErrorString("this SBThread object is invalid"); 956 return sb_error; 957 } 958 959 Thread *thread = exe_ctx.GetThreadPtr(); 960 961 Error err = thread->JumpToLine (file_spec.get(), line, true); 962 sb_error.SetError (err); 963 return sb_error; 964 } 965 966 SBError 967 SBThread::ReturnFromFrame (SBFrame &frame, SBValue &return_value) 968 { 969 SBError sb_error; 970 971 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 972 973 Mutex::Locker api_locker; 974 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 975 976 977 if (log) 978 log->Printf ("SBThread(%p)::ReturnFromFrame (frame=%d)", exe_ctx.GetThreadPtr(), frame.GetFrameID()); 979 980 if (exe_ctx.HasThreadScope()) 981 { 982 Thread *thread = exe_ctx.GetThreadPtr(); 983 sb_error.SetError (thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP())); 984 } 985 986 return sb_error; 987 } 988 989 990 bool 991 SBThread::Suspend() 992 { 993 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 994 ExecutionContext exe_ctx (m_opaque_sp.get()); 995 bool result = false; 996 if (exe_ctx.HasThreadScope()) 997 { 998 Process::StopLocker stop_locker; 999 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 1000 { 1001 exe_ctx.GetThreadPtr()->SetResumeState (eStateSuspended); 1002 result = true; 1003 } 1004 else 1005 { 1006 if (log) 1007 log->Printf ("SBThread(%p)::Suspend() => error: process is running", exe_ctx.GetThreadPtr()); 1008 } 1009 } 1010 if (log) 1011 log->Printf ("SBThread(%p)::Suspend() => %i", exe_ctx.GetThreadPtr(), result); 1012 return result; 1013 } 1014 1015 bool 1016 SBThread::Resume () 1017 { 1018 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1019 ExecutionContext exe_ctx (m_opaque_sp.get()); 1020 bool result = false; 1021 if (exe_ctx.HasThreadScope()) 1022 { 1023 Process::StopLocker stop_locker; 1024 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 1025 { 1026 exe_ctx.GetThreadPtr()->SetResumeState (eStateRunning); 1027 result = true; 1028 } 1029 else 1030 { 1031 if (log) 1032 log->Printf ("SBThread(%p)::Resume() => error: process is running", exe_ctx.GetThreadPtr()); 1033 } 1034 } 1035 if (log) 1036 log->Printf ("SBThread(%p)::Resume() => %i", exe_ctx.GetThreadPtr(), result); 1037 return result; 1038 } 1039 1040 bool 1041 SBThread::IsSuspended() 1042 { 1043 ExecutionContext exe_ctx (m_opaque_sp.get()); 1044 if (exe_ctx.HasThreadScope()) 1045 return exe_ctx.GetThreadPtr()->GetResumeState () == eStateSuspended; 1046 return false; 1047 } 1048 1049 bool 1050 SBThread::IsStopped() 1051 { 1052 ExecutionContext exe_ctx (m_opaque_sp.get()); 1053 if (exe_ctx.HasThreadScope()) 1054 return StateIsStoppedState(exe_ctx.GetThreadPtr()->GetState(), true); 1055 return false; 1056 } 1057 1058 SBProcess 1059 SBThread::GetProcess () 1060 { 1061 SBProcess sb_process; 1062 ExecutionContext exe_ctx (m_opaque_sp.get()); 1063 if (exe_ctx.HasThreadScope()) 1064 { 1065 // Have to go up to the target so we can get a shared pointer to our process... 1066 sb_process.SetSP (exe_ctx.GetProcessSP()); 1067 } 1068 1069 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1070 if (log) 1071 { 1072 SBStream frame_desc_strm; 1073 sb_process.GetDescription (frame_desc_strm); 1074 log->Printf ("SBThread(%p)::GetProcess () => SBProcess(%p): %s", exe_ctx.GetThreadPtr(), 1075 sb_process.GetSP().get(), frame_desc_strm.GetData()); 1076 } 1077 1078 return sb_process; 1079 } 1080 1081 uint32_t 1082 SBThread::GetNumFrames () 1083 { 1084 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1085 1086 uint32_t num_frames = 0; 1087 Mutex::Locker api_locker; 1088 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1089 1090 if (exe_ctx.HasThreadScope()) 1091 { 1092 Process::StopLocker stop_locker; 1093 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 1094 { 1095 num_frames = exe_ctx.GetThreadPtr()->GetStackFrameCount(); 1096 } 1097 else 1098 { 1099 if (log) 1100 log->Printf ("SBThread(%p)::GetNumFrames() => error: process is running", exe_ctx.GetThreadPtr()); 1101 } 1102 } 1103 1104 if (log) 1105 log->Printf ("SBThread(%p)::GetNumFrames () => %u", exe_ctx.GetThreadPtr(), num_frames); 1106 1107 return num_frames; 1108 } 1109 1110 SBFrame 1111 SBThread::GetFrameAtIndex (uint32_t idx) 1112 { 1113 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1114 1115 SBFrame sb_frame; 1116 StackFrameSP frame_sp; 1117 Mutex::Locker api_locker; 1118 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1119 1120 if (exe_ctx.HasThreadScope()) 1121 { 1122 Process::StopLocker stop_locker; 1123 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 1124 { 1125 frame_sp = exe_ctx.GetThreadPtr()->GetStackFrameAtIndex (idx); 1126 sb_frame.SetFrameSP (frame_sp); 1127 } 1128 else 1129 { 1130 if (log) 1131 log->Printf ("SBThread(%p)::GetFrameAtIndex() => error: process is running", exe_ctx.GetThreadPtr()); 1132 } 1133 } 1134 1135 if (log) 1136 { 1137 SBStream frame_desc_strm; 1138 sb_frame.GetDescription (frame_desc_strm); 1139 log->Printf ("SBThread(%p)::GetFrameAtIndex (idx=%d) => SBFrame(%p): %s", 1140 exe_ctx.GetThreadPtr(), idx, frame_sp.get(), frame_desc_strm.GetData()); 1141 } 1142 1143 return sb_frame; 1144 } 1145 1146 lldb::SBFrame 1147 SBThread::GetSelectedFrame () 1148 { 1149 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1150 1151 SBFrame sb_frame; 1152 StackFrameSP frame_sp; 1153 Mutex::Locker api_locker; 1154 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1155 1156 if (exe_ctx.HasThreadScope()) 1157 { 1158 Process::StopLocker stop_locker; 1159 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 1160 { 1161 frame_sp = exe_ctx.GetThreadPtr()->GetSelectedFrame (); 1162 sb_frame.SetFrameSP (frame_sp); 1163 } 1164 else 1165 { 1166 if (log) 1167 log->Printf ("SBThread(%p)::GetSelectedFrame() => error: process is running", exe_ctx.GetThreadPtr()); 1168 } 1169 } 1170 1171 if (log) 1172 { 1173 SBStream frame_desc_strm; 1174 sb_frame.GetDescription (frame_desc_strm); 1175 log->Printf ("SBThread(%p)::GetSelectedFrame () => SBFrame(%p): %s", 1176 exe_ctx.GetThreadPtr(), frame_sp.get(), frame_desc_strm.GetData()); 1177 } 1178 1179 return sb_frame; 1180 } 1181 1182 lldb::SBFrame 1183 SBThread::SetSelectedFrame (uint32_t idx) 1184 { 1185 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1186 1187 SBFrame sb_frame; 1188 StackFrameSP frame_sp; 1189 Mutex::Locker api_locker; 1190 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1191 1192 if (exe_ctx.HasThreadScope()) 1193 { 1194 Process::StopLocker stop_locker; 1195 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 1196 { 1197 Thread *thread = exe_ctx.GetThreadPtr(); 1198 frame_sp = thread->GetStackFrameAtIndex (idx); 1199 if (frame_sp) 1200 { 1201 thread->SetSelectedFrame (frame_sp.get()); 1202 sb_frame.SetFrameSP (frame_sp); 1203 } 1204 } 1205 else 1206 { 1207 if (log) 1208 log->Printf ("SBThread(%p)::SetSelectedFrame() => error: process is running", exe_ctx.GetThreadPtr()); 1209 } 1210 } 1211 1212 if (log) 1213 { 1214 SBStream frame_desc_strm; 1215 sb_frame.GetDescription (frame_desc_strm); 1216 log->Printf ("SBThread(%p)::SetSelectedFrame (idx=%u) => SBFrame(%p): %s", 1217 exe_ctx.GetThreadPtr(), idx, frame_sp.get(), frame_desc_strm.GetData()); 1218 } 1219 return sb_frame; 1220 } 1221 1222 bool 1223 SBThread::EventIsThreadEvent (const SBEvent &event) 1224 { 1225 return Thread::ThreadEventData::GetEventDataFromEvent(event.get()) != NULL; 1226 } 1227 1228 SBFrame 1229 SBThread::GetStackFrameFromEvent (const SBEvent &event) 1230 { 1231 return Thread::ThreadEventData::GetStackFrameFromEvent (event.get()); 1232 1233 } 1234 1235 SBThread 1236 SBThread::GetThreadFromEvent (const SBEvent &event) 1237 { 1238 return Thread::ThreadEventData::GetThreadFromEvent (event.get()); 1239 } 1240 1241 bool 1242 SBThread::operator == (const SBThread &rhs) const 1243 { 1244 return m_opaque_sp->GetThreadSP().get() == rhs.m_opaque_sp->GetThreadSP().get(); 1245 } 1246 1247 bool 1248 SBThread::operator != (const SBThread &rhs) const 1249 { 1250 return m_opaque_sp->GetThreadSP().get() != rhs.m_opaque_sp->GetThreadSP().get(); 1251 } 1252 1253 bool 1254 SBThread::GetStatus (SBStream &status) const 1255 { 1256 Stream &strm = status.ref(); 1257 1258 ExecutionContext exe_ctx (m_opaque_sp.get()); 1259 if (exe_ctx.HasThreadScope()) 1260 { 1261 exe_ctx.GetThreadPtr()->GetStatus(strm, 0, 1, 1); 1262 } 1263 else 1264 strm.PutCString ("No status"); 1265 1266 return true; 1267 } 1268 1269 bool 1270 SBThread::GetDescription (SBStream &description) const 1271 { 1272 Stream &strm = description.ref(); 1273 1274 ExecutionContext exe_ctx (m_opaque_sp.get()); 1275 if (exe_ctx.HasThreadScope()) 1276 { 1277 strm.Printf("SBThread: tid = 0x%4.4" PRIx64, exe_ctx.GetThreadPtr()->GetID()); 1278 } 1279 else 1280 strm.PutCString ("No value"); 1281 1282 return true; 1283 } 1284 1285 SBThread 1286 SBThread::GetExtendedBacktrace (const char *type) 1287 { 1288 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1289 Mutex::Locker api_locker; 1290 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1291 SBThread sb_origin_thread; 1292 1293 if (exe_ctx.HasThreadScope()) 1294 { 1295 Process::StopLocker stop_locker; 1296 if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) 1297 { 1298 ThreadSP real_thread(exe_ctx.GetThreadPtr()); 1299 if (real_thread) 1300 { 1301 ConstString type_const (type); 1302 SystemRuntime *runtime = exe_ctx.GetProcessPtr()->GetSystemRuntime(); 1303 if (runtime) 1304 { 1305 ThreadSP origin_thread = runtime->GetExtendedBacktrace (real_thread, type_const); 1306 sb_origin_thread.SetThread (origin_thread); 1307 } 1308 } 1309 } 1310 else 1311 { 1312 if (log) 1313 log->Printf ("SBThread(%p)::GetExtendedBacktrace() => error: process is running", exe_ctx.GetThreadPtr()); 1314 } 1315 } 1316 1317 return sb_origin_thread; 1318 } 1319