lldb/source/API/SBTarget.cpp

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