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 static Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) { 77 std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex()); 78 79 auto process_sp = target.GetProcessSP(); 80 if (process_sp) { 81 const auto state = process_sp->GetState(); 82 if (process_sp->IsAlive() && state == eStateConnected) { 83 // If we are already connected, then we have already specified the 84 // listener, so if a valid listener is supplied, we need to error out to 85 // let the client know. 86 if (attach_info.GetListener()) 87 return Status("process is connected and already has a listener, pass " 88 "empty listener"); 89 } 90 } 91 92 return target.Attach(attach_info, nullptr); 93 } 94 95 // SBTarget constructor 96 SBTarget::SBTarget() : m_opaque_sp() { 97 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTarget); 98 } 99 100 SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) { 101 LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs); 102 } 103 104 SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) { 105 LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp); 106 } 107 108 const SBTarget &SBTarget::operator=(const SBTarget &rhs) { 109 LLDB_RECORD_METHOD(const lldb::SBTarget &, 110 SBTarget, operator=,(const lldb::SBTarget &), rhs); 111 112 if (this != &rhs) 113 m_opaque_sp = rhs.m_opaque_sp; 114 return LLDB_RECORD_RESULT(*this); 115 } 116 117 // Destructor 118 SBTarget::~SBTarget() = default; 119 120 bool SBTarget::EventIsTargetEvent(const SBEvent &event) { 121 LLDB_RECORD_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent, 122 (const lldb::SBEvent &), event); 123 124 return Target::TargetEventData::GetEventDataFromEvent(event.get()) != nullptr; 125 } 126 127 SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) { 128 LLDB_RECORD_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent, 129 (const lldb::SBEvent &), event); 130 131 return LLDB_RECORD_RESULT( 132 Target::TargetEventData::GetTargetFromEvent(event.get())); 133 } 134 135 uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) { 136 LLDB_RECORD_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent, 137 (const lldb::SBEvent &), event); 138 139 const ModuleList module_list = 140 Target::TargetEventData::GetModuleListFromEvent(event.get()); 141 return module_list.GetSize(); 142 } 143 144 SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx, 145 const SBEvent &event) { 146 LLDB_RECORD_STATIC_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndexFromEvent, 147 (const uint32_t, const lldb::SBEvent &), idx, 148 event); 149 150 const ModuleList module_list = 151 Target::TargetEventData::GetModuleListFromEvent(event.get()); 152 return LLDB_RECORD_RESULT(SBModule(module_list.GetModuleAtIndex(idx))); 153 } 154 155 const char *SBTarget::GetBroadcasterClassName() { 156 LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget, 157 GetBroadcasterClassName); 158 159 return Target::GetStaticBroadcasterClass().AsCString(); 160 } 161 162 bool SBTarget::IsValid() const { 163 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid); 164 return this->operator bool(); 165 } 166 SBTarget::operator bool() const { 167 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool); 168 169 return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid(); 170 } 171 172 SBProcess SBTarget::GetProcess() { 173 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess); 174 175 SBProcess sb_process; 176 ProcessSP process_sp; 177 TargetSP target_sp(GetSP()); 178 if (target_sp) { 179 process_sp = target_sp->GetProcessSP(); 180 sb_process.SetSP(process_sp); 181 } 182 183 return LLDB_RECORD_RESULT(sb_process); 184 } 185 186 SBPlatform SBTarget::GetPlatform() { 187 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform); 188 189 TargetSP target_sp(GetSP()); 190 if (!target_sp) 191 return LLDB_RECORD_RESULT(SBPlatform()); 192 193 SBPlatform platform; 194 platform.m_opaque_sp = target_sp->GetPlatform(); 195 196 return LLDB_RECORD_RESULT(platform); 197 } 198 199 SBDebugger SBTarget::GetDebugger() const { 200 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger); 201 202 SBDebugger debugger; 203 TargetSP target_sp(GetSP()); 204 if (target_sp) 205 debugger.reset(target_sp->GetDebugger().shared_from_this()); 206 return LLDB_RECORD_RESULT(debugger); 207 } 208 209 SBStructuredData SBTarget::GetStatistics() { 210 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics); 211 212 SBStructuredData data; 213 TargetSP target_sp(GetSP()); 214 if (!target_sp) 215 return LLDB_RECORD_RESULT(data); 216 std::string json_str = 217 llvm::formatv("{0:2}", 218 DebuggerStats::ReportStatistics(target_sp->GetDebugger(), 219 target_sp.get())).str(); 220 data.m_impl_up->SetObjectSP(StructuredData::ParseJSON(json_str)); 221 return LLDB_RECORD_RESULT(data); 222 } 223 224 void SBTarget::SetCollectingStats(bool v) { 225 LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v); 226 227 TargetSP target_sp(GetSP()); 228 if (!target_sp) 229 return; 230 return DebuggerStats::SetCollectingStats(v); 231 } 232 233 bool SBTarget::GetCollectingStats() { 234 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats); 235 236 TargetSP target_sp(GetSP()); 237 if (!target_sp) 238 return false; 239 return DebuggerStats::GetCollectingStats(); 240 } 241 242 SBProcess SBTarget::LoadCore(const char *core_file) { 243 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *), 244 core_file); 245 246 lldb::SBError error; // Ignored 247 return LLDB_RECORD_RESULT(LoadCore(core_file, error)); 248 } 249 250 SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) { 251 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, 252 (const char *, lldb::SBError &), core_file, error); 253 254 SBProcess sb_process; 255 TargetSP target_sp(GetSP()); 256 if (target_sp) { 257 FileSpec filespec(core_file); 258 FileSystem::Instance().Resolve(filespec); 259 ProcessSP process_sp(target_sp->CreateProcess( 260 target_sp->GetDebugger().GetListener(), "", &filespec, false)); 261 if (process_sp) { 262 error.SetError(process_sp->LoadCore()); 263 if (error.Success()) 264 sb_process.SetSP(process_sp); 265 } else { 266 error.SetErrorString("Failed to create the process"); 267 } 268 } else { 269 error.SetErrorString("SBTarget is invalid"); 270 } 271 return LLDB_RECORD_RESULT(sb_process); 272 } 273 274 SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp, 275 const char *working_directory) { 276 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple, 277 (const char **, const char **, const char *), argv, envp, 278 working_directory); 279 280 TargetSP target_sp = GetSP(); 281 if (!target_sp) 282 return LLDB_RECORD_RESULT(SBProcess()); 283 284 SBLaunchInfo launch_info = GetLaunchInfo(); 285 286 if (Module *exe_module = target_sp->GetExecutableModulePointer()) 287 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), 288 /*add_as_first_arg*/ true); 289 if (argv) 290 launch_info.SetArguments(argv, /*append*/ true); 291 if (envp) 292 launch_info.SetEnvironmentEntries(envp, /*append*/ false); 293 if (working_directory) 294 launch_info.SetWorkingDirectory(working_directory); 295 296 SBError error; 297 return LLDB_RECORD_RESULT(Launch(launch_info, error)); 298 } 299 300 SBError SBTarget::Install() { 301 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install); 302 303 SBError sb_error; 304 TargetSP target_sp(GetSP()); 305 if (target_sp) { 306 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 307 sb_error.ref() = target_sp->Install(nullptr); 308 } 309 return LLDB_RECORD_RESULT(sb_error); 310 } 311 312 SBProcess SBTarget::Launch(SBListener &listener, char const **argv, 313 char const **envp, const char *stdin_path, 314 const char *stdout_path, const char *stderr_path, 315 const char *working_directory, 316 uint32_t launch_flags, // See LaunchFlags 317 bool stop_at_entry, lldb::SBError &error) { 318 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch, 319 (lldb::SBListener &, const char **, const char **, 320 const char *, const char *, const char *, const char *, 321 uint32_t, bool, lldb::SBError &), 322 listener, argv, envp, stdin_path, stdout_path, stderr_path, 323 working_directory, launch_flags, stop_at_entry, error); 324 325 SBProcess sb_process; 326 ProcessSP process_sp; 327 TargetSP target_sp(GetSP()); 328 329 if (target_sp) { 330 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 331 332 if (stop_at_entry) 333 launch_flags |= eLaunchFlagStopAtEntry; 334 335 if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR")) 336 launch_flags |= eLaunchFlagDisableASLR; 337 338 StateType state = eStateInvalid; 339 process_sp = target_sp->GetProcessSP(); 340 if (process_sp) { 341 state = process_sp->GetState(); 342 343 if (process_sp->IsAlive() && state != eStateConnected) { 344 if (state == eStateAttaching) 345 error.SetErrorString("process attach is in progress"); 346 else 347 error.SetErrorString("a process is already being debugged"); 348 return LLDB_RECORD_RESULT(sb_process); 349 } 350 } 351 352 if (state == eStateConnected) { 353 // If we are already connected, then we have already specified the 354 // listener, so if a valid listener is supplied, we need to error out to 355 // let the client know. 356 if (listener.IsValid()) { 357 error.SetErrorString("process is connected and already has a listener, " 358 "pass empty listener"); 359 return LLDB_RECORD_RESULT(sb_process); 360 } 361 } 362 363 if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO")) 364 launch_flags |= eLaunchFlagDisableSTDIO; 365 366 ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path), 367 FileSpec(stderr_path), 368 FileSpec(working_directory), launch_flags); 369 370 Module *exe_module = target_sp->GetExecutableModulePointer(); 371 if (exe_module) 372 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); 373 if (argv) { 374 launch_info.GetArguments().AppendArguments(argv); 375 } else { 376 auto default_launch_info = target_sp->GetProcessLaunchInfo(); 377 launch_info.GetArguments().AppendArguments( 378 default_launch_info.GetArguments()); 379 } 380 if (envp) { 381 launch_info.GetEnvironment() = Environment(envp); 382 } else { 383 auto default_launch_info = target_sp->GetProcessLaunchInfo(); 384 launch_info.GetEnvironment() = default_launch_info.GetEnvironment(); 385 } 386 387 if (listener.IsValid()) 388 launch_info.SetListener(listener.GetSP()); 389 390 error.SetError(target_sp->Launch(launch_info, nullptr)); 391 392 sb_process.SetSP(target_sp->GetProcessSP()); 393 } else { 394 error.SetErrorString("SBTarget is invalid"); 395 } 396 397 return LLDB_RECORD_RESULT(sb_process); 398 } 399 400 SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { 401 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch, 402 (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info, 403 error); 404 405 406 SBProcess sb_process; 407 TargetSP target_sp(GetSP()); 408 409 if (target_sp) { 410 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 411 StateType state = eStateInvalid; 412 { 413 ProcessSP process_sp = target_sp->GetProcessSP(); 414 if (process_sp) { 415 state = process_sp->GetState(); 416 417 if (process_sp->IsAlive() && state != eStateConnected) { 418 if (state == eStateAttaching) 419 error.SetErrorString("process attach is in progress"); 420 else 421 error.SetErrorString("a process is already being debugged"); 422 return LLDB_RECORD_RESULT(sb_process); 423 } 424 } 425 } 426 427 lldb_private::ProcessLaunchInfo launch_info = sb_launch_info.ref(); 428 429 if (!launch_info.GetExecutableFile()) { 430 Module *exe_module = target_sp->GetExecutableModulePointer(); 431 if (exe_module) 432 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); 433 } 434 435 const ArchSpec &arch_spec = target_sp->GetArchitecture(); 436 if (arch_spec.IsValid()) 437 launch_info.GetArchitecture() = arch_spec; 438 439 error.SetError(target_sp->Launch(launch_info, nullptr)); 440 sb_launch_info.set_ref(launch_info); 441 sb_process.SetSP(target_sp->GetProcessSP()); 442 } else { 443 error.SetErrorString("SBTarget is invalid"); 444 } 445 446 return LLDB_RECORD_RESULT(sb_process); 447 } 448 449 lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { 450 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach, 451 (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info, 452 error); 453 454 SBProcess sb_process; 455 TargetSP target_sp(GetSP()); 456 457 if (target_sp) { 458 ProcessAttachInfo &attach_info = sb_attach_info.ref(); 459 if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) { 460 PlatformSP platform_sp = target_sp->GetPlatform(); 461 // See if we can pre-verify if a process exists or not 462 if (platform_sp && platform_sp->IsConnected()) { 463 lldb::pid_t attach_pid = attach_info.GetProcessID(); 464 ProcessInstanceInfo instance_info; 465 if (platform_sp->GetProcessInfo(attach_pid, instance_info)) { 466 attach_info.SetUserID(instance_info.GetEffectiveUserID()); 467 } else { 468 error.ref().SetErrorStringWithFormat( 469 "no process found with process ID %" PRIu64, attach_pid); 470 return LLDB_RECORD_RESULT(sb_process); 471 } 472 } 473 } 474 error.SetError(AttachToProcess(attach_info, *target_sp)); 475 if (error.Success()) 476 sb_process.SetSP(target_sp->GetProcessSP()); 477 } else { 478 error.SetErrorString("SBTarget is invalid"); 479 } 480 481 return LLDB_RECORD_RESULT(sb_process); 482 } 483 484 lldb::SBProcess SBTarget::AttachToProcessWithID( 485 SBListener &listener, 486 lldb::pid_t pid, // The process ID to attach to 487 SBError &error // An error explaining what went wrong if attach fails 488 ) { 489 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID, 490 (lldb::SBListener &, lldb::pid_t, lldb::SBError &), 491 listener, pid, error); 492 493 SBProcess sb_process; 494 TargetSP target_sp(GetSP()); 495 496 if (target_sp) { 497 ProcessAttachInfo attach_info; 498 attach_info.SetProcessID(pid); 499 if (listener.IsValid()) 500 attach_info.SetListener(listener.GetSP()); 501 502 ProcessInstanceInfo instance_info; 503 if (target_sp->GetPlatform()->GetProcessInfo(pid, instance_info)) 504 attach_info.SetUserID(instance_info.GetEffectiveUserID()); 505 506 error.SetError(AttachToProcess(attach_info, *target_sp)); 507 if (error.Success()) 508 sb_process.SetSP(target_sp->GetProcessSP()); 509 } else 510 error.SetErrorString("SBTarget is invalid"); 511 512 return LLDB_RECORD_RESULT(sb_process); 513 } 514 515 lldb::SBProcess SBTarget::AttachToProcessWithName( 516 SBListener &listener, 517 const char *name, // basename of process to attach to 518 bool wait_for, // if true wait for a new instance of "name" to be launched 519 SBError &error // An error explaining what went wrong if attach fails 520 ) { 521 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName, 522 (lldb::SBListener &, const char *, bool, lldb::SBError &), 523 listener, name, wait_for, error); 524 525 SBProcess sb_process; 526 TargetSP target_sp(GetSP()); 527 528 if (name && target_sp) { 529 ProcessAttachInfo attach_info; 530 attach_info.GetExecutableFile().SetFile(name, FileSpec::Style::native); 531 attach_info.SetWaitForLaunch(wait_for); 532 if (listener.IsValid()) 533 attach_info.SetListener(listener.GetSP()); 534 535 error.SetError(AttachToProcess(attach_info, *target_sp)); 536 if (error.Success()) 537 sb_process.SetSP(target_sp->GetProcessSP()); 538 } else 539 error.SetErrorString("SBTarget is invalid"); 540 541 return LLDB_RECORD_RESULT(sb_process); 542 } 543 544 lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, 545 const char *plugin_name, 546 SBError &error) { 547 LLDB_RECORD_METHOD( 548 lldb::SBProcess, SBTarget, ConnectRemote, 549 (lldb::SBListener &, const char *, const char *, lldb::SBError &), 550 listener, url, plugin_name, error); 551 552 SBProcess sb_process; 553 ProcessSP process_sp; 554 TargetSP target_sp(GetSP()); 555 556 if (target_sp) { 557 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 558 if (listener.IsValid()) 559 process_sp = 560 target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, nullptr, 561 true); 562 else 563 process_sp = target_sp->CreateProcess( 564 target_sp->GetDebugger().GetListener(), plugin_name, nullptr, true); 565 566 if (process_sp) { 567 sb_process.SetSP(process_sp); 568 error.SetError(process_sp->ConnectRemote(url)); 569 } else { 570 error.SetErrorString("unable to create lldb_private::Process"); 571 } 572 } else { 573 error.SetErrorString("SBTarget is invalid"); 574 } 575 576 return LLDB_RECORD_RESULT(sb_process); 577 } 578 579 SBFileSpec SBTarget::GetExecutable() { 580 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable); 581 582 SBFileSpec exe_file_spec; 583 TargetSP target_sp(GetSP()); 584 if (target_sp) { 585 Module *exe_module = target_sp->GetExecutableModulePointer(); 586 if (exe_module) 587 exe_file_spec.SetFileSpec(exe_module->GetFileSpec()); 588 } 589 590 return LLDB_RECORD_RESULT(exe_file_spec); 591 } 592 593 bool SBTarget::operator==(const SBTarget &rhs) const { 594 LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &), 595 rhs); 596 597 return m_opaque_sp.get() == rhs.m_opaque_sp.get(); 598 } 599 600 bool SBTarget::operator!=(const SBTarget &rhs) const { 601 LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=,(const lldb::SBTarget &), 602 rhs); 603 604 return m_opaque_sp.get() != rhs.m_opaque_sp.get(); 605 } 606 607 lldb::TargetSP SBTarget::GetSP() const { return m_opaque_sp; } 608 609 void SBTarget::SetSP(const lldb::TargetSP &target_sp) { 610 m_opaque_sp = target_sp; 611 } 612 613 lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) { 614 LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress, 615 (lldb::addr_t), vm_addr); 616 617 lldb::SBAddress sb_addr; 618 Address &addr = sb_addr.ref(); 619 TargetSP target_sp(GetSP()); 620 if (target_sp) { 621 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 622 if (target_sp->ResolveLoadAddress(vm_addr, addr)) 623 return LLDB_RECORD_RESULT(sb_addr); 624 } 625 626 // We have a load address that isn't in a section, just return an address 627 // with the offset filled in (the address) and the section set to NULL 628 addr.SetRawAddress(vm_addr); 629 return LLDB_RECORD_RESULT(sb_addr); 630 } 631 632 lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) { 633 LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress, 634 (lldb::addr_t), file_addr); 635 636 lldb::SBAddress sb_addr; 637 Address &addr = sb_addr.ref(); 638 TargetSP target_sp(GetSP()); 639 if (target_sp) { 640 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 641 if (target_sp->ResolveFileAddress(file_addr, addr)) 642 return LLDB_RECORD_RESULT(sb_addr); 643 } 644 645 addr.SetRawAddress(file_addr); 646 return LLDB_RECORD_RESULT(sb_addr); 647 } 648 649 lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id, 650 lldb::addr_t vm_addr) { 651 LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress, 652 (uint32_t, lldb::addr_t), stop_id, vm_addr); 653 654 lldb::SBAddress sb_addr; 655 Address &addr = sb_addr.ref(); 656 TargetSP target_sp(GetSP()); 657 if (target_sp) { 658 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 659 if (target_sp->ResolveLoadAddress(vm_addr, addr)) 660 return LLDB_RECORD_RESULT(sb_addr); 661 } 662 663 // We have a load address that isn't in a section, just return an address 664 // with the offset filled in (the address) and the section set to NULL 665 addr.SetRawAddress(vm_addr); 666 return LLDB_RECORD_RESULT(sb_addr); 667 } 668 669 SBSymbolContext 670 SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr, 671 uint32_t resolve_scope) { 672 LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBTarget, 673 ResolveSymbolContextForAddress, 674 (const lldb::SBAddress &, uint32_t), addr, resolve_scope); 675 676 SBSymbolContext sc; 677 SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope); 678 if (addr.IsValid()) { 679 TargetSP target_sp(GetSP()); 680 if (target_sp) 681 target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope, 682 sc.ref()); 683 } 684 return LLDB_RECORD_RESULT(sc); 685 } 686 687 size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, 688 lldb::SBError &error) { 689 LLDB_RECORD_METHOD(size_t, SBTarget, ReadMemory, 690 (const lldb::SBAddress, void *, size_t, lldb::SBError &), 691 addr, buf, size, error); 692 693 SBError sb_error; 694 size_t bytes_read = 0; 695 TargetSP target_sp(GetSP()); 696 if (target_sp) { 697 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 698 bytes_read = 699 target_sp->ReadMemory(addr.ref(), buf, size, sb_error.ref(), true); 700 } else { 701 sb_error.SetErrorString("invalid target"); 702 } 703 704 return bytes_read; 705 } 706 707 SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, 708 uint32_t line) { 709 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, 710 (const char *, uint32_t), file, line); 711 712 return LLDB_RECORD_RESULT( 713 SBBreakpoint(BreakpointCreateByLocation(SBFileSpec(file, false), line))); 714 } 715 716 SBBreakpoint 717 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, 718 uint32_t line) { 719 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, 720 (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line); 721 722 return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0)); 723 } 724 725 SBBreakpoint 726 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, 727 uint32_t line, lldb::addr_t offset) { 728 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, 729 (const lldb::SBFileSpec &, uint32_t, lldb::addr_t), 730 sb_file_spec, line, offset); 731 732 SBFileSpecList empty_list; 733 return LLDB_RECORD_RESULT( 734 BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list)); 735 } 736 737 SBBreakpoint 738 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, 739 uint32_t line, lldb::addr_t offset, 740 SBFileSpecList &sb_module_list) { 741 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, 742 (const lldb::SBFileSpec &, uint32_t, lldb::addr_t, 743 lldb::SBFileSpecList &), 744 sb_file_spec, line, offset, sb_module_list); 745 746 return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0, 747 offset, sb_module_list)); 748 } 749 750 SBBreakpoint SBTarget::BreakpointCreateByLocation( 751 const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column, 752 lldb::addr_t offset, SBFileSpecList &sb_module_list) { 753 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, 754 (const lldb::SBFileSpec &, uint32_t, uint32_t, 755 lldb::addr_t, lldb::SBFileSpecList &), 756 sb_file_spec, line, column, offset, sb_module_list); 757 758 SBBreakpoint sb_bp; 759 TargetSP target_sp(GetSP()); 760 if (target_sp && line != 0) { 761 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 762 763 const LazyBool check_inlines = eLazyBoolCalculate; 764 const LazyBool skip_prologue = eLazyBoolCalculate; 765 const bool internal = false; 766 const bool hardware = false; 767 const LazyBool move_to_nearest_code = eLazyBoolCalculate; 768 const FileSpecList *module_list = nullptr; 769 if (sb_module_list.GetSize() > 0) { 770 module_list = sb_module_list.get(); 771 } 772 sb_bp = target_sp->CreateBreakpoint( 773 module_list, *sb_file_spec, line, column, offset, check_inlines, 774 skip_prologue, internal, hardware, move_to_nearest_code); 775 } 776 777 return LLDB_RECORD_RESULT(sb_bp); 778 } 779 780 SBBreakpoint SBTarget::BreakpointCreateByLocation( 781 const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column, 782 lldb::addr_t offset, SBFileSpecList &sb_module_list, 783 bool move_to_nearest_code) { 784 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, 785 (const lldb::SBFileSpec &, uint32_t, uint32_t, 786 lldb::addr_t, lldb::SBFileSpecList &, bool), 787 sb_file_spec, line, column, offset, sb_module_list, 788 move_to_nearest_code); 789 790 SBBreakpoint sb_bp; 791 TargetSP target_sp(GetSP()); 792 if (target_sp && line != 0) { 793 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 794 795 const LazyBool check_inlines = eLazyBoolCalculate; 796 const LazyBool skip_prologue = eLazyBoolCalculate; 797 const bool internal = false; 798 const bool hardware = false; 799 const FileSpecList *module_list = nullptr; 800 if (sb_module_list.GetSize() > 0) { 801 module_list = sb_module_list.get(); 802 } 803 sb_bp = target_sp->CreateBreakpoint( 804 module_list, *sb_file_spec, line, column, offset, check_inlines, 805 skip_prologue, internal, hardware, 806 move_to_nearest_code ? eLazyBoolYes : eLazyBoolNo); 807 } 808 809 return LLDB_RECORD_RESULT(sb_bp); 810 } 811 812 SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, 813 const char *module_name) { 814 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, 815 (const char *, const char *), symbol_name, module_name); 816 817 SBBreakpoint sb_bp; 818 TargetSP target_sp(GetSP()); 819 if (target_sp.get()) { 820 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 821 822 const bool internal = false; 823 const bool hardware = false; 824 const LazyBool skip_prologue = eLazyBoolCalculate; 825 const lldb::addr_t offset = 0; 826 if (module_name && module_name[0]) { 827 FileSpecList module_spec_list; 828 module_spec_list.Append(FileSpec(module_name)); 829 sb_bp = target_sp->CreateBreakpoint( 830 &module_spec_list, nullptr, symbol_name, eFunctionNameTypeAuto, 831 eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); 832 } else { 833 sb_bp = target_sp->CreateBreakpoint( 834 nullptr, nullptr, symbol_name, eFunctionNameTypeAuto, 835 eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); 836 } 837 } 838 839 return LLDB_RECORD_RESULT(sb_bp); 840 } 841 842 lldb::SBBreakpoint 843 SBTarget::BreakpointCreateByName(const char *symbol_name, 844 const SBFileSpecList &module_list, 845 const SBFileSpecList &comp_unit_list) { 846 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, 847 (const char *, const lldb::SBFileSpecList &, 848 const lldb::SBFileSpecList &), 849 symbol_name, module_list, comp_unit_list); 850 851 lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto; 852 return LLDB_RECORD_RESULT( 853 BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, 854 module_list, comp_unit_list)); 855 } 856 857 lldb::SBBreakpoint SBTarget::BreakpointCreateByName( 858 const char *symbol_name, uint32_t name_type_mask, 859 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { 860 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, 861 (const char *, uint32_t, const lldb::SBFileSpecList &, 862 const lldb::SBFileSpecList &), 863 symbol_name, name_type_mask, module_list, comp_unit_list); 864 865 return LLDB_RECORD_RESULT( 866 BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, 867 module_list, comp_unit_list)); 868 } 869 870 lldb::SBBreakpoint SBTarget::BreakpointCreateByName( 871 const char *symbol_name, uint32_t name_type_mask, 872 LanguageType symbol_language, const SBFileSpecList &module_list, 873 const SBFileSpecList &comp_unit_list) { 874 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, 875 (const char *, uint32_t, lldb::LanguageType, 876 const lldb::SBFileSpecList &, 877 const lldb::SBFileSpecList &), 878 symbol_name, name_type_mask, symbol_language, module_list, 879 comp_unit_list); 880 881 SBBreakpoint sb_bp; 882 TargetSP target_sp(GetSP()); 883 if (target_sp && symbol_name && symbol_name[0]) { 884 const bool internal = false; 885 const bool hardware = false; 886 const LazyBool skip_prologue = eLazyBoolCalculate; 887 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 888 FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask); 889 sb_bp = target_sp->CreateBreakpoint(module_list.get(), comp_unit_list.get(), 890 symbol_name, mask, symbol_language, 0, 891 skip_prologue, internal, hardware); 892 } 893 894 return LLDB_RECORD_RESULT(sb_bp); 895 } 896 897 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( 898 const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, 899 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { 900 LLDB_RECORD_METHOD( 901 lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, 902 (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &, 903 const lldb::SBFileSpecList &), 904 symbol_names, num_names, name_type_mask, module_list, comp_unit_list); 905 906 return LLDB_RECORD_RESULT(BreakpointCreateByNames( 907 symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 908 module_list, comp_unit_list)); 909 } 910 911 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( 912 const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, 913 LanguageType symbol_language, const SBFileSpecList &module_list, 914 const SBFileSpecList &comp_unit_list) { 915 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, 916 (const char **, uint32_t, uint32_t, lldb::LanguageType, 917 const lldb::SBFileSpecList &, 918 const lldb::SBFileSpecList &), 919 symbol_names, num_names, name_type_mask, symbol_language, 920 module_list, comp_unit_list); 921 922 return LLDB_RECORD_RESULT(BreakpointCreateByNames( 923 symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0, 924 module_list, comp_unit_list)); 925 } 926 927 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( 928 const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, 929 LanguageType symbol_language, lldb::addr_t offset, 930 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { 931 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, 932 (const char **, uint32_t, uint32_t, lldb::LanguageType, 933 lldb::addr_t, const lldb::SBFileSpecList &, 934 const lldb::SBFileSpecList &), 935 symbol_names, num_names, name_type_mask, symbol_language, 936 offset, module_list, comp_unit_list); 937 938 SBBreakpoint sb_bp; 939 TargetSP target_sp(GetSP()); 940 if (target_sp && num_names > 0) { 941 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 942 const bool internal = false; 943 const bool hardware = false; 944 FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask); 945 const LazyBool skip_prologue = eLazyBoolCalculate; 946 sb_bp = target_sp->CreateBreakpoint( 947 module_list.get(), comp_unit_list.get(), symbol_names, num_names, mask, 948 symbol_language, offset, skip_prologue, internal, hardware); 949 } 950 951 return LLDB_RECORD_RESULT(sb_bp); 952 } 953 954 SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, 955 const char *module_name) { 956 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, 957 (const char *, const char *), symbol_name_regex, 958 module_name); 959 960 SBFileSpecList module_spec_list; 961 SBFileSpecList comp_unit_list; 962 if (module_name && module_name[0]) { 963 module_spec_list.Append(FileSpec(module_name)); 964 } 965 return LLDB_RECORD_RESULT( 966 BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, 967 module_spec_list, comp_unit_list)); 968 } 969 970 lldb::SBBreakpoint 971 SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, 972 const SBFileSpecList &module_list, 973 const SBFileSpecList &comp_unit_list) { 974 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, 975 (const char *, const lldb::SBFileSpecList &, 976 const lldb::SBFileSpecList &), 977 symbol_name_regex, module_list, comp_unit_list); 978 979 return LLDB_RECORD_RESULT(BreakpointCreateByRegex( 980 symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list)); 981 } 982 983 lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( 984 const char *symbol_name_regex, LanguageType symbol_language, 985 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { 986 LLDB_RECORD_METHOD( 987 lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, 988 (const char *, lldb::LanguageType, const lldb::SBFileSpecList &, 989 const lldb::SBFileSpecList &), 990 symbol_name_regex, symbol_language, module_list, comp_unit_list); 991 992 993 SBBreakpoint sb_bp; 994 TargetSP target_sp(GetSP()); 995 if (target_sp && symbol_name_regex && symbol_name_regex[0]) { 996 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 997 RegularExpression regexp((llvm::StringRef(symbol_name_regex))); 998 const bool internal = false; 999 const bool hardware = false; 1000 const LazyBool skip_prologue = eLazyBoolCalculate; 1001 1002 sb_bp = target_sp->CreateFuncRegexBreakpoint( 1003 module_list.get(), comp_unit_list.get(), std::move(regexp), 1004 symbol_language, skip_prologue, internal, hardware); 1005 } 1006 1007 return LLDB_RECORD_RESULT(sb_bp); 1008 } 1009 1010 SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { 1011 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress, 1012 (lldb::addr_t), address); 1013 1014 SBBreakpoint sb_bp; 1015 TargetSP target_sp(GetSP()); 1016 if (target_sp) { 1017 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1018 const bool hardware = false; 1019 sb_bp = target_sp->CreateBreakpoint(address, false, hardware); 1020 } 1021 1022 return LLDB_RECORD_RESULT(sb_bp); 1023 } 1024 1025 SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { 1026 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress, 1027 (lldb::SBAddress &), sb_address); 1028 1029 SBBreakpoint sb_bp; 1030 TargetSP target_sp(GetSP()); 1031 if (!sb_address.IsValid()) { 1032 return LLDB_RECORD_RESULT(sb_bp); 1033 } 1034 1035 if (target_sp) { 1036 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1037 const bool hardware = false; 1038 sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware); 1039 } 1040 1041 return LLDB_RECORD_RESULT(sb_bp); 1042 } 1043 1044 lldb::SBBreakpoint 1045 SBTarget::BreakpointCreateBySourceRegex(const char *source_regex, 1046 const lldb::SBFileSpec &source_file, 1047 const char *module_name) { 1048 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, 1049 BreakpointCreateBySourceRegex, 1050 (const char *, const lldb::SBFileSpec &, const char *), 1051 source_regex, source_file, module_name); 1052 1053 SBFileSpecList module_spec_list; 1054 1055 if (module_name && module_name[0]) { 1056 module_spec_list.Append(FileSpec(module_name)); 1057 } 1058 1059 SBFileSpecList source_file_list; 1060 if (source_file.IsValid()) { 1061 source_file_list.Append(source_file); 1062 } 1063 1064 return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex( 1065 source_regex, module_spec_list, source_file_list)); 1066 } 1067 1068 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( 1069 const char *source_regex, const SBFileSpecList &module_list, 1070 const lldb::SBFileSpecList &source_file_list) { 1071 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, 1072 BreakpointCreateBySourceRegex, 1073 (const char *, const lldb::SBFileSpecList &, 1074 const lldb::SBFileSpecList &), 1075 source_regex, module_list, source_file_list); 1076 1077 return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex( 1078 source_regex, module_list, source_file_list, SBStringList())); 1079 } 1080 1081 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( 1082 const char *source_regex, const SBFileSpecList &module_list, 1083 const lldb::SBFileSpecList &source_file_list, 1084 const SBStringList &func_names) { 1085 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, 1086 BreakpointCreateBySourceRegex, 1087 (const char *, const lldb::SBFileSpecList &, 1088 const lldb::SBFileSpecList &, const lldb::SBStringList &), 1089 source_regex, module_list, source_file_list, func_names); 1090 1091 SBBreakpoint sb_bp; 1092 TargetSP target_sp(GetSP()); 1093 if (target_sp && source_regex && source_regex[0]) { 1094 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1095 const bool hardware = false; 1096 const LazyBool move_to_nearest_code = eLazyBoolCalculate; 1097 RegularExpression regexp((llvm::StringRef(source_regex))); 1098 std::unordered_set<std::string> func_names_set; 1099 for (size_t i = 0; i < func_names.GetSize(); i++) { 1100 func_names_set.insert(func_names.GetStringAtIndex(i)); 1101 } 1102 1103 sb_bp = target_sp->CreateSourceRegexBreakpoint( 1104 module_list.get(), source_file_list.get(), func_names_set, 1105 std::move(regexp), false, hardware, move_to_nearest_code); 1106 } 1107 1108 return LLDB_RECORD_RESULT(sb_bp); 1109 } 1110 1111 lldb::SBBreakpoint 1112 SBTarget::BreakpointCreateForException(lldb::LanguageType language, 1113 bool catch_bp, bool throw_bp) { 1114 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException, 1115 (lldb::LanguageType, bool, bool), language, catch_bp, 1116 throw_bp); 1117 1118 SBBreakpoint sb_bp; 1119 TargetSP target_sp(GetSP()); 1120 if (target_sp) { 1121 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1122 const bool hardware = false; 1123 sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp, 1124 hardware); 1125 } 1126 1127 return LLDB_RECORD_RESULT(sb_bp); 1128 } 1129 1130 lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript( 1131 const char *class_name, SBStructuredData &extra_args, 1132 const SBFileSpecList &module_list, const SBFileSpecList &file_list, 1133 bool request_hardware) { 1134 LLDB_RECORD_METHOD( 1135 lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript, 1136 (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &, 1137 const lldb::SBFileSpecList &, bool), 1138 class_name, extra_args, module_list, file_list, request_hardware); 1139 1140 SBBreakpoint sb_bp; 1141 TargetSP target_sp(GetSP()); 1142 if (target_sp) { 1143 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1144 Status error; 1145 1146 StructuredData::ObjectSP obj_sp = extra_args.m_impl_up->GetObjectSP(); 1147 sb_bp = 1148 target_sp->CreateScriptedBreakpoint(class_name, 1149 module_list.get(), 1150 file_list.get(), 1151 false, /* internal */ 1152 request_hardware, 1153 obj_sp, 1154 &error); 1155 } 1156 1157 return LLDB_RECORD_RESULT(sb_bp); 1158 } 1159 1160 uint32_t SBTarget::GetNumBreakpoints() const { 1161 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints); 1162 1163 TargetSP target_sp(GetSP()); 1164 if (target_sp) { 1165 // The breakpoint list is thread safe, no need to lock 1166 return target_sp->GetBreakpointList().GetSize(); 1167 } 1168 return 0; 1169 } 1170 1171 SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { 1172 LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex, 1173 (uint32_t), idx); 1174 1175 SBBreakpoint sb_breakpoint; 1176 TargetSP target_sp(GetSP()); 1177 if (target_sp) { 1178 // The breakpoint list is thread safe, no need to lock 1179 sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); 1180 } 1181 return LLDB_RECORD_RESULT(sb_breakpoint); 1182 } 1183 1184 bool SBTarget::BreakpointDelete(break_id_t bp_id) { 1185 LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t), 1186 bp_id); 1187 1188 bool result = false; 1189 TargetSP target_sp(GetSP()); 1190 if (target_sp) { 1191 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1192 result = target_sp->RemoveBreakpointByID(bp_id); 1193 } 1194 1195 return result; 1196 } 1197 1198 SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { 1199 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID, 1200 (lldb::break_id_t), bp_id); 1201 1202 SBBreakpoint sb_breakpoint; 1203 TargetSP target_sp(GetSP()); 1204 if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) { 1205 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1206 sb_breakpoint = target_sp->GetBreakpointByID(bp_id); 1207 } 1208 1209 return LLDB_RECORD_RESULT(sb_breakpoint); 1210 } 1211 1212 bool SBTarget::FindBreakpointsByName(const char *name, 1213 SBBreakpointList &bkpts) { 1214 LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName, 1215 (const char *, lldb::SBBreakpointList &), name, bkpts); 1216 1217 TargetSP target_sp(GetSP()); 1218 if (target_sp) { 1219 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1220 llvm::Expected<std::vector<BreakpointSP>> expected_vector = 1221 target_sp->GetBreakpointList().FindBreakpointsByName(name); 1222 if (!expected_vector) { 1223 LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS), 1224 "invalid breakpoint name: {}", 1225 llvm::toString(expected_vector.takeError())); 1226 return false; 1227 } 1228 for (BreakpointSP bkpt_sp : *expected_vector) { 1229 bkpts.AppendByID(bkpt_sp->GetID()); 1230 } 1231 } 1232 return true; 1233 } 1234 1235 void SBTarget::GetBreakpointNames(SBStringList &names) { 1236 LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &), 1237 names); 1238 1239 names.Clear(); 1240 1241 TargetSP target_sp(GetSP()); 1242 if (target_sp) { 1243 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1244 1245 std::vector<std::string> name_vec; 1246 target_sp->GetBreakpointNames(name_vec); 1247 for (auto name : name_vec) 1248 names.AppendString(name.c_str()); 1249 } 1250 } 1251 1252 void SBTarget::DeleteBreakpointName(const char *name) { 1253 LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *), 1254 name); 1255 1256 TargetSP target_sp(GetSP()); 1257 if (target_sp) { 1258 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1259 target_sp->DeleteBreakpointName(ConstString(name)); 1260 } 1261 } 1262 1263 bool SBTarget::EnableAllBreakpoints() { 1264 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints); 1265 1266 TargetSP target_sp(GetSP()); 1267 if (target_sp) { 1268 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1269 target_sp->EnableAllowedBreakpoints(); 1270 return true; 1271 } 1272 return false; 1273 } 1274 1275 bool SBTarget::DisableAllBreakpoints() { 1276 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints); 1277 1278 TargetSP target_sp(GetSP()); 1279 if (target_sp) { 1280 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1281 target_sp->DisableAllowedBreakpoints(); 1282 return true; 1283 } 1284 return false; 1285 } 1286 1287 bool SBTarget::DeleteAllBreakpoints() { 1288 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints); 1289 1290 TargetSP target_sp(GetSP()); 1291 if (target_sp) { 1292 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1293 target_sp->RemoveAllowedBreakpoints(); 1294 return true; 1295 } 1296 return false; 1297 } 1298 1299 lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, 1300 SBBreakpointList &new_bps) { 1301 LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile, 1302 (lldb::SBFileSpec &, lldb::SBBreakpointList &), 1303 source_file, new_bps); 1304 1305 SBStringList empty_name_list; 1306 return LLDB_RECORD_RESULT( 1307 BreakpointsCreateFromFile(source_file, empty_name_list, new_bps)); 1308 } 1309 1310 lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, 1311 SBStringList &matching_names, 1312 SBBreakpointList &new_bps) { 1313 LLDB_RECORD_METHOD( 1314 lldb::SBError, SBTarget, BreakpointsCreateFromFile, 1315 (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &), 1316 source_file, matching_names, new_bps); 1317 1318 SBError sberr; 1319 TargetSP target_sp(GetSP()); 1320 if (!target_sp) { 1321 sberr.SetErrorString( 1322 "BreakpointCreateFromFile called with invalid target."); 1323 return LLDB_RECORD_RESULT(sberr); 1324 } 1325 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1326 1327 BreakpointIDList bp_ids; 1328 1329 std::vector<std::string> name_vector; 1330 size_t num_names = matching_names.GetSize(); 1331 for (size_t i = 0; i < num_names; i++) 1332 name_vector.push_back(matching_names.GetStringAtIndex(i)); 1333 1334 sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(), 1335 name_vector, bp_ids); 1336 if (sberr.Fail()) 1337 return LLDB_RECORD_RESULT(sberr); 1338 1339 size_t num_bkpts = bp_ids.GetSize(); 1340 for (size_t i = 0; i < num_bkpts; i++) { 1341 BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i); 1342 new_bps.AppendByID(bp_id.GetBreakpointID()); 1343 } 1344 return LLDB_RECORD_RESULT(sberr); 1345 } 1346 1347 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) { 1348 LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, 1349 (lldb::SBFileSpec &), dest_file); 1350 1351 SBError sberr; 1352 TargetSP target_sp(GetSP()); 1353 if (!target_sp) { 1354 sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); 1355 return LLDB_RECORD_RESULT(sberr); 1356 } 1357 SBBreakpointList bkpt_list(*this); 1358 return LLDB_RECORD_RESULT(BreakpointsWriteToFile(dest_file, bkpt_list)); 1359 } 1360 1361 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file, 1362 SBBreakpointList &bkpt_list, 1363 bool append) { 1364 LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, 1365 (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool), 1366 dest_file, bkpt_list, append); 1367 1368 SBError sberr; 1369 TargetSP target_sp(GetSP()); 1370 if (!target_sp) { 1371 sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); 1372 return LLDB_RECORD_RESULT(sberr); 1373 } 1374 1375 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1376 BreakpointIDList bp_id_list; 1377 bkpt_list.CopyToBreakpointIDList(bp_id_list); 1378 sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(), 1379 bp_id_list, append); 1380 return LLDB_RECORD_RESULT(sberr); 1381 } 1382 1383 uint32_t SBTarget::GetNumWatchpoints() const { 1384 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints); 1385 1386 TargetSP target_sp(GetSP()); 1387 if (target_sp) { 1388 // The watchpoint list is thread safe, no need to lock 1389 return target_sp->GetWatchpointList().GetSize(); 1390 } 1391 return 0; 1392 } 1393 1394 SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const { 1395 LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex, 1396 (uint32_t), idx); 1397 1398 SBWatchpoint sb_watchpoint; 1399 TargetSP target_sp(GetSP()); 1400 if (target_sp) { 1401 // The watchpoint list is thread safe, no need to lock 1402 sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx)); 1403 } 1404 return LLDB_RECORD_RESULT(sb_watchpoint); 1405 } 1406 1407 bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { 1408 LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t), 1409 wp_id); 1410 1411 1412 bool result = false; 1413 TargetSP target_sp(GetSP()); 1414 if (target_sp) { 1415 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1416 std::unique_lock<std::recursive_mutex> lock; 1417 target_sp->GetWatchpointList().GetListMutex(lock); 1418 result = target_sp->RemoveWatchpointByID(wp_id); 1419 } 1420 1421 return result; 1422 } 1423 1424 SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { 1425 LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID, 1426 (lldb::watch_id_t), wp_id); 1427 1428 1429 SBWatchpoint sb_watchpoint; 1430 lldb::WatchpointSP watchpoint_sp; 1431 TargetSP target_sp(GetSP()); 1432 if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) { 1433 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1434 std::unique_lock<std::recursive_mutex> lock; 1435 target_sp->GetWatchpointList().GetListMutex(lock); 1436 watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id); 1437 sb_watchpoint.SetSP(watchpoint_sp); 1438 } 1439 1440 return LLDB_RECORD_RESULT(sb_watchpoint); 1441 } 1442 1443 lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, 1444 bool read, bool write, 1445 SBError &error) { 1446 LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress, 1447 (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr, 1448 size, read, write, error); 1449 1450 SBWatchpoint sb_watchpoint; 1451 lldb::WatchpointSP watchpoint_sp; 1452 TargetSP target_sp(GetSP()); 1453 if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS && 1454 size > 0) { 1455 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1456 uint32_t watch_type = 0; 1457 if (read) 1458 watch_type |= LLDB_WATCH_TYPE_READ; 1459 if (write) 1460 watch_type |= LLDB_WATCH_TYPE_WRITE; 1461 if (watch_type == 0) { 1462 error.SetErrorString( 1463 "Can't create a watchpoint that is neither read nor write."); 1464 return LLDB_RECORD_RESULT(sb_watchpoint); 1465 } 1466 1467 // Target::CreateWatchpoint() is thread safe. 1468 Status cw_error; 1469 // This API doesn't take in a type, so we can't figure out what it is. 1470 CompilerType *type = nullptr; 1471 watchpoint_sp = 1472 target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error); 1473 error.SetError(cw_error); 1474 sb_watchpoint.SetSP(watchpoint_sp); 1475 } 1476 1477 return LLDB_RECORD_RESULT(sb_watchpoint); 1478 } 1479 1480 bool SBTarget::EnableAllWatchpoints() { 1481 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints); 1482 1483 TargetSP target_sp(GetSP()); 1484 if (target_sp) { 1485 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1486 std::unique_lock<std::recursive_mutex> lock; 1487 target_sp->GetWatchpointList().GetListMutex(lock); 1488 target_sp->EnableAllWatchpoints(); 1489 return true; 1490 } 1491 return false; 1492 } 1493 1494 bool SBTarget::DisableAllWatchpoints() { 1495 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints); 1496 1497 TargetSP target_sp(GetSP()); 1498 if (target_sp) { 1499 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1500 std::unique_lock<std::recursive_mutex> lock; 1501 target_sp->GetWatchpointList().GetListMutex(lock); 1502 target_sp->DisableAllWatchpoints(); 1503 return true; 1504 } 1505 return false; 1506 } 1507 1508 SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr, 1509 SBType type) { 1510 LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress, 1511 (const char *, lldb::SBAddress, lldb::SBType), name, addr, 1512 type); 1513 1514 SBValue sb_value; 1515 lldb::ValueObjectSP new_value_sp; 1516 if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) { 1517 lldb::addr_t load_addr(addr.GetLoadAddress(*this)); 1518 ExecutionContext exe_ctx( 1519 ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); 1520 CompilerType ast_type(type.GetSP()->GetCompilerType(true)); 1521 new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr, 1522 exe_ctx, ast_type); 1523 } 1524 sb_value.SetSP(new_value_sp); 1525 return LLDB_RECORD_RESULT(sb_value); 1526 } 1527 1528 lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data, 1529 lldb::SBType type) { 1530 LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData, 1531 (const char *, lldb::SBData, lldb::SBType), name, data, 1532 type); 1533 1534 SBValue sb_value; 1535 lldb::ValueObjectSP new_value_sp; 1536 if (IsValid() && name && *name && data.IsValid() && type.IsValid()) { 1537 DataExtractorSP extractor(*data); 1538 ExecutionContext exe_ctx( 1539 ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); 1540 CompilerType ast_type(type.GetSP()->GetCompilerType(true)); 1541 new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor, 1542 exe_ctx, ast_type); 1543 } 1544 sb_value.SetSP(new_value_sp); 1545 return LLDB_RECORD_RESULT(sb_value); 1546 } 1547 1548 lldb::SBValue SBTarget::CreateValueFromExpression(const char *name, 1549 const char *expr) { 1550 LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression, 1551 (const char *, const char *), name, expr); 1552 1553 SBValue sb_value; 1554 lldb::ValueObjectSP new_value_sp; 1555 if (IsValid() && name && *name && expr && *expr) { 1556 ExecutionContext exe_ctx( 1557 ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); 1558 new_value_sp = 1559 ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx); 1560 } 1561 sb_value.SetSP(new_value_sp); 1562 return LLDB_RECORD_RESULT(sb_value); 1563 } 1564 1565 bool SBTarget::DeleteAllWatchpoints() { 1566 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints); 1567 1568 TargetSP target_sp(GetSP()); 1569 if (target_sp) { 1570 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); 1571 std::unique_lock<std::recursive_mutex> lock; 1572 target_sp->GetWatchpointList().GetListMutex(lock); 1573 target_sp->RemoveAllWatchpoints(); 1574 return true; 1575 } 1576 return false; 1577 } 1578 1579 void SBTarget::AppendImageSearchPath(const char *from, const char *to, 1580 lldb::SBError &error) { 1581 LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath, 1582 (const char *, const char *, lldb::SBError &), from, to, 1583 error); 1584 1585 TargetSP target_sp(GetSP()); 1586 if (!target_sp) 1587 return error.SetErrorString("invalid target"); 1588 1589 llvm::StringRef srFrom = from, srTo = to; 1590 if (srFrom.empty()) 1591 return error.SetErrorString("<from> path can't be empty"); 1592 if (srTo.empty()) 1593 return error.SetErrorString("<to> path can't be empty"); 1594 1595 target_sp->GetImageSearchPathList().Append(srFrom, srTo, true); 1596 } 1597 1598 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, 1599 const char *uuid_cstr) { 1600 LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, 1601 (const char *, const char *, const char *), path, triple, 1602 uuid_cstr); 1603 1604 return LLDB_RECORD_RESULT(AddModule(path, triple, uuid_cstr, nullptr)); 1605 } 1606 1607 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, 1608 const char *uuid_cstr, const char *symfile) { 1609 LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, 1610 (const char *, const char *, const char *, const char *), 1611 path, triple, uuid_cstr, symfile); 1612 1613 lldb::SBModule sb_module; 1614 TargetSP target_sp(GetSP()); 1615 if (target_sp) { 1616 ModuleSpec module_spec; 1617 if (path) 1618 module_spec.GetFileSpec().SetFile(path, FileSpec::Style::native); 1619 1620 if (uuid_cstr) 1621 module_spec.GetUUID().SetFromStringRef(uuid_cstr); 1622 1623 if (triple) 1624 module_spec.GetArchitecture() = Platform::GetAugmentedArchSpec( 1625 target_sp->GetPlatform().get(), triple); 1626 else 1627 module_spec.GetArchitecture() = target_sp->GetArchitecture(); 1628 1629 if (symfile) 1630 module_spec.GetSymbolFileSpec().SetFile(symfile, FileSpec::Style::native); 1631 1632 sb_module.SetSP(target_sp->GetOrCreateModule(module_spec, true /* notify */)); 1633 } 1634 return LLDB_RECORD_RESULT(sb_module); 1635 } 1636 1637 lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { 1638 LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, 1639 (const lldb::SBModuleSpec &), module_spec); 1640 1641 lldb::SBModule sb_module; 1642 TargetSP target_sp(GetSP()); 1643 if (target_sp) 1644 sb_module.SetSP(target_sp->GetOrCreateModule(*module_spec.m_opaque_up, 1645 true /* notify */)); 1646 return LLDB_RECORD_RESULT(sb_module); 1647 } 1648 1649 bool SBTarget::AddModule(lldb::SBModule &module) { 1650 LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module); 1651 1652 TargetSP target_sp(GetSP()); 1653 if (target_sp) { 1654 target_sp->GetImages().AppendIfNeeded(module.GetSP()); 1655 return true; 1656 } 1657 return false; 1658 } 1659 1660 uint32_t SBTarget::GetNumModules() const { 1661 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules); 1662 1663 uint32_t num = 0; 1664 TargetSP target_sp(GetSP()); 1665 if (target_sp) { 1666 // The module list is thread safe, no need to lock 1667 num = target_sp->GetImages().GetSize(); 1668 } 1669 1670 return num; 1671 } 1672 1673 void SBTarget::Clear() { 1674 LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear); 1675 1676 m_opaque_sp.reset(); 1677 } 1678 1679 SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) { 1680 LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule, 1681 (const lldb::SBFileSpec &), sb_file_spec); 1682 1683 SBModule sb_module; 1684 TargetSP target_sp(GetSP()); 1685 if (target_sp && sb_file_spec.IsValid()) { 1686 ModuleSpec module_spec(*sb_file_spec); 1687 // The module list is thread safe, no need to lock 1688 sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec)); 1689 } 1690 return LLDB_RECORD_RESULT(sb_module); 1691 } 1692 1693 SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) { 1694 LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits, 1695 (const lldb::SBFileSpec &), sb_file_spec); 1696 1697 SBSymbolContextList sb_sc_list; 1698 const TargetSP target_sp(GetSP()); 1699 if (target_sp && sb_file_spec.IsValid()) 1700 target_sp->GetImages().FindCompileUnits(*sb_file_spec, *sb_sc_list); 1701 return LLDB_RECORD_RESULT(sb_sc_list); 1702 } 1703 1704 lldb::ByteOrder SBTarget::GetByteOrder() { 1705 LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder); 1706 1707 TargetSP target_sp(GetSP()); 1708 if (target_sp) 1709 return target_sp->GetArchitecture().GetByteOrder(); 1710 return eByteOrderInvalid; 1711 } 1712 1713 const char *SBTarget::GetTriple() { 1714 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple); 1715 1716 TargetSP target_sp(GetSP()); 1717 if (target_sp) { 1718 std::string triple(target_sp->GetArchitecture().GetTriple().str()); 1719 // Unique the string so we don't run into ownership issues since the const 1720 // strings put the string into the string pool once and the strings never 1721 // comes out 1722 ConstString const_triple(triple.c_str()); 1723 return const_triple.GetCString(); 1724 } 1725 return nullptr; 1726 } 1727 1728 uint32_t SBTarget::GetDataByteSize() { 1729 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize); 1730 1731 TargetSP target_sp(GetSP()); 1732 if (target_sp) { 1733 return target_sp->GetArchitecture().GetDataByteSize(); 1734 } 1735 return 0; 1736 } 1737 1738 uint32_t SBTarget::GetCodeByteSize() { 1739 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize); 1740 1741 TargetSP target_sp(GetSP()); 1742 if (target_sp) { 1743 return target_sp->GetArchitecture().GetCodeByteSize(); 1744 } 1745 return 0; 1746 } 1747 1748 uint32_t SBTarget::GetMaximumNumberOfChildrenToDisplay() const { 1749 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay); 1750 1751 TargetSP target_sp(GetSP()); 1752 if(target_sp){ 1753 return target_sp->GetMaximumNumberOfChildrenToDisplay(); 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_CONST(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay,()); 2693 LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ()); 2694 LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, 2695 (uint32_t)); 2696 LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule)); 2697 LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster, 2698 ()); 2699 LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription, 2700 (lldb::SBStream &, lldb::DescriptionLevel)); 2701 LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions, 2702 (const char *, uint32_t)); 2703 LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, 2704 FindGlobalFunctions, 2705 (const char *, uint32_t, lldb::MatchType)); 2706 LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *)); 2707 LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType, 2708 (lldb::BasicType)); 2709 LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *)); 2710 LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, 2711 (const char *, uint32_t)); 2712 LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, 2713 (const char *, uint32_t, lldb::MatchType)); 2714 LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable, 2715 (const char *)); 2716 LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ()); 2717 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, 2718 (lldb::SBAddress, uint32_t)); 2719 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, 2720 (lldb::SBAddress, uint32_t, const char *)); 2721 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress, 2722 (lldb::SBSection, lldb::addr_t)); 2723 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress, 2724 (lldb::SBSection)); 2725 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress, 2726 (lldb::SBModule, int64_t)); 2727 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress, 2728 (lldb::SBModule)); 2729 LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols, 2730 (const char *, lldb::SymbolType)); 2731 LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, 2732 (const char *)); 2733 LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, 2734 (const char *, const lldb::SBExpressionOptions &)); 2735 LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ()); 2736 LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsLoaded, 2737 (const lldb::SBModule &)); 2738 LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ()); 2739 LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo, 2740 (const lldb::SBLaunchInfo &)); 2741 LLDB_REGISTER_METHOD( 2742 size_t, SBTarget, ReadMemory, 2743 (const lldb::SBAddress, void *, size_t, lldb::SBError &)); 2744 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, 2745 (lldb::SBAddress, const void *, size_t)); 2746 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, 2747 GetInstructionsWithFlavor, 2748 (lldb::SBAddress, const char *, const void *, size_t)); 2749 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, 2750 (lldb::addr_t, const void *, size_t)); 2751 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, 2752 GetInstructionsWithFlavor, 2753 (lldb::addr_t, const char *, const void *, size_t)); 2754 LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBTarget, GetEnvironment, ()); 2755 LLDB_REGISTER_METHOD(lldb::SBTrace, SBTarget, GetTrace, ()); 2756 LLDB_REGISTER_METHOD(lldb::SBTrace, SBTarget, CreateTrace, (lldb::SBError &)); 2757 } 2758 2759 } 2760 } 2761