lldb/source/API/SBTarget.cpp

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