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