1 //===-- SBTarget.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/SBTarget.h" 11 12 #include "lldb/lldb-public.h" 13 14 #include "lldb/API/SBBreakpoint.h" 15 #include "lldb/API/SBDebugger.h" 16 #include "lldb/API/SBEvent.h" 17 #include "lldb/API/SBExpressionOptions.h" 18 #include "lldb/API/SBFileSpec.h" 19 #include "lldb/API/SBListener.h" 20 #include "lldb/API/SBModule.h" 21 #include "lldb/API/SBModuleSpec.h" 22 #include "lldb/API/SBProcess.h" 23 #include "lldb/API/SBSourceManager.h" 24 #include "lldb/API/SBStream.h" 25 #include "lldb/API/SBStringList.h" 26 #include "lldb/API/SBStructuredData.h" 27 #include "lldb/API/SBSymbolContextList.h" 28 #include "lldb/Breakpoint/BreakpointID.h" 29 #include "lldb/Breakpoint/BreakpointIDList.h" 30 #include "lldb/Breakpoint/BreakpointList.h" 31 #include "lldb/Breakpoint/BreakpointLocation.h" 32 #include "lldb/Core/Address.h" 33 #include "lldb/Core/AddressResolver.h" 34 #include "lldb/Core/AddressResolverName.h" 35 #include "lldb/Core/Debugger.h" 36 #include "lldb/Core/Disassembler.h" 37 #include "lldb/Core/Module.h" 38 #include "lldb/Core/ModuleSpec.h" 39 #include "lldb/Core/STLUtils.h" 40 #include "lldb/Core/SearchFilter.h" 41 #include "lldb/Core/Section.h" 42 #include "lldb/Core/StructuredDataImpl.h" 43 #include "lldb/Core/ValueObjectConstResult.h" 44 #include "lldb/Core/ValueObjectList.h" 45 #include "lldb/Core/ValueObjectVariable.h" 46 #include "lldb/Host/Host.h" 47 #include "lldb/Symbol/ClangASTContext.h" 48 #include "lldb/Symbol/DeclVendor.h" 49 #include "lldb/Symbol/ObjectFile.h" 50 #include "lldb/Symbol/SymbolFile.h" 51 #include "lldb/Symbol/SymbolVendor.h" 52 #include "lldb/Symbol/VariableList.h" 53 #include "lldb/Target/ABI.h" 54 #include "lldb/Target/Language.h" 55 #include "lldb/Target/LanguageRuntime.h" 56 #include "lldb/Target/ObjCLanguageRuntime.h" 57 #include "lldb/Target/Process.h" 58 #include "lldb/Target/StackFrame.h" 59 #include "lldb/Target/Target.h" 60 #include "lldb/Target/TargetList.h" 61 #include "lldb/Utility/ArchSpec.h" 62 #include "lldb/Utility/Args.h" 63 #include "lldb/Utility/FileSpec.h" 64 #include "lldb/Utility/Log.h" 65 #include "lldb/Utility/RegularExpression.h" 66 67 #include "Commands/CommandObjectBreakpoint.h" 68 #include "lldb/Interpreter/CommandReturnObject.h" 69 #include "llvm/Support/PrettyStackTrace.h" 70 #include "llvm/Support/Regex.h" 71 72 using namespace lldb; 73 using namespace lldb_private; 74 75 #define DEFAULT_DISASM_BYTE_SIZE 32 76 77 namespace { 78 79 Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) { 80 std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex()); 81 82 auto process_sp = target.GetProcessSP(); 83 if (process_sp) { 84 const auto state = process_sp->GetState(); 85 if (process_sp->IsAlive() && state == eStateConnected) { 86 // If we are already connected, then we have already specified the 87 // listener, so if a valid listener is supplied, we need to error out to 88 // let the client know. 89 if (attach_info.GetListener()) 90 return Status("process is connected and already has a listener, pass " 91 "empty listener"); 92 } 93 } 94 95 return target.Attach(attach_info, nullptr); 96 } 97 98 } // namespace 99 100 //---------------------------------------------------------------------- 101 // SBTarget constructor 102 //---------------------------------------------------------------------- 103 SBTarget::SBTarget() : m_opaque_sp() {} 104 105 SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {} 106 107 SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {} 108 109 const SBTarget &SBTarget::operator=(const SBTarget &rhs) { 110 if (this != &rhs) 111 m_opaque_sp = rhs.m_opaque_sp; 112 return *this; 113 } 114 115 //---------------------------------------------------------------------- 116 // Destructor 117 //---------------------------------------------------------------------- 118 SBTarget::~SBTarget() {} 119 120 bool SBTarget::EventIsTargetEvent(const SBEvent &event) { 121 return Target::TargetEventData::GetEventDataFromEvent(event.get()) != NULL; 122 } 123 124 SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) { 125 return Target::TargetEventData::GetTargetFromEvent(event.get()); 126 } 127 128 uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) { 129 const ModuleList module_list = 130 Target::TargetEventData::GetModuleListFromEvent(event.get()); 131 return module_list.GetSize(); 132 } 133 134 SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx, 135 const SBEvent &event) { 136 const ModuleList module_list = 137 Target::TargetEventData::GetModuleListFromEvent(event.get()); 138 return SBModule(module_list.GetModuleAtIndex(idx)); 139 } 140 141 const char *SBTarget::GetBroadcasterClassName() { 142 return Target::GetStaticBroadcasterClass().AsCString(); 143 } 144 145 bool SBTarget::IsValid() const { 146 return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid(); 147 } 148 149 SBProcess SBTarget::GetProcess() { 150 SBProcess sb_process; 151 ProcessSP process_sp; 152 TargetSP target_sp(GetSP()); 153 if (target_sp) { 154 process_sp = target_sp->GetProcessSP(); 155 sb_process.SetSP(process_sp); 156 } 157 158 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 159 if (log) 160 log->Printf("SBTarget(%p)::GetProcess () => SBProcess(%p)", 161 static_cast<void *>(target_sp.get()), 162 static_cast<void *>(process_sp.get())); 163 164 return sb_process; 165 } 166 167 SBPlatform SBTarget::GetPlatform() { 168 TargetSP target_sp(GetSP()); 169 if (!target_sp) 170 return SBPlatform(); 171 172 SBPlatform platform; 173 platform.m_opaque_sp = target_sp->GetPlatform(); 174 175 return platform; 176 } 177 178 SBDebugger SBTarget::GetDebugger() const { 179 SBDebugger debugger; 180 TargetSP target_sp(GetSP()); 181 if (target_sp) 182 debugger.reset(target_sp->GetDebugger().shared_from_this()); 183 return debugger; 184 } 185 186 SBStructuredData SBTarget::GetStatistics() { 187 SBStructuredData data; 188 TargetSP target_sp(GetSP()); 189 if (!target_sp) 190 return data; 191 192 auto stats_up = llvm::make_unique<StructuredData::Dictionary>(); 193 int i = 0; 194 for (auto &Entry : target_sp->GetStatistics()) { 195 std::string Desc = lldb_private::GetStatDescription( 196 static_cast<lldb_private::StatisticKind>(i)); 197 stats_up->AddIntegerItem(Desc, Entry); 198 i += 1; 199 } 200 201 data.m_impl_up->SetObjectSP(std::move(stats_up)); 202 return data; 203 } 204 205 SBProcess SBTarget::LoadCore(const char *core_file) { 206 lldb::SBError error; // Ignored 207 return LoadCore(core_file, error); 208 } 209 210 SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) { 211 SBProcess sb_process; 212 TargetSP target_sp(GetSP()); 213 if (target_sp) { 214 FileSpec filespec(core_file, true); 215 ProcessSP process_sp(target_sp->CreateProcess( 216 target_sp->GetDebugger().GetListener(), "", &filespec)); 217 if (process_sp) { 218 error.SetError(process_sp->LoadCore()); 219 if (error.Success()) 220 sb_process.SetSP(process_sp); 221 } else { 222 error.SetErrorString("Failed to create the process"); 223 } 224 } else { 225 error.SetErrorString("SBTarget is invalid"); 226 } 227 return sb_process; 228 } 229 230 SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp, 231 const char *working_directory) { 232 char *stdin_path = NULL; 233 char *stdout_path = NULL; 234 char *stderr_path = NULL; 235 uint32_t launch_flags = 0; 236 bool stop_at_entry = false; 237 SBError error; 238 SBListener listener = GetDebugger().GetListener(); 239 return Launch(listener, argv, envp, stdin_path, stdout_path, stderr_path, 240 working_directory, launch_flags, stop_at_entry, error); 241 } 242 243 SBError SBTarget::Install() { 244 SBError sb_error; 245 TargetSP target_sp(GetSP()); 246 if (target_sp) { 247 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 248 sb_error.ref() = target_sp->Install(NULL); 249 } 250 return sb_error; 251 } 252 253 SBProcess SBTarget::Launch(SBListener &listener, char const **argv, 254 char const **envp, const char *stdin_path, 255 const char *stdout_path, const char *stderr_path, 256 const char *working_directory, 257 uint32_t launch_flags, // See LaunchFlags 258 bool stop_at_entry, lldb::SBError &error) { 259 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 260 261 SBProcess sb_process; 262 ProcessSP process_sp; 263 TargetSP target_sp(GetSP()); 264 265 if (log) 266 log->Printf("SBTarget(%p)::Launch (argv=%p, envp=%p, stdin=%s, stdout=%s, " 267 "stderr=%s, working-dir=%s, launch_flags=0x%x, " 268 "stop_at_entry=%i, &error (%p))...", 269 static_cast<void *>(target_sp.get()), static_cast<void *>(argv), 270 static_cast<void *>(envp), stdin_path ? stdin_path : "NULL", 271 stdout_path ? stdout_path : "NULL", 272 stderr_path ? stderr_path : "NULL", 273 working_directory ? working_directory : "NULL", launch_flags, 274 stop_at_entry, static_cast<void *>(error.get())); 275 276 if (target_sp) { 277 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 278 279 if (stop_at_entry) 280 launch_flags |= eLaunchFlagStopAtEntry; 281 282 if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR")) 283 launch_flags |= eLaunchFlagDisableASLR; 284 285 StateType state = eStateInvalid; 286 process_sp = target_sp->GetProcessSP(); 287 if (process_sp) { 288 state = process_sp->GetState(); 289 290 if (process_sp->IsAlive() && state != eStateConnected) { 291 if (state == eStateAttaching) 292 error.SetErrorString("process attach is in progress"); 293 else 294 error.SetErrorString("a process is already being debugged"); 295 return sb_process; 296 } 297 } 298 299 if (state == eStateConnected) { 300 // If we are already connected, then we have already specified the 301 // listener, so if a valid listener is supplied, we need to error out to 302 // let the client know. 303 if (listener.IsValid()) { 304 error.SetErrorString("process is connected and already has a listener, " 305 "pass empty listener"); 306 return sb_process; 307 } 308 } 309 310 if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO")) 311 launch_flags |= eLaunchFlagDisableSTDIO; 312 313 ProcessLaunchInfo launch_info( 314 FileSpec{stdin_path, false}, FileSpec{stdout_path, false}, 315 FileSpec{stderr_path, false}, FileSpec{working_directory, false}, 316 launch_flags); 317 318 Module *exe_module = target_sp->GetExecutableModulePointer(); 319 if (exe_module) 320 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); 321 if (argv) 322 launch_info.GetArguments().AppendArguments(argv); 323 if (envp) 324 launch_info.GetEnvironment() = Environment(envp); 325 326 if (listener.IsValid()) 327 launch_info.SetListener(listener.GetSP()); 328 329 error.SetError(target_sp->Launch(launch_info, NULL)); 330 331 sb_process.SetSP(target_sp->GetProcessSP()); 332 } else { 333 error.SetErrorString("SBTarget is invalid"); 334 } 335 336 log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API); 337 if (log) 338 log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p), SBError(%s)", 339 static_cast<void *>(target_sp.get()), 340 static_cast<void *>(sb_process.GetSP().get()), 341 error.GetCString()); 342 343 return sb_process; 344 } 345 346 SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { 347 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 348 349 SBProcess sb_process; 350 TargetSP target_sp(GetSP()); 351 352 if (log) 353 log->Printf("SBTarget(%p)::Launch (launch_info, error)...", 354 static_cast<void *>(target_sp.get())); 355 356 if (target_sp) { 357 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 358 StateType state = eStateInvalid; 359 { 360 ProcessSP process_sp = target_sp->GetProcessSP(); 361 if (process_sp) { 362 state = process_sp->GetState(); 363 364 if (process_sp->IsAlive() && state != eStateConnected) { 365 if (state == eStateAttaching) 366 error.SetErrorString("process attach is in progress"); 367 else 368 error.SetErrorString("a process is already being debugged"); 369 return sb_process; 370 } 371 } 372 } 373 374 lldb_private::ProcessLaunchInfo launch_info = sb_launch_info.ref(); 375 376 if (!launch_info.GetExecutableFile()) { 377 Module *exe_module = target_sp->GetExecutableModulePointer(); 378 if (exe_module) 379 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); 380 } 381 382 const ArchSpec &arch_spec = target_sp->GetArchitecture(); 383 if (arch_spec.IsValid()) 384 launch_info.GetArchitecture() = arch_spec; 385 386 error.SetError(target_sp->Launch(launch_info, NULL)); 387 sb_launch_info.set_ref(launch_info); 388 sb_process.SetSP(target_sp->GetProcessSP()); 389 } else { 390 error.SetErrorString("SBTarget is invalid"); 391 } 392 393 log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API); 394 if (log) 395 log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p)", 396 static_cast<void *>(target_sp.get()), 397 static_cast<void *>(sb_process.GetSP().get())); 398 399 return sb_process; 400 } 401 402 lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { 403 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 404 405 SBProcess sb_process; 406 TargetSP target_sp(GetSP()); 407 408 if (log) 409 log->Printf("SBTarget(%p)::Attach (sb_attach_info, error)...", 410 static_cast<void *>(target_sp.get())); 411 412 if (target_sp) { 413 ProcessAttachInfo &attach_info = sb_attach_info.ref(); 414 if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) { 415 PlatformSP platform_sp = target_sp->GetPlatform(); 416 // See if we can pre-verify if a process exists or not 417 if (platform_sp && platform_sp->IsConnected()) { 418 lldb::pid_t attach_pid = attach_info.GetProcessID(); 419 ProcessInstanceInfo instance_info; 420 if (platform_sp->GetProcessInfo(attach_pid, instance_info)) { 421 attach_info.SetUserID(instance_info.GetEffectiveUserID()); 422 } else { 423 error.ref().SetErrorStringWithFormat( 424 "no process found with process ID %" PRIu64, attach_pid); 425 if (log) { 426 log->Printf("SBTarget(%p)::Attach (...) => error %s", 427 static_cast<void *>(target_sp.get()), 428 error.GetCString()); 429 } 430 return sb_process; 431 } 432 } 433 } 434 error.SetError(AttachToProcess(attach_info, *target_sp)); 435 if (error.Success()) 436 sb_process.SetSP(target_sp->GetProcessSP()); 437 } else { 438 error.SetErrorString("SBTarget is invalid"); 439 } 440 441 if (log) 442 log->Printf("SBTarget(%p)::Attach (...) => SBProcess(%p)", 443 static_cast<void *>(target_sp.get()), 444 static_cast<void *>(sb_process.GetSP().get())); 445 446 return sb_process; 447 } 448 449 lldb::SBProcess SBTarget::AttachToProcessWithID( 450 SBListener &listener, 451 lldb::pid_t pid, // The process ID to attach to 452 SBError &error // An error explaining what went wrong if attach fails 453 ) { 454 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 455 456 SBProcess sb_process; 457 TargetSP target_sp(GetSP()); 458 459 if (log) 460 log->Printf("SBTarget(%p)::%s (listener, pid=%" PRId64 ", error)...", 461 static_cast<void *>(target_sp.get()), __FUNCTION__, pid); 462 463 if (target_sp) { 464 ProcessAttachInfo attach_info; 465 attach_info.SetProcessID(pid); 466 if (listener.IsValid()) 467 attach_info.SetListener(listener.GetSP()); 468 469 ProcessInstanceInfo instance_info; 470 if (target_sp->GetPlatform()->GetProcessInfo(pid, instance_info)) 471 attach_info.SetUserID(instance_info.GetEffectiveUserID()); 472 473 error.SetError(AttachToProcess(attach_info, *target_sp)); 474 if (error.Success()) 475 sb_process.SetSP(target_sp->GetProcessSP()); 476 } else 477 error.SetErrorString("SBTarget is invalid"); 478 479 if (log) 480 log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)", 481 static_cast<void *>(target_sp.get()), __FUNCTION__, 482 static_cast<void *>(sb_process.GetSP().get())); 483 return sb_process; 484 } 485 486 lldb::SBProcess SBTarget::AttachToProcessWithName( 487 SBListener &listener, 488 const char *name, // basename of process to attach to 489 bool wait_for, // if true wait for a new instance of "name" to be launched 490 SBError &error // An error explaining what went wrong if attach fails 491 ) { 492 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 493 494 SBProcess sb_process; 495 TargetSP target_sp(GetSP()); 496 497 if (log) 498 log->Printf("SBTarget(%p)::%s (listener, name=%s, wait_for=%s, error)...", 499 static_cast<void *>(target_sp.get()), __FUNCTION__, name, 500 wait_for ? "true" : "false"); 501 502 if (name && target_sp) { 503 ProcessAttachInfo attach_info; 504 attach_info.GetExecutableFile().SetFile(name, false, 505 FileSpec::Style::native); 506 attach_info.SetWaitForLaunch(wait_for); 507 if (listener.IsValid()) 508 attach_info.SetListener(listener.GetSP()); 509 510 error.SetError(AttachToProcess(attach_info, *target_sp)); 511 if (error.Success()) 512 sb_process.SetSP(target_sp->GetProcessSP()); 513 } else 514 error.SetErrorString("SBTarget is invalid"); 515 516 if (log) 517 log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)", 518 static_cast<void *>(target_sp.get()), __FUNCTION__, 519 static_cast<void *>(sb_process.GetSP().get())); 520 return sb_process; 521 } 522 523 lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, 524 const char *plugin_name, 525 SBError &error) { 526 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 527 528 SBProcess sb_process; 529 ProcessSP process_sp; 530 TargetSP target_sp(GetSP()); 531 532 if (log) 533 log->Printf("SBTarget(%p)::ConnectRemote (listener, url=%s, " 534 "plugin_name=%s, error)...", 535 static_cast<void *>(target_sp.get()), url, plugin_name); 536 537 if (target_sp) { 538 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 539 if (listener.IsValid()) 540 process_sp = 541 target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, NULL); 542 else 543 process_sp = target_sp->CreateProcess( 544 target_sp->GetDebugger().GetListener(), plugin_name, NULL); 545 546 if (process_sp) { 547 sb_process.SetSP(process_sp); 548 error.SetError(process_sp->ConnectRemote(NULL, url)); 549 } else { 550 error.SetErrorString("unable to create lldb_private::Process"); 551 } 552 } else { 553 error.SetErrorString("SBTarget is invalid"); 554 } 555 556 if (log) 557 log->Printf("SBTarget(%p)::ConnectRemote (...) => SBProcess(%p)", 558 static_cast<void *>(target_sp.get()), 559 static_cast<void *>(process_sp.get())); 560 return sb_process; 561 } 562 563 SBFileSpec SBTarget::GetExecutable() { 564 565 SBFileSpec exe_file_spec; 566 TargetSP target_sp(GetSP()); 567 if (target_sp) { 568 Module *exe_module = target_sp->GetExecutableModulePointer(); 569 if (exe_module) 570 exe_file_spec.SetFileSpec(exe_module->GetFileSpec()); 571 } 572 573 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 574 if (log) { 575 log->Printf("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)", 576 static_cast<void *>(target_sp.get()), 577 static_cast<const void *>(exe_file_spec.get())); 578 } 579 580 return exe_file_spec; 581 } 582 583 bool SBTarget::operator==(const SBTarget &rhs) const { 584 return m_opaque_sp.get() == rhs.m_opaque_sp.get(); 585 } 586 587 bool SBTarget::operator!=(const SBTarget &rhs) const { 588 return m_opaque_sp.get() != rhs.m_opaque_sp.get(); 589 } 590 591 lldb::TargetSP SBTarget::GetSP() const { return m_opaque_sp; } 592 593 void SBTarget::SetSP(const lldb::TargetSP &target_sp) { 594 m_opaque_sp = target_sp; 595 } 596 597 lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) { 598 lldb::SBAddress sb_addr; 599 Address &addr = sb_addr.ref(); 600 TargetSP target_sp(GetSP()); 601 if (target_sp) { 602 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 603 if (target_sp->ResolveLoadAddress(vm_addr, addr)) 604 return sb_addr; 605 } 606 607 // We have a load address that isn't in a section, just return an address 608 // with the offset filled in (the address) and the section set to NULL 609 addr.SetRawAddress(vm_addr); 610 return sb_addr; 611 } 612 613 lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) { 614 lldb::SBAddress sb_addr; 615 Address &addr = sb_addr.ref(); 616 TargetSP target_sp(GetSP()); 617 if (target_sp) { 618 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 619 if (target_sp->ResolveFileAddress(file_addr, addr)) 620 return sb_addr; 621 } 622 623 addr.SetRawAddress(file_addr); 624 return sb_addr; 625 } 626 627 lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id, 628 lldb::addr_t vm_addr) { 629 lldb::SBAddress sb_addr; 630 Address &addr = sb_addr.ref(); 631 TargetSP target_sp(GetSP()); 632 if (target_sp) { 633 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 634 if (target_sp->ResolveLoadAddress(vm_addr, addr)) 635 return sb_addr; 636 } 637 638 // We have a load address that isn't in a section, just return an address 639 // with the offset filled in (the address) and the section set to NULL 640 addr.SetRawAddress(vm_addr); 641 return sb_addr; 642 } 643 644 SBSymbolContext 645 SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr, 646 uint32_t resolve_scope) { 647 SBSymbolContext sc; 648 if (addr.IsValid()) { 649 TargetSP target_sp(GetSP()); 650 if (target_sp) 651 target_sp->GetImages().ResolveSymbolContextForAddress( 652 addr.ref(), resolve_scope, sc.ref()); 653 } 654 return sc; 655 } 656 657 size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, 658 lldb::SBError &error) { 659 SBError sb_error; 660 size_t bytes_read = 0; 661 TargetSP target_sp(GetSP()); 662 if (target_sp) { 663 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 664 bytes_read = 665 target_sp->ReadMemory(addr.ref(), false, buf, size, sb_error.ref()); 666 } else { 667 sb_error.SetErrorString("invalid target"); 668 } 669 670 return bytes_read; 671 } 672 673 SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, 674 uint32_t line) { 675 return SBBreakpoint( 676 BreakpointCreateByLocation(SBFileSpec(file, false), line)); 677 } 678 679 SBBreakpoint 680 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, 681 uint32_t line) { 682 return BreakpointCreateByLocation(sb_file_spec, line, 0); 683 } 684 685 SBBreakpoint 686 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, 687 uint32_t line, lldb::addr_t offset) { 688 SBFileSpecList empty_list; 689 return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list); 690 } 691 692 SBBreakpoint 693 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, 694 uint32_t line, lldb::addr_t offset, 695 SBFileSpecList &sb_module_list) { 696 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 697 698 SBBreakpoint sb_bp; 699 TargetSP target_sp(GetSP()); 700 if (target_sp && line != 0) { 701 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 702 703 const LazyBool check_inlines = eLazyBoolCalculate; 704 const LazyBool skip_prologue = eLazyBoolCalculate; 705 const bool internal = false; 706 const bool hardware = false; 707 const LazyBool move_to_nearest_code = eLazyBoolCalculate; 708 const FileSpecList *module_list = nullptr; 709 if (sb_module_list.GetSize() > 0) { 710 module_list = sb_module_list.get(); 711 } 712 sb_bp = target_sp->CreateBreakpoint( 713 module_list, *sb_file_spec, line, offset, check_inlines, skip_prologue, 714 internal, hardware, move_to_nearest_code); 715 } 716 717 if (log) { 718 SBStream sstr; 719 sb_bp.GetDescription(sstr); 720 char path[PATH_MAX]; 721 sb_file_spec->GetPath(path, sizeof(path)); 722 log->Printf("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => " 723 "SBBreakpoint(%p): %s", 724 static_cast<void *>(target_sp.get()), path, line, 725 static_cast<void *>(sb_bp.GetSP().get()), sstr.GetData()); 726 } 727 728 return sb_bp; 729 } 730 731 SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, 732 const char *module_name) { 733 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 734 735 SBBreakpoint sb_bp; 736 TargetSP target_sp(GetSP()); 737 if (target_sp.get()) { 738 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 739 740 const bool internal = false; 741 const bool hardware = false; 742 const LazyBool skip_prologue = eLazyBoolCalculate; 743 const lldb::addr_t offset = 0; 744 if (module_name && module_name[0]) { 745 FileSpecList module_spec_list; 746 module_spec_list.Append(FileSpec(module_name, false)); 747 sb_bp = target_sp->CreateBreakpoint( 748 &module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, 749 eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); 750 } else { 751 sb_bp = target_sp->CreateBreakpoint( 752 NULL, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown, 753 offset, skip_prologue, internal, hardware); 754 } 755 } 756 757 if (log) 758 log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", " 759 "module=\"%s\") => SBBreakpoint(%p)", 760 static_cast<void *>(target_sp.get()), symbol_name, module_name, 761 static_cast<void *>(sb_bp.GetSP().get())); 762 763 return sb_bp; 764 } 765 766 lldb::SBBreakpoint 767 SBTarget::BreakpointCreateByName(const char *symbol_name, 768 const SBFileSpecList &module_list, 769 const SBFileSpecList &comp_unit_list) { 770 uint32_t name_type_mask = eFunctionNameTypeAuto; 771 return BreakpointCreateByName(symbol_name, name_type_mask, 772 eLanguageTypeUnknown, module_list, 773 comp_unit_list); 774 } 775 776 lldb::SBBreakpoint SBTarget::BreakpointCreateByName( 777 const char *symbol_name, uint32_t name_type_mask, 778 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { 779 return BreakpointCreateByName(symbol_name, name_type_mask, 780 eLanguageTypeUnknown, module_list, 781 comp_unit_list); 782 } 783 784 lldb::SBBreakpoint SBTarget::BreakpointCreateByName( 785 const char *symbol_name, uint32_t name_type_mask, 786 LanguageType symbol_language, const SBFileSpecList &module_list, 787 const SBFileSpecList &comp_unit_list) { 788 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 789 790 SBBreakpoint sb_bp; 791 TargetSP target_sp(GetSP()); 792 if (target_sp && symbol_name && symbol_name[0]) { 793 const bool internal = false; 794 const bool hardware = false; 795 const LazyBool skip_prologue = eLazyBoolCalculate; 796 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 797 sb_bp = target_sp->CreateBreakpoint( 798 module_list.get(), comp_unit_list.get(), symbol_name, name_type_mask, 799 symbol_language, 0, skip_prologue, internal, hardware); 800 } 801 802 if (log) 803 log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", " 804 "name_type: %d) => SBBreakpoint(%p)", 805 static_cast<void *>(target_sp.get()), symbol_name, 806 name_type_mask, static_cast<void *>(sb_bp.GetSP().get())); 807 808 return sb_bp; 809 } 810 811 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( 812 const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, 813 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { 814 return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, 815 eLanguageTypeUnknown, module_list, 816 comp_unit_list); 817 } 818 819 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( 820 const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, 821 LanguageType symbol_language, const SBFileSpecList &module_list, 822 const SBFileSpecList &comp_unit_list) { 823 return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, 824 eLanguageTypeUnknown, 0, module_list, 825 comp_unit_list); 826 } 827 828 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( 829 const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, 830 LanguageType symbol_language, lldb::addr_t offset, 831 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { 832 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 833 834 SBBreakpoint sb_bp; 835 TargetSP target_sp(GetSP()); 836 if (target_sp && num_names > 0) { 837 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 838 const bool internal = false; 839 const bool hardware = false; 840 const LazyBool skip_prologue = eLazyBoolCalculate; 841 sb_bp = target_sp->CreateBreakpoint( 842 module_list.get(), comp_unit_list.get(), symbol_names, num_names, 843 name_type_mask, symbol_language, offset, skip_prologue, internal, 844 hardware); 845 } 846 847 if (log) { 848 log->Printf("SBTarget(%p)::BreakpointCreateByName (symbols={", 849 static_cast<void *>(target_sp.get())); 850 for (uint32_t i = 0; i < num_names; i++) { 851 char sep; 852 if (i < num_names - 1) 853 sep = ','; 854 else 855 sep = '}'; 856 if (symbol_names[i] != NULL) 857 log->Printf("\"%s\"%c ", symbol_names[i], sep); 858 else 859 log->Printf("\"<NULL>\"%c ", sep); 860 } 861 log->Printf("name_type: %d) => SBBreakpoint(%p)", name_type_mask, 862 static_cast<void *>(sb_bp.GetSP().get())); 863 } 864 865 return sb_bp; 866 } 867 868 SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, 869 const char *module_name) { 870 SBFileSpecList module_spec_list; 871 SBFileSpecList comp_unit_list; 872 if (module_name && module_name[0]) { 873 module_spec_list.Append(FileSpec(module_name, false)); 874 } 875 return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, 876 module_spec_list, comp_unit_list); 877 } 878 879 lldb::SBBreakpoint 880 SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, 881 const SBFileSpecList &module_list, 882 const SBFileSpecList &comp_unit_list) { 883 return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, 884 module_list, comp_unit_list); 885 } 886 887 lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( 888 const char *symbol_name_regex, LanguageType symbol_language, 889 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { 890 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 891 892 SBBreakpoint sb_bp; 893 TargetSP target_sp(GetSP()); 894 if (target_sp && symbol_name_regex && symbol_name_regex[0]) { 895 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 896 RegularExpression regexp((llvm::StringRef(symbol_name_regex))); 897 const bool internal = false; 898 const bool hardware = false; 899 const LazyBool skip_prologue = eLazyBoolCalculate; 900 901 sb_bp = target_sp->CreateFuncRegexBreakpoint( 902 module_list.get(), comp_unit_list.get(), regexp, symbol_language, 903 skip_prologue, internal, hardware); 904 } 905 906 if (log) 907 log->Printf("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") " 908 "=> SBBreakpoint(%p)", 909 static_cast<void *>(target_sp.get()), symbol_name_regex, 910 static_cast<void *>(sb_bp.GetSP().get())); 911 912 return sb_bp; 913 } 914 915 SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { 916 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 917 918 SBBreakpoint sb_bp; 919 TargetSP target_sp(GetSP()); 920 if (target_sp) { 921 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 922 const bool hardware = false; 923 sb_bp = target_sp->CreateBreakpoint(address, false, hardware); 924 } 925 926 if (log) 927 log->Printf("SBTarget(%p)::BreakpointCreateByAddress (address=%" PRIu64 928 ") => SBBreakpoint(%p)", 929 static_cast<void *>(target_sp.get()), 930 static_cast<uint64_t>(address), 931 static_cast<void *>(sb_bp.GetSP().get())); 932 933 return sb_bp; 934 } 935 936 SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { 937 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 938 939 SBBreakpoint sb_bp; 940 TargetSP target_sp(GetSP()); 941 if (!sb_address.IsValid()) { 942 if (log) 943 log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress called with " 944 "invalid address", 945 static_cast<void *>(target_sp.get())); 946 return sb_bp; 947 } 948 949 if (target_sp) { 950 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 951 const bool hardware = false; 952 sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware); 953 } 954 955 if (log) { 956 SBStream s; 957 sb_address.GetDescription(s); 958 log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress (address=%s) => " 959 "SBBreakpoint(%p)", 960 static_cast<void *>(target_sp.get()), s.GetData(), 961 static_cast<void *>(sb_bp.GetSP().get())); 962 } 963 964 return sb_bp; 965 } 966 967 lldb::SBBreakpoint 968 SBTarget::BreakpointCreateBySourceRegex(const char *source_regex, 969 const lldb::SBFileSpec &source_file, 970 const char *module_name) { 971 SBFileSpecList module_spec_list; 972 973 if (module_name && module_name[0]) { 974 module_spec_list.Append(FileSpec(module_name, false)); 975 } 976 977 SBFileSpecList source_file_list; 978 if (source_file.IsValid()) { 979 source_file_list.Append(source_file); 980 } 981 982 return BreakpointCreateBySourceRegex(source_regex, module_spec_list, 983 source_file_list); 984 } 985 986 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( 987 const char *source_regex, const SBFileSpecList &module_list, 988 const lldb::SBFileSpecList &source_file_list) { 989 return BreakpointCreateBySourceRegex(source_regex, module_list, 990 source_file_list, SBStringList()); 991 } 992 993 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( 994 const char *source_regex, const SBFileSpecList &module_list, 995 const lldb::SBFileSpecList &source_file_list, 996 const SBStringList &func_names) { 997 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 998 999 SBBreakpoint sb_bp; 1000 TargetSP target_sp(GetSP()); 1001 if (target_sp && source_regex && source_regex[0]) { 1002 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1003 const bool hardware = false; 1004 const LazyBool move_to_nearest_code = eLazyBoolCalculate; 1005 RegularExpression regexp((llvm::StringRef(source_regex))); 1006 std::unordered_set<std::string> func_names_set; 1007 for (size_t i = 0; i < func_names.GetSize(); i++) { 1008 func_names_set.insert(func_names.GetStringAtIndex(i)); 1009 } 1010 1011 sb_bp = target_sp->CreateSourceRegexBreakpoint( 1012 module_list.get(), source_file_list.get(), func_names_set, regexp, 1013 false, hardware, move_to_nearest_code); 1014 } 1015 1016 if (log) 1017 log->Printf("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") " 1018 "=> SBBreakpoint(%p)", 1019 static_cast<void *>(target_sp.get()), source_regex, 1020 static_cast<void *>(sb_bp.GetSP().get())); 1021 1022 return sb_bp; 1023 } 1024 1025 lldb::SBBreakpoint 1026 SBTarget::BreakpointCreateForException(lldb::LanguageType language, 1027 bool catch_bp, bool throw_bp) { 1028 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1029 1030 SBBreakpoint sb_bp; 1031 TargetSP target_sp(GetSP()); 1032 if (target_sp) { 1033 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1034 const bool hardware = false; 1035 sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp, 1036 hardware); 1037 } 1038 1039 if (log) 1040 log->Printf("SBTarget(%p)::BreakpointCreateByRegex (Language: %s, catch: " 1041 "%s throw: %s) => SBBreakpoint(%p)", 1042 static_cast<void *>(target_sp.get()), 1043 Language::GetNameForLanguageType(language), 1044 catch_bp ? "on" : "off", throw_bp ? "on" : "off", 1045 static_cast<void *>(sb_bp.GetSP().get())); 1046 1047 return sb_bp; 1048 } 1049 1050 uint32_t SBTarget::GetNumBreakpoints() const { 1051 TargetSP target_sp(GetSP()); 1052 if (target_sp) { 1053 // The breakpoint list is thread safe, no need to lock 1054 return target_sp->GetBreakpointList().GetSize(); 1055 } 1056 return 0; 1057 } 1058 1059 SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { 1060 SBBreakpoint sb_breakpoint; 1061 TargetSP target_sp(GetSP()); 1062 if (target_sp) { 1063 // The breakpoint list is thread safe, no need to lock 1064 sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); 1065 } 1066 return sb_breakpoint; 1067 } 1068 1069 bool SBTarget::BreakpointDelete(break_id_t bp_id) { 1070 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1071 1072 bool result = false; 1073 TargetSP target_sp(GetSP()); 1074 if (target_sp) { 1075 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1076 result = target_sp->RemoveBreakpointByID(bp_id); 1077 } 1078 1079 if (log) 1080 log->Printf("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i", 1081 static_cast<void *>(target_sp.get()), 1082 static_cast<uint32_t>(bp_id), result); 1083 1084 return result; 1085 } 1086 1087 SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { 1088 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1089 1090 SBBreakpoint sb_breakpoint; 1091 TargetSP target_sp(GetSP()); 1092 if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) { 1093 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1094 sb_breakpoint = target_sp->GetBreakpointByID(bp_id); 1095 } 1096 1097 if (log) 1098 log->Printf( 1099 "SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)", 1100 static_cast<void *>(target_sp.get()), static_cast<uint32_t>(bp_id), 1101 static_cast<void *>(sb_breakpoint.GetSP().get())); 1102 1103 return sb_breakpoint; 1104 } 1105 1106 bool SBTarget::FindBreakpointsByName(const char *name, 1107 SBBreakpointList &bkpts) { 1108 TargetSP target_sp(GetSP()); 1109 if (target_sp) { 1110 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1111 BreakpointList bkpt_list(false); 1112 bool is_valid = 1113 target_sp->GetBreakpointList().FindBreakpointsByName(name, bkpt_list); 1114 if (!is_valid) 1115 return false; 1116 for (BreakpointSP bkpt_sp : bkpt_list.Breakpoints()) { 1117 bkpts.AppendByID(bkpt_sp->GetID()); 1118 } 1119 } 1120 return true; 1121 } 1122 1123 void SBTarget::GetBreakpointNames(SBStringList &names) 1124 { 1125 names.Clear(); 1126 1127 TargetSP target_sp(GetSP()); 1128 if (target_sp) { 1129 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1130 1131 std::vector<std::string> name_vec; 1132 target_sp->GetBreakpointNames(name_vec); 1133 for (auto name : name_vec) 1134 names.AppendString(name.c_str()); 1135 } 1136 } 1137 1138 void SBTarget::DeleteBreakpointName(const char *name) 1139 { 1140 TargetSP target_sp(GetSP()); 1141 if (target_sp) { 1142 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1143 target_sp->DeleteBreakpointName(ConstString(name)); 1144 } 1145 } 1146 1147 bool SBTarget::EnableAllBreakpoints() { 1148 TargetSP target_sp(GetSP()); 1149 if (target_sp) { 1150 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1151 target_sp->EnableAllowedBreakpoints(); 1152 return true; 1153 } 1154 return false; 1155 } 1156 1157 bool SBTarget::DisableAllBreakpoints() { 1158 TargetSP target_sp(GetSP()); 1159 if (target_sp) { 1160 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1161 target_sp->DisableAllowedBreakpoints(); 1162 return true; 1163 } 1164 return false; 1165 } 1166 1167 bool SBTarget::DeleteAllBreakpoints() { 1168 TargetSP target_sp(GetSP()); 1169 if (target_sp) { 1170 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1171 target_sp->RemoveAllowedBreakpoints(); 1172 return true; 1173 } 1174 return false; 1175 } 1176 1177 lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, 1178 SBBreakpointList &new_bps) { 1179 SBStringList empty_name_list; 1180 return BreakpointsCreateFromFile(source_file, empty_name_list, new_bps); 1181 } 1182 1183 lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, 1184 SBStringList &matching_names, 1185 SBBreakpointList &new_bps) { 1186 SBError sberr; 1187 TargetSP target_sp(GetSP()); 1188 if (!target_sp) { 1189 sberr.SetErrorString( 1190 "BreakpointCreateFromFile called with invalid target."); 1191 return sberr; 1192 } 1193 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1194 1195 BreakpointIDList bp_ids; 1196 1197 std::vector<std::string> name_vector; 1198 size_t num_names = matching_names.GetSize(); 1199 for (size_t i = 0; i < num_names; i++) 1200 name_vector.push_back(matching_names.GetStringAtIndex(i)); 1201 1202 sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(), 1203 name_vector, bp_ids); 1204 if (sberr.Fail()) 1205 return sberr; 1206 1207 size_t num_bkpts = bp_ids.GetSize(); 1208 for (size_t i = 0; i < num_bkpts; i++) { 1209 BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i); 1210 new_bps.AppendByID(bp_id.GetBreakpointID()); 1211 } 1212 return sberr; 1213 } 1214 1215 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) { 1216 SBError sberr; 1217 TargetSP target_sp(GetSP()); 1218 if (!target_sp) { 1219 sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); 1220 return sberr; 1221 } 1222 SBBreakpointList bkpt_list(*this); 1223 return BreakpointsWriteToFile(dest_file, bkpt_list); 1224 } 1225 1226 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file, 1227 SBBreakpointList &bkpt_list, 1228 bool append) { 1229 SBError sberr; 1230 TargetSP target_sp(GetSP()); 1231 if (!target_sp) { 1232 sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); 1233 return sberr; 1234 } 1235 1236 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1237 BreakpointIDList bp_id_list; 1238 bkpt_list.CopyToBreakpointIDList(bp_id_list); 1239 sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(), 1240 bp_id_list, append); 1241 return sberr; 1242 } 1243 1244 uint32_t SBTarget::GetNumWatchpoints() const { 1245 TargetSP target_sp(GetSP()); 1246 if (target_sp) { 1247 // The watchpoint list is thread safe, no need to lock 1248 return target_sp->GetWatchpointList().GetSize(); 1249 } 1250 return 0; 1251 } 1252 1253 SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const { 1254 SBWatchpoint sb_watchpoint; 1255 TargetSP target_sp(GetSP()); 1256 if (target_sp) { 1257 // The watchpoint list is thread safe, no need to lock 1258 sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx)); 1259 } 1260 return sb_watchpoint; 1261 } 1262 1263 bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { 1264 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1265 1266 bool result = false; 1267 TargetSP target_sp(GetSP()); 1268 if (target_sp) { 1269 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1270 std::unique_lock<std::recursive_mutex> lock; 1271 target_sp->GetWatchpointList().GetListMutex(lock); 1272 result = target_sp->RemoveWatchpointByID(wp_id); 1273 } 1274 1275 if (log) 1276 log->Printf("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i", 1277 static_cast<void *>(target_sp.get()), 1278 static_cast<uint32_t>(wp_id), result); 1279 1280 return result; 1281 } 1282 1283 SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { 1284 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1285 1286 SBWatchpoint sb_watchpoint; 1287 lldb::WatchpointSP watchpoint_sp; 1288 TargetSP target_sp(GetSP()); 1289 if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) { 1290 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1291 std::unique_lock<std::recursive_mutex> lock; 1292 target_sp->GetWatchpointList().GetListMutex(lock); 1293 watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id); 1294 sb_watchpoint.SetSP(watchpoint_sp); 1295 } 1296 1297 if (log) 1298 log->Printf( 1299 "SBTarget(%p)::FindWatchpointByID (bp_id=%d) => SBWatchpoint(%p)", 1300 static_cast<void *>(target_sp.get()), static_cast<uint32_t>(wp_id), 1301 static_cast<void *>(watchpoint_sp.get())); 1302 1303 return sb_watchpoint; 1304 } 1305 1306 lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, 1307 bool read, bool write, 1308 SBError &error) { 1309 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1310 1311 SBWatchpoint sb_watchpoint; 1312 lldb::WatchpointSP watchpoint_sp; 1313 TargetSP target_sp(GetSP()); 1314 if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS && 1315 size > 0) { 1316 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1317 uint32_t watch_type = 0; 1318 if (read) 1319 watch_type |= LLDB_WATCH_TYPE_READ; 1320 if (write) 1321 watch_type |= LLDB_WATCH_TYPE_WRITE; 1322 if (watch_type == 0) { 1323 error.SetErrorString( 1324 "Can't create a watchpoint that is neither read nor write."); 1325 return sb_watchpoint; 1326 } 1327 1328 // Target::CreateWatchpoint() is thread safe. 1329 Status cw_error; 1330 // This API doesn't take in a type, so we can't figure out what it is. 1331 CompilerType *type = NULL; 1332 watchpoint_sp = 1333 target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error); 1334 error.SetError(cw_error); 1335 sb_watchpoint.SetSP(watchpoint_sp); 1336 } 1337 1338 if (log) 1339 log->Printf("SBTarget(%p)::WatchAddress (addr=0x%" PRIx64 1340 ", 0x%u) => SBWatchpoint(%p)", 1341 static_cast<void *>(target_sp.get()), addr, 1342 static_cast<uint32_t>(size), 1343 static_cast<void *>(watchpoint_sp.get())); 1344 1345 return sb_watchpoint; 1346 } 1347 1348 bool SBTarget::EnableAllWatchpoints() { 1349 TargetSP target_sp(GetSP()); 1350 if (target_sp) { 1351 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1352 std::unique_lock<std::recursive_mutex> lock; 1353 target_sp->GetWatchpointList().GetListMutex(lock); 1354 target_sp->EnableAllWatchpoints(); 1355 return true; 1356 } 1357 return false; 1358 } 1359 1360 bool SBTarget::DisableAllWatchpoints() { 1361 TargetSP target_sp(GetSP()); 1362 if (target_sp) { 1363 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1364 std::unique_lock<std::recursive_mutex> lock; 1365 target_sp->GetWatchpointList().GetListMutex(lock); 1366 target_sp->DisableAllWatchpoints(); 1367 return true; 1368 } 1369 return false; 1370 } 1371 1372 SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr, 1373 SBType type) { 1374 SBValue sb_value; 1375 lldb::ValueObjectSP new_value_sp; 1376 if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) { 1377 lldb::addr_t load_addr(addr.GetLoadAddress(*this)); 1378 ExecutionContext exe_ctx( 1379 ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); 1380 CompilerType ast_type(type.GetSP()->GetCompilerType(true)); 1381 new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr, 1382 exe_ctx, ast_type); 1383 } 1384 sb_value.SetSP(new_value_sp); 1385 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1386 if (log) { 1387 if (new_value_sp) 1388 log->Printf("SBTarget(%p)::CreateValueFromAddress => \"%s\"", 1389 static_cast<void *>(m_opaque_sp.get()), 1390 new_value_sp->GetName().AsCString()); 1391 else 1392 log->Printf("SBTarget(%p)::CreateValueFromAddress => NULL", 1393 static_cast<void *>(m_opaque_sp.get())); 1394 } 1395 return sb_value; 1396 } 1397 1398 lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data, 1399 lldb::SBType type) { 1400 SBValue sb_value; 1401 lldb::ValueObjectSP new_value_sp; 1402 if (IsValid() && name && *name && data.IsValid() && type.IsValid()) { 1403 DataExtractorSP extractor(*data); 1404 ExecutionContext exe_ctx( 1405 ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); 1406 CompilerType ast_type(type.GetSP()->GetCompilerType(true)); 1407 new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor, 1408 exe_ctx, ast_type); 1409 } 1410 sb_value.SetSP(new_value_sp); 1411 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1412 if (log) { 1413 if (new_value_sp) 1414 log->Printf("SBTarget(%p)::CreateValueFromData => \"%s\"", 1415 static_cast<void *>(m_opaque_sp.get()), 1416 new_value_sp->GetName().AsCString()); 1417 else 1418 log->Printf("SBTarget(%p)::CreateValueFromData => NULL", 1419 static_cast<void *>(m_opaque_sp.get())); 1420 } 1421 return sb_value; 1422 } 1423 1424 lldb::SBValue SBTarget::CreateValueFromExpression(const char *name, 1425 const char *expr) { 1426 SBValue sb_value; 1427 lldb::ValueObjectSP new_value_sp; 1428 if (IsValid() && name && *name && expr && *expr) { 1429 ExecutionContext exe_ctx( 1430 ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); 1431 new_value_sp = 1432 ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx); 1433 } 1434 sb_value.SetSP(new_value_sp); 1435 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1436 if (log) { 1437 if (new_value_sp) 1438 log->Printf("SBTarget(%p)::CreateValueFromExpression => \"%s\"", 1439 static_cast<void *>(m_opaque_sp.get()), 1440 new_value_sp->GetName().AsCString()); 1441 else 1442 log->Printf("SBTarget(%p)::CreateValueFromExpression => NULL", 1443 static_cast<void *>(m_opaque_sp.get())); 1444 } 1445 return sb_value; 1446 } 1447 1448 bool SBTarget::DeleteAllWatchpoints() { 1449 TargetSP target_sp(GetSP()); 1450 if (target_sp) { 1451 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1452 std::unique_lock<std::recursive_mutex> lock; 1453 target_sp->GetWatchpointList().GetListMutex(lock); 1454 target_sp->RemoveAllWatchpoints(); 1455 return true; 1456 } 1457 return false; 1458 } 1459 1460 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, 1461 const char *uuid_cstr) { 1462 return AddModule(path, triple, uuid_cstr, NULL); 1463 } 1464 1465 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, 1466 const char *uuid_cstr, const char *symfile) { 1467 lldb::SBModule sb_module; 1468 TargetSP target_sp(GetSP()); 1469 if (target_sp) { 1470 ModuleSpec module_spec; 1471 if (path) 1472 module_spec.GetFileSpec().SetFile(path, false, FileSpec::Style::native); 1473 1474 if (uuid_cstr) 1475 module_spec.GetUUID().SetFromStringRef(uuid_cstr); 1476 1477 if (triple) 1478 module_spec.GetArchitecture() = Platform::GetAugmentedArchSpec( 1479 target_sp->GetPlatform().get(), triple); 1480 else 1481 module_spec.GetArchitecture() = target_sp->GetArchitecture(); 1482 1483 if (symfile) 1484 module_spec.GetSymbolFileSpec().SetFile(symfile, false, 1485 FileSpec::Style::native); 1486 1487 sb_module.SetSP(target_sp->GetSharedModule(module_spec)); 1488 } 1489 return sb_module; 1490 } 1491 1492 lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { 1493 lldb::SBModule sb_module; 1494 TargetSP target_sp(GetSP()); 1495 if (target_sp) 1496 sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_ap)); 1497 return sb_module; 1498 } 1499 1500 bool SBTarget::AddModule(lldb::SBModule &module) { 1501 TargetSP target_sp(GetSP()); 1502 if (target_sp) { 1503 target_sp->GetImages().AppendIfNeeded(module.GetSP()); 1504 return true; 1505 } 1506 return false; 1507 } 1508 1509 uint32_t SBTarget::GetNumModules() const { 1510 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1511 1512 uint32_t num = 0; 1513 TargetSP target_sp(GetSP()); 1514 if (target_sp) { 1515 // The module list is thread safe, no need to lock 1516 num = target_sp->GetImages().GetSize(); 1517 } 1518 1519 if (log) 1520 log->Printf("SBTarget(%p)::GetNumModules () => %d", 1521 static_cast<void *>(target_sp.get()), num); 1522 1523 return num; 1524 } 1525 1526 void SBTarget::Clear() { 1527 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1528 1529 if (log) 1530 log->Printf("SBTarget(%p)::Clear ()", 1531 static_cast<void *>(m_opaque_sp.get())); 1532 1533 m_opaque_sp.reset(); 1534 } 1535 1536 SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) { 1537 SBModule sb_module; 1538 TargetSP target_sp(GetSP()); 1539 if (target_sp && sb_file_spec.IsValid()) { 1540 ModuleSpec module_spec(*sb_file_spec); 1541 // The module list is thread safe, no need to lock 1542 sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec)); 1543 } 1544 return sb_module; 1545 } 1546 1547 SBSymbolContextList 1548 SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) { 1549 SBSymbolContextList sb_sc_list; 1550 const TargetSP target_sp(GetSP()); 1551 if (target_sp && sb_file_spec.IsValid()) { 1552 const bool append = true; 1553 target_sp->GetImages().FindCompileUnits(*sb_file_spec, 1554 append, *sb_sc_list); 1555 } 1556 return sb_sc_list; 1557 } 1558 1559 lldb::ByteOrder SBTarget::GetByteOrder() { 1560 TargetSP target_sp(GetSP()); 1561 if (target_sp) 1562 return target_sp->GetArchitecture().GetByteOrder(); 1563 return eByteOrderInvalid; 1564 } 1565 1566 const char *SBTarget::GetTriple() { 1567 TargetSP target_sp(GetSP()); 1568 if (target_sp) { 1569 std::string triple(target_sp->GetArchitecture().GetTriple().str()); 1570 // Unique the string so we don't run into ownership issues since the const 1571 // strings put the string into the string pool once and the strings never 1572 // comes out 1573 ConstString const_triple(triple.c_str()); 1574 return const_triple.GetCString(); 1575 } 1576 return NULL; 1577 } 1578 1579 uint32_t SBTarget::GetDataByteSize() { 1580 TargetSP target_sp(GetSP()); 1581 if (target_sp) { 1582 return target_sp->GetArchitecture().GetDataByteSize(); 1583 } 1584 return 0; 1585 } 1586 1587 uint32_t SBTarget::GetCodeByteSize() { 1588 TargetSP target_sp(GetSP()); 1589 if (target_sp) { 1590 return target_sp->GetArchitecture().GetCodeByteSize(); 1591 } 1592 return 0; 1593 } 1594 1595 uint32_t SBTarget::GetAddressByteSize() { 1596 TargetSP target_sp(GetSP()); 1597 if (target_sp) 1598 return target_sp->GetArchitecture().GetAddressByteSize(); 1599 return sizeof(void *); 1600 } 1601 1602 SBModule SBTarget::GetModuleAtIndex(uint32_t idx) { 1603 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1604 1605 SBModule sb_module; 1606 ModuleSP module_sp; 1607 TargetSP target_sp(GetSP()); 1608 if (target_sp) { 1609 // The module list is thread safe, no need to lock 1610 module_sp = target_sp->GetImages().GetModuleAtIndex(idx); 1611 sb_module.SetSP(module_sp); 1612 } 1613 1614 if (log) 1615 log->Printf("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)", 1616 static_cast<void *>(target_sp.get()), idx, 1617 static_cast<void *>(module_sp.get())); 1618 1619 return sb_module; 1620 } 1621 1622 bool SBTarget::RemoveModule(lldb::SBModule module) { 1623 TargetSP target_sp(GetSP()); 1624 if (target_sp) 1625 return target_sp->GetImages().Remove(module.GetSP()); 1626 return false; 1627 } 1628 1629 SBBroadcaster SBTarget::GetBroadcaster() const { 1630 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1631 1632 TargetSP target_sp(GetSP()); 1633 SBBroadcaster broadcaster(target_sp.get(), false); 1634 1635 if (log) 1636 log->Printf("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)", 1637 static_cast<void *>(target_sp.get()), 1638 static_cast<void *>(broadcaster.get())); 1639 1640 return broadcaster; 1641 } 1642 1643 bool SBTarget::GetDescription(SBStream &description, 1644 lldb::DescriptionLevel description_level) { 1645 Stream &strm = description.ref(); 1646 1647 TargetSP target_sp(GetSP()); 1648 if (target_sp) { 1649 target_sp->Dump(&strm, description_level); 1650 } else 1651 strm.PutCString("No value"); 1652 1653 return true; 1654 } 1655 1656 lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name, 1657 uint32_t name_type_mask) { 1658 lldb::SBSymbolContextList sb_sc_list; 1659 if (name && name[0]) { 1660 TargetSP target_sp(GetSP()); 1661 if (target_sp) { 1662 const bool symbols_ok = true; 1663 const bool inlines_ok = true; 1664 const bool append = true; 1665 target_sp->GetImages().FindFunctions(ConstString(name), name_type_mask, 1666 symbols_ok, inlines_ok, append, 1667 *sb_sc_list); 1668 } 1669 } 1670 return sb_sc_list; 1671 } 1672 1673 lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name, 1674 uint32_t max_matches, 1675 MatchType matchtype) { 1676 lldb::SBSymbolContextList sb_sc_list; 1677 if (name && name[0]) { 1678 llvm::StringRef name_ref(name); 1679 TargetSP target_sp(GetSP()); 1680 if (target_sp) { 1681 std::string regexstr; 1682 switch (matchtype) { 1683 case eMatchTypeRegex: 1684 target_sp->GetImages().FindFunctions(RegularExpression(name_ref), true, 1685 true, true, *sb_sc_list); 1686 break; 1687 case eMatchTypeStartsWith: 1688 regexstr = llvm::Regex::escape(name) + ".*"; 1689 target_sp->GetImages().FindFunctions(RegularExpression(regexstr), true, 1690 true, true, *sb_sc_list); 1691 break; 1692 default: 1693 target_sp->GetImages().FindFunctions(ConstString(name), 1694 eFunctionNameTypeAny, true, true, 1695 true, *sb_sc_list); 1696 break; 1697 } 1698 } 1699 } 1700 return sb_sc_list; 1701 } 1702 1703 lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { 1704 TargetSP target_sp(GetSP()); 1705 if (typename_cstr && typename_cstr[0] && target_sp) { 1706 ConstString const_typename(typename_cstr); 1707 SymbolContext sc; 1708 const bool exact_match = false; 1709 1710 const ModuleList &module_list = target_sp->GetImages(); 1711 size_t count = module_list.GetSize(); 1712 for (size_t idx = 0; idx < count; idx++) { 1713 ModuleSP module_sp(module_list.GetModuleAtIndex(idx)); 1714 if (module_sp) { 1715 TypeSP type_sp( 1716 module_sp->FindFirstType(sc, const_typename, exact_match)); 1717 if (type_sp) 1718 return SBType(type_sp); 1719 } 1720 } 1721 1722 // Didn't find the type in the symbols; try the Objective-C runtime if one 1723 // is installed 1724 1725 ProcessSP process_sp(target_sp->GetProcessSP()); 1726 1727 if (process_sp) { 1728 ObjCLanguageRuntime *objc_language_runtime = 1729 process_sp->GetObjCLanguageRuntime(); 1730 1731 if (objc_language_runtime) { 1732 DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor(); 1733 1734 if (objc_decl_vendor) { 1735 std::vector<clang::NamedDecl *> decls; 1736 1737 if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) { 1738 if (CompilerType type = ClangASTContext::GetTypeForDecl(decls[0])) { 1739 return SBType(type); 1740 } 1741 } 1742 } 1743 } 1744 } 1745 1746 // No matches, search for basic typename matches 1747 ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); 1748 if (clang_ast) 1749 return SBType(ClangASTContext::GetBasicType(clang_ast->getASTContext(), 1750 const_typename)); 1751 } 1752 return SBType(); 1753 } 1754 1755 SBType SBTarget::GetBasicType(lldb::BasicType type) { 1756 TargetSP target_sp(GetSP()); 1757 if (target_sp) { 1758 ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); 1759 if (clang_ast) 1760 return SBType( 1761 ClangASTContext::GetBasicType(clang_ast->getASTContext(), type)); 1762 } 1763 return SBType(); 1764 } 1765 1766 lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) { 1767 SBTypeList sb_type_list; 1768 TargetSP target_sp(GetSP()); 1769 if (typename_cstr && typename_cstr[0] && target_sp) { 1770 ModuleList &images = target_sp->GetImages(); 1771 ConstString const_typename(typename_cstr); 1772 bool exact_match = false; 1773 SymbolContext sc; 1774 TypeList type_list; 1775 llvm::DenseSet<SymbolFile *> searched_symbol_files; 1776 uint32_t num_matches = 1777 images.FindTypes(sc, const_typename, exact_match, UINT32_MAX, 1778 searched_symbol_files, type_list); 1779 1780 if (num_matches > 0) { 1781 for (size_t idx = 0; idx < num_matches; idx++) { 1782 TypeSP type_sp(type_list.GetTypeAtIndex(idx)); 1783 if (type_sp) 1784 sb_type_list.Append(SBType(type_sp)); 1785 } 1786 } 1787 1788 // Try the Objective-C runtime if one is installed 1789 1790 ProcessSP process_sp(target_sp->GetProcessSP()); 1791 1792 if (process_sp) { 1793 ObjCLanguageRuntime *objc_language_runtime = 1794 process_sp->GetObjCLanguageRuntime(); 1795 1796 if (objc_language_runtime) { 1797 DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor(); 1798 1799 if (objc_decl_vendor) { 1800 std::vector<clang::NamedDecl *> decls; 1801 1802 if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) { 1803 for (clang::NamedDecl *decl : decls) { 1804 if (CompilerType type = ClangASTContext::GetTypeForDecl(decl)) { 1805 sb_type_list.Append(SBType(type)); 1806 } 1807 } 1808 } 1809 } 1810 } 1811 } 1812 1813 if (sb_type_list.GetSize() == 0) { 1814 // No matches, search for basic typename matches 1815 ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); 1816 if (clang_ast) 1817 sb_type_list.Append(SBType(ClangASTContext::GetBasicType( 1818 clang_ast->getASTContext(), const_typename))); 1819 } 1820 } 1821 return sb_type_list; 1822 } 1823 1824 SBValueList SBTarget::FindGlobalVariables(const char *name, 1825 uint32_t max_matches) { 1826 SBValueList sb_value_list; 1827 1828 TargetSP target_sp(GetSP()); 1829 if (name && target_sp) { 1830 VariableList variable_list; 1831 const uint32_t match_count = target_sp->GetImages().FindGlobalVariables( 1832 ConstString(name), max_matches, variable_list); 1833 1834 if (match_count > 0) { 1835 ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); 1836 if (exe_scope == NULL) 1837 exe_scope = target_sp.get(); 1838 for (uint32_t i = 0; i < match_count; ++i) { 1839 lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create( 1840 exe_scope, variable_list.GetVariableAtIndex(i))); 1841 if (valobj_sp) 1842 sb_value_list.Append(SBValue(valobj_sp)); 1843 } 1844 } 1845 } 1846 1847 return sb_value_list; 1848 } 1849 1850 SBValueList SBTarget::FindGlobalVariables(const char *name, 1851 uint32_t max_matches, 1852 MatchType matchtype) { 1853 SBValueList sb_value_list; 1854 1855 TargetSP target_sp(GetSP()); 1856 if (name && target_sp) { 1857 llvm::StringRef name_ref(name); 1858 VariableList variable_list; 1859 1860 std::string regexstr; 1861 uint32_t match_count; 1862 switch (matchtype) { 1863 case eMatchTypeNormal: 1864 match_count = target_sp->GetImages().FindGlobalVariables( 1865 ConstString(name), max_matches, variable_list); 1866 break; 1867 case eMatchTypeRegex: 1868 match_count = target_sp->GetImages().FindGlobalVariables( 1869 RegularExpression(name_ref), max_matches, variable_list); 1870 break; 1871 case eMatchTypeStartsWith: 1872 regexstr = llvm::Regex::escape(name) + ".*"; 1873 match_count = target_sp->GetImages().FindGlobalVariables( 1874 RegularExpression(regexstr), max_matches, variable_list); 1875 break; 1876 } 1877 1878 if (match_count > 0) { 1879 ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); 1880 if (exe_scope == NULL) 1881 exe_scope = target_sp.get(); 1882 for (uint32_t i = 0; i < match_count; ++i) { 1883 lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create( 1884 exe_scope, variable_list.GetVariableAtIndex(i))); 1885 if (valobj_sp) 1886 sb_value_list.Append(SBValue(valobj_sp)); 1887 } 1888 } 1889 } 1890 1891 return sb_value_list; 1892 } 1893 1894 lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) { 1895 SBValueList sb_value_list(FindGlobalVariables(name, 1)); 1896 if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) 1897 return sb_value_list.GetValueAtIndex(0); 1898 return SBValue(); 1899 } 1900 1901 SBSourceManager SBTarget::GetSourceManager() { 1902 SBSourceManager source_manager(*this); 1903 return source_manager; 1904 } 1905 1906 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, 1907 uint32_t count) { 1908 return ReadInstructions(base_addr, count, NULL); 1909 } 1910 1911 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, 1912 uint32_t count, 1913 const char *flavor_string) { 1914 SBInstructionList sb_instructions; 1915 1916 TargetSP target_sp(GetSP()); 1917 if (target_sp) { 1918 Address *addr_ptr = base_addr.get(); 1919 1920 if (addr_ptr) { 1921 DataBufferHeap data( 1922 target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0); 1923 bool prefer_file_cache = false; 1924 lldb_private::Status error; 1925 lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; 1926 const size_t bytes_read = 1927 target_sp->ReadMemory(*addr_ptr, prefer_file_cache, data.GetBytes(), 1928 data.GetByteSize(), error, &load_addr); 1929 const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS; 1930 sb_instructions.SetDisassembler(Disassembler::DisassembleBytes( 1931 target_sp->GetArchitecture(), NULL, flavor_string, *addr_ptr, 1932 data.GetBytes(), bytes_read, count, data_from_file)); 1933 } 1934 } 1935 1936 return sb_instructions; 1937 } 1938 1939 lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr, 1940 const void *buf, 1941 size_t size) { 1942 return GetInstructionsWithFlavor(base_addr, NULL, buf, size); 1943 } 1944 1945 lldb::SBInstructionList 1946 SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr, 1947 const char *flavor_string, const void *buf, 1948 size_t size) { 1949 SBInstructionList sb_instructions; 1950 1951 TargetSP target_sp(GetSP()); 1952 if (target_sp) { 1953 Address addr; 1954 1955 if (base_addr.get()) 1956 addr = *base_addr.get(); 1957 1958 const bool data_from_file = true; 1959 1960 sb_instructions.SetDisassembler(Disassembler::DisassembleBytes( 1961 target_sp->GetArchitecture(), NULL, flavor_string, addr, buf, size, 1962 UINT32_MAX, data_from_file)); 1963 } 1964 1965 return sb_instructions; 1966 } 1967 1968 lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr, 1969 const void *buf, 1970 size_t size) { 1971 return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), NULL, buf, 1972 size); 1973 } 1974 1975 lldb::SBInstructionList 1976 SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr, 1977 const char *flavor_string, const void *buf, 1978 size_t size) { 1979 return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), flavor_string, 1980 buf, size); 1981 } 1982 1983 SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section, 1984 lldb::addr_t section_base_addr) { 1985 SBError sb_error; 1986 TargetSP target_sp(GetSP()); 1987 if (target_sp) { 1988 if (!section.IsValid()) { 1989 sb_error.SetErrorStringWithFormat("invalid section"); 1990 } else { 1991 SectionSP section_sp(section.GetSP()); 1992 if (section_sp) { 1993 if (section_sp->IsThreadSpecific()) { 1994 sb_error.SetErrorString( 1995 "thread specific sections are not yet supported"); 1996 } else { 1997 ProcessSP process_sp(target_sp->GetProcessSP()); 1998 if (target_sp->SetSectionLoadAddress(section_sp, section_base_addr)) { 1999 ModuleSP module_sp(section_sp->GetModule()); 2000 if (module_sp) { 2001 ModuleList module_list; 2002 module_list.Append(module_sp); 2003 target_sp->ModulesDidLoad(module_list); 2004 } 2005 // Flush info in the process (stack frames, etc) 2006 if (process_sp) 2007 process_sp->Flush(); 2008 } 2009 } 2010 } 2011 } 2012 } else { 2013 sb_error.SetErrorString("invalid target"); 2014 } 2015 return sb_error; 2016 } 2017 2018 SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) { 2019 SBError sb_error; 2020 2021 TargetSP target_sp(GetSP()); 2022 if (target_sp) { 2023 if (!section.IsValid()) { 2024 sb_error.SetErrorStringWithFormat("invalid section"); 2025 } else { 2026 SectionSP section_sp(section.GetSP()); 2027 if (section_sp) { 2028 ProcessSP process_sp(target_sp->GetProcessSP()); 2029 if (target_sp->SetSectionUnloaded(section_sp)) { 2030 ModuleSP module_sp(section_sp->GetModule()); 2031 if (module_sp) { 2032 ModuleList module_list; 2033 module_list.Append(module_sp); 2034 target_sp->ModulesDidUnload(module_list, false); 2035 } 2036 // Flush info in the process (stack frames, etc) 2037 if (process_sp) 2038 process_sp->Flush(); 2039 } 2040 } else { 2041 sb_error.SetErrorStringWithFormat("invalid section"); 2042 } 2043 } 2044 } else { 2045 sb_error.SetErrorStringWithFormat("invalid target"); 2046 } 2047 return sb_error; 2048 } 2049 2050 SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module, 2051 int64_t slide_offset) { 2052 SBError sb_error; 2053 2054 TargetSP target_sp(GetSP()); 2055 if (target_sp) { 2056 ModuleSP module_sp(module.GetSP()); 2057 if (module_sp) { 2058 bool changed = false; 2059 if (module_sp->SetLoadAddress(*target_sp, slide_offset, true, changed)) { 2060 // The load was successful, make sure that at least some sections 2061 // changed before we notify that our module was loaded. 2062 if (changed) { 2063 ModuleList module_list; 2064 module_list.Append(module_sp); 2065 target_sp->ModulesDidLoad(module_list); 2066 // Flush info in the process (stack frames, etc) 2067 ProcessSP process_sp(target_sp->GetProcessSP()); 2068 if (process_sp) 2069 process_sp->Flush(); 2070 } 2071 } 2072 } else { 2073 sb_error.SetErrorStringWithFormat("invalid module"); 2074 } 2075 2076 } else { 2077 sb_error.SetErrorStringWithFormat("invalid target"); 2078 } 2079 return sb_error; 2080 } 2081 2082 SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) { 2083 SBError sb_error; 2084 2085 char path[PATH_MAX]; 2086 TargetSP target_sp(GetSP()); 2087 if (target_sp) { 2088 ModuleSP module_sp(module.GetSP()); 2089 if (module_sp) { 2090 ObjectFile *objfile = module_sp->GetObjectFile(); 2091 if (objfile) { 2092 SectionList *section_list = objfile->GetSectionList(); 2093 if (section_list) { 2094 ProcessSP process_sp(target_sp->GetProcessSP()); 2095 2096 bool changed = false; 2097 const size_t num_sections = section_list->GetSize(); 2098 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) { 2099 SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx)); 2100 if (section_sp) 2101 changed |= target_sp->SetSectionUnloaded(section_sp); 2102 } 2103 if (changed) { 2104 ModuleList module_list; 2105 module_list.Append(module_sp); 2106 target_sp->ModulesDidUnload(module_list, false); 2107 // Flush info in the process (stack frames, etc) 2108 ProcessSP process_sp(target_sp->GetProcessSP()); 2109 if (process_sp) 2110 process_sp->Flush(); 2111 } 2112 } else { 2113 module_sp->GetFileSpec().GetPath(path, sizeof(path)); 2114 sb_error.SetErrorStringWithFormat("no sections in object file '%s'", 2115 path); 2116 } 2117 } else { 2118 module_sp->GetFileSpec().GetPath(path, sizeof(path)); 2119 sb_error.SetErrorStringWithFormat("no object file for module '%s'", 2120 path); 2121 } 2122 } else { 2123 sb_error.SetErrorStringWithFormat("invalid module"); 2124 } 2125 } else { 2126 sb_error.SetErrorStringWithFormat("invalid target"); 2127 } 2128 return sb_error; 2129 } 2130 2131 lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name, 2132 lldb::SymbolType symbol_type) { 2133 SBSymbolContextList sb_sc_list; 2134 if (name && name[0]) { 2135 TargetSP target_sp(GetSP()); 2136 if (target_sp) { 2137 bool append = true; 2138 target_sp->GetImages().FindSymbolsWithNameAndType( 2139 ConstString(name), symbol_type, *sb_sc_list, append); 2140 } 2141 } 2142 return sb_sc_list; 2143 } 2144 2145 lldb::SBValue SBTarget::EvaluateExpression(const char *expr) { 2146 TargetSP target_sp(GetSP()); 2147 if (!target_sp) 2148 return SBValue(); 2149 2150 SBExpressionOptions options; 2151 lldb::DynamicValueType fetch_dynamic_value = 2152 target_sp->GetPreferDynamicValue(); 2153 options.SetFetchDynamicValue(fetch_dynamic_value); 2154 options.SetUnwindOnError(true); 2155 return EvaluateExpression(expr, options); 2156 } 2157 2158 lldb::SBValue SBTarget::EvaluateExpression(const char *expr, 2159 const SBExpressionOptions &options) { 2160 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 2161 #if !defined(LLDB_DISABLE_PYTHON) 2162 Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 2163 #endif 2164 SBValue expr_result; 2165 ExpressionResults exe_results = eExpressionSetupError; 2166 ValueObjectSP expr_value_sp; 2167 TargetSP target_sp(GetSP()); 2168 StackFrame *frame = NULL; 2169 if (target_sp) { 2170 if (expr == NULL || expr[0] == '\0') { 2171 if (log) 2172 log->Printf( 2173 "SBTarget::EvaluateExpression called with an empty expression"); 2174 return expr_result; 2175 } 2176 2177 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 2178 ExecutionContext exe_ctx(m_opaque_sp.get()); 2179 2180 if (log) 2181 log->Printf("SBTarget()::EvaluateExpression (expr=\"%s\")...", expr); 2182 2183 frame = exe_ctx.GetFramePtr(); 2184 Target *target = exe_ctx.GetTargetPtr(); 2185 2186 if (target) { 2187 #ifdef LLDB_CONFIGURATION_DEBUG 2188 StreamString frame_description; 2189 if (frame) 2190 frame->DumpUsingSettingsFormat(&frame_description); 2191 llvm::PrettyStackTraceFormat stack_trace( 2192 "SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = " 2193 "%u) %s", 2194 expr, options.GetFetchDynamicValue(), 2195 frame_description.GetString().str().c_str()); 2196 #endif 2197 exe_results = 2198 target->EvaluateExpression(expr, frame, expr_value_sp, options.ref()); 2199 2200 expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); 2201 } else { 2202 if (log) 2203 log->Printf("SBTarget::EvaluateExpression () => error: could not " 2204 "reconstruct frame object for this SBTarget."); 2205 } 2206 } 2207 #ifndef LLDB_DISABLE_PYTHON 2208 if (expr_log) 2209 expr_log->Printf("** [SBTarget::EvaluateExpression] Expression result is " 2210 "%s, summary %s **", 2211 expr_result.GetValue(), expr_result.GetSummary()); 2212 2213 if (log) 2214 log->Printf("SBTarget(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) " 2215 "(execution result=%d)", 2216 static_cast<void *>(frame), expr, 2217 static_cast<void *>(expr_value_sp.get()), exe_results); 2218 #endif 2219 2220 return expr_result; 2221 } 2222 2223 lldb::addr_t SBTarget::GetStackRedZoneSize() { 2224 TargetSP target_sp(GetSP()); 2225 if (target_sp) { 2226 ABISP abi_sp; 2227 ProcessSP process_sp(target_sp->GetProcessSP()); 2228 if (process_sp) 2229 abi_sp = process_sp->GetABI(); 2230 else 2231 abi_sp = ABI::FindPlugin(ProcessSP(), target_sp->GetArchitecture()); 2232 if (abi_sp) 2233 return abi_sp->GetRedZoneSize(); 2234 } 2235 return 0; 2236 } 2237 2238 lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const { 2239 lldb::SBLaunchInfo launch_info(NULL); 2240 TargetSP target_sp(GetSP()); 2241 if (target_sp) 2242 launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo()); 2243 return launch_info; 2244 } 2245 2246 void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) { 2247 TargetSP target_sp(GetSP()); 2248 if (target_sp) 2249 m_opaque_sp->SetProcessLaunchInfo(launch_info.ref()); 2250 } 2251