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