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