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