lldb/source/Target/Platform.cpp

   1 //===-- Platform.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 <algorithm>
  10 #include <csignal>
  11 #include <fstream>
  12 #include <memory>
  13 #include <vector>
  14
  15 #include "lldb/Breakpoint/BreakpointIDList.h"
  16 #include "lldb/Breakpoint/BreakpointLocation.h"
  17 #include "lldb/Core/Debugger.h"
  18 #include "lldb/Core/Module.h"
  19 #include "lldb/Core/ModuleSpec.h"
  20 #include "lldb/Core/PluginManager.h"
  21 #include "lldb/Core/StreamFile.h"
  22 #include "lldb/Host/FileSystem.h"
  23 #include "lldb/Host/Host.h"
  24 #include "lldb/Host/HostInfo.h"
  25 #include "lldb/Host/OptionParser.h"
  26 #include "lldb/Interpreter/OptionValueFileSpec.h"
  27 #include "lldb/Interpreter/OptionValueProperties.h"
  28 #include "lldb/Interpreter/Property.h"
  29 #include "lldb/Symbol/ObjectFile.h"
  30 #include "lldb/Target/ModuleCache.h"
  31 #include "lldb/Target/Platform.h"
  32 #include "lldb/Target/Process.h"
  33 #include "lldb/Target/Target.h"
  34 #include "lldb/Target/UnixSignals.h"
  35 #include "lldb/Utility/DataBufferHeap.h"
  36 #include "lldb/Utility/FileSpec.h"
  37 #include "lldb/Utility/Log.h"
  38 #include "lldb/Utility/Status.h"
  39 #include "lldb/Utility/StructuredData.h"
  40 #include "llvm/Support/FileSystem.h"
  41 #include "llvm/Support/Path.h"
  42
  43 // Define these constants from POSIX mman.h rather than include the file so
  44 // that they will be correct even when compiled on Linux.
  45 #define MAP_PRIVATE 2
  46 #define MAP_ANON 0x1000
  47
  48 using namespace lldb;
  49 using namespace lldb_private;
  50
  51 static uint32_t g_initialize_count = 0;
  52
  53 // Use a singleton function for g_local_platform_sp to avoid init constructors
  54 // since LLDB is often part of a shared library
  55 static PlatformSP &GetHostPlatformSP() {
  56   static PlatformSP g_platform_sp;
  57   return g_platform_sp;
  58 }
  59
  60 const char *Platform::GetHostPlatformName() { return "host"; }
  61
  62 namespace {
  63
  64 #define LLDB_PROPERTIES_platform
  65 #include "TargetProperties.inc"
  66
  67 enum {
  68 #define LLDB_PROPERTIES_platform
  69 #include "TargetPropertiesEnum.inc"
  70 };
  71
  72 } // namespace
  73
  74 ConstString PlatformProperties::GetSettingName() {
  75   static ConstString g_setting_name("platform");
  76   return g_setting_name;
  77 }
  78
  79 PlatformProperties::PlatformProperties() {
  80   m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
  81   m_collection_sp->Initialize(g_platform_properties);
  82
  83   auto module_cache_dir = GetModuleCacheDirectory();
  84   if (module_cache_dir)
  85     return;
  86
  87   llvm::SmallString<64> user_home_dir;
  88   if (!FileSystem::Instance().GetHomeDirectory(user_home_dir))
  89     return;
  90
  91   module_cache_dir = FileSpec(user_home_dir.c_str());
  92   module_cache_dir.AppendPathComponent(".lldb");
  93   module_cache_dir.AppendPathComponent("module_cache");
  94   SetDefaultModuleCacheDirectory(module_cache_dir);
  95   SetModuleCacheDirectory(module_cache_dir);
  96 }
  97
  98 bool PlatformProperties::GetUseModuleCache() const {
  99   const auto idx = ePropertyUseModuleCache;
 100   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 101       nullptr, idx, g_platform_properties[idx].default_uint_value != 0);
 102 }
 103
 104 bool PlatformProperties::SetUseModuleCache(bool use_module_cache) {
 105   return m_collection_sp->SetPropertyAtIndexAsBoolean(
 106       nullptr, ePropertyUseModuleCache, use_module_cache);
 107 }
 108
 109 FileSpec PlatformProperties::GetModuleCacheDirectory() const {
 110   return m_collection_sp->GetPropertyAtIndexAsFileSpec(
 111       nullptr, ePropertyModuleCacheDirectory);
 112 }
 113
 114 bool PlatformProperties::SetModuleCacheDirectory(const FileSpec &dir_spec) {
 115   return m_collection_sp->SetPropertyAtIndexAsFileSpec(
 116       nullptr, ePropertyModuleCacheDirectory, dir_spec);
 117 }
 118
 119 void PlatformProperties::SetDefaultModuleCacheDirectory(
 120     const FileSpec &dir_spec) {
 121   auto f_spec_opt = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec(
 122         nullptr, false, ePropertyModuleCacheDirectory);
 123   assert(f_spec_opt);
 124   f_spec_opt->SetDefaultValue(dir_spec);
 125 }
 126
 127 /// Get the native host platform plug-in.
 128 ///
 129 /// There should only be one of these for each host that LLDB runs
 130 /// upon that should be statically compiled in and registered using
 131 /// preprocessor macros or other similar build mechanisms.
 132 ///
 133 /// This platform will be used as the default platform when launching
 134 /// or attaching to processes unless another platform is specified.
 135 PlatformSP Platform::GetHostPlatform() { return GetHostPlatformSP(); }
 136
 137 static std::vector<PlatformSP> &GetPlatformList() {
 138   static std::vector<PlatformSP> g_platform_list;
 139   return g_platform_list;
 140 }
 141
 142 static std::recursive_mutex &GetPlatformListMutex() {
 143   static std::recursive_mutex g_mutex;
 144   return g_mutex;
 145 }
 146
 147 void Platform::Initialize() { g_initialize_count++; }
 148
 149 void Platform::Terminate() {
 150   if (g_initialize_count > 0) {
 151     if (--g_initialize_count == 0) {
 152       std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 153       GetPlatformList().clear();
 154     }
 155   }
 156 }
 157
 158 PlatformProperties &Platform::GetGlobalPlatformProperties() {
 159   static PlatformProperties g_settings;
 160   return g_settings;
 161 }
 162
 163 void Platform::SetHostPlatform(const lldb::PlatformSP &platform_sp) {
 164   // The native platform should use its static void Platform::Initialize()
 165   // function to register itself as the native platform.
 166   GetHostPlatformSP() = platform_sp;
 167
 168   if (platform_sp) {
 169     std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 170     GetPlatformList().push_back(platform_sp);
 171   }
 172 }
 173
 174 Status Platform::GetFileWithUUID(const FileSpec &platform_file,
 175                                  const UUID *uuid_ptr, FileSpec &local_file) {
 176   // Default to the local case
 177   local_file = platform_file;
 178   return Status();
 179 }
 180
 181 FileSpecList
 182 Platform::LocateExecutableScriptingResources(Target *target, Module &module,
 183                                              Stream *feedback_stream) {
 184   return FileSpecList();
 185 }
 186
 187 // PlatformSP
 188 // Platform::FindPlugin (Process *process, ConstString plugin_name)
 189 //{
 190 //    PlatformCreateInstance create_callback = nullptr;
 191 //    if (plugin_name)
 192 //    {
 193 //        create_callback  =
 194 //        PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name);
 195 //        if (create_callback)
 196 //        {
 197 //            ArchSpec arch;
 198 //            if (process)
 199 //            {
 200 //                arch = process->GetTarget().GetArchitecture();
 201 //            }
 202 //            PlatformSP platform_sp(create_callback(process, &arch));
 203 //            if (platform_sp)
 204 //                return platform_sp;
 205 //        }
 206 //    }
 207 //    else
 208 //    {
 209 //        for (uint32_t idx = 0; (create_callback =
 210 //        PluginManager::GetPlatformCreateCallbackAtIndex(idx)) != nullptr;
 211 //        ++idx)
 212 //        {
 213 //            PlatformSP platform_sp(create_callback(process, nullptr));
 214 //            if (platform_sp)
 215 //                return platform_sp;
 216 //        }
 217 //    }
 218 //    return PlatformSP();
 219 //}
 220
 221 Status Platform::GetSharedModule(
 222     const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
 223     const FileSpecList *module_search_paths_ptr,
 224     llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules, bool *did_create_ptr) {
 225   if (IsHost())
 226     return ModuleList::GetSharedModule(module_spec, module_sp,
 227                                        module_search_paths_ptr, old_modules,
 228                                        did_create_ptr, false);
 229
 230   // Module resolver lambda.
 231   auto resolver = [&](const ModuleSpec &spec) {
 232     Status error(eErrorTypeGeneric);
 233     ModuleSpec resolved_spec;
 234     // Check if we have sysroot set.
 235     if (m_sdk_sysroot) {
 236       // Prepend sysroot to module spec.
 237       resolved_spec = spec;
 238       resolved_spec.GetFileSpec().PrependPathComponent(
 239           m_sdk_sysroot.GetStringRef());
 240       // Try to get shared module with resolved spec.
 241       error = ModuleList::GetSharedModule(resolved_spec, module_sp,
 242                                           module_search_paths_ptr, old_modules,
 243                                           did_create_ptr, false);
 244     }
 245     // If we don't have sysroot or it didn't work then
 246     // try original module spec.
 247     if (!error.Success()) {
 248       resolved_spec = spec;
 249       error = ModuleList::GetSharedModule(resolved_spec, module_sp,
 250                                           module_search_paths_ptr, old_modules,
 251                                           did_create_ptr, false);
 252     }
 253     if (error.Success() && module_sp)
 254       module_sp->SetPlatformFileSpec(resolved_spec.GetFileSpec());
 255     return error;
 256   };
 257
 258   return GetRemoteSharedModule(module_spec, process, module_sp, resolver,
 259                                did_create_ptr);
 260 }
 261
 262 bool Platform::GetModuleSpec(const FileSpec &module_file_spec,
 263                              const ArchSpec &arch, ModuleSpec &module_spec) {
 264   ModuleSpecList module_specs;
 265   if (ObjectFile::GetModuleSpecifications(module_file_spec, 0, 0,
 266                                           module_specs) == 0)
 267     return false;
 268
 269   ModuleSpec matched_module_spec;
 270   return module_specs.FindMatchingModuleSpec(ModuleSpec(module_file_spec, arch),
 271                                              module_spec);
 272 }
 273
 274 PlatformSP Platform::Find(ConstString name) {
 275   if (name) {
 276     static ConstString g_host_platform_name("host");
 277     if (name == g_host_platform_name)
 278       return GetHostPlatform();
 279
 280     std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 281     for (const auto &platform_sp : GetPlatformList()) {
 282       if (platform_sp->GetName() == name)
 283         return platform_sp;
 284     }
 285   }
 286   return PlatformSP();
 287 }
 288
 289 PlatformSP Platform::Create(ConstString name, Status &error) {
 290   PlatformCreateInstance create_callback = nullptr;
 291   lldb::PlatformSP platform_sp;
 292   if (name) {
 293     static ConstString g_host_platform_name("host");
 294     if (name == g_host_platform_name)
 295       return GetHostPlatform();
 296
 297     create_callback = PluginManager::GetPlatformCreateCallbackForPluginName(
 298         name.GetStringRef());
 299     if (create_callback)
 300       platform_sp = create_callback(true, nullptr);
 301     else
 302       error.SetErrorStringWithFormat(
 303           "unable to find a plug-in for the platform named \"%s\"",
 304           name.GetCString());
 305   } else
 306     error.SetErrorString("invalid platform name");
 307
 308   if (platform_sp) {
 309     std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 310     GetPlatformList().push_back(platform_sp);
 311   }
 312
 313   return platform_sp;
 314 }
 315
 316 PlatformSP Platform::Create(const ArchSpec &arch, ArchSpec *platform_arch_ptr,
 317                             Status &error) {
 318   lldb::PlatformSP platform_sp;
 319   if (arch.IsValid()) {
 320     // Scope for locker
 321     {
 322       // First try exact arch matches across all platforms already created
 323       std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 324       for (const auto &platform_sp : GetPlatformList()) {
 325         if (platform_sp->IsCompatibleArchitecture(arch, true,
 326                                                   platform_arch_ptr))
 327           return platform_sp;
 328       }
 329
 330       // Next try compatible arch matches across all platforms already created
 331       for (const auto &platform_sp : GetPlatformList()) {
 332         if (platform_sp->IsCompatibleArchitecture(arch, false,
 333                                                   platform_arch_ptr))
 334           return platform_sp;
 335       }
 336     }
 337
 338     PlatformCreateInstance create_callback;
 339     // First try exact arch matches across all platform plug-ins
 340     uint32_t idx;
 341     for (idx = 0; (create_callback =
 342                        PluginManager::GetPlatformCreateCallbackAtIndex(idx));
 343          ++idx) {
 344       if (create_callback) {
 345         platform_sp = create_callback(false, &arch);
 346         if (platform_sp &&
 347             platform_sp->IsCompatibleArchitecture(arch, true,
 348                                                   platform_arch_ptr)) {
 349           std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 350           GetPlatformList().push_back(platform_sp);
 351           return platform_sp;
 352         }
 353       }
 354     }
 355     // Next try compatible arch matches across all platform plug-ins
 356     for (idx = 0; (create_callback =
 357                        PluginManager::GetPlatformCreateCallbackAtIndex(idx));
 358          ++idx) {
 359       if (create_callback) {
 360         platform_sp = create_callback(false, &arch);
 361         if (platform_sp &&
 362             platform_sp->IsCompatibleArchitecture(arch, false,
 363                                                   platform_arch_ptr)) {
 364           std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 365           GetPlatformList().push_back(platform_sp);
 366           return platform_sp;
 367         }
 368       }
 369     }
 370   } else
 371     error.SetErrorString("invalid platform name");
 372   if (platform_arch_ptr)
 373     platform_arch_ptr->Clear();
 374   platform_sp.reset();
 375   return platform_sp;
 376 }
 377
 378 ArchSpec Platform::GetAugmentedArchSpec(Platform *platform, llvm::StringRef triple) {
 379   if (platform)
 380     return platform->GetAugmentedArchSpec(triple);
 381   return HostInfo::GetAugmentedArchSpec(triple);
 382 }
 383
 384 /// Default Constructor
 385 Platform::Platform(bool is_host)
 386     : m_is_host(is_host), m_os_version_set_while_connected(false),
 387       m_system_arch_set_while_connected(false), m_sdk_sysroot(), m_sdk_build(),
 388       m_working_dir(), m_remote_url(), m_name(), m_system_arch(), m_mutex(),
 389       m_max_uid_name_len(0), m_max_gid_name_len(0), m_supports_rsync(false),
 390       m_rsync_opts(), m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(),
 391       m_ignores_remote_hostname(false), m_trap_handlers(),
 392       m_calculated_trap_handlers(false),
 393       m_module_cache(std::make_unique<ModuleCache>()) {
 394   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
 395   LLDB_LOGF(log, "%p Platform::Platform()", static_cast<void *>(this));
 396 }
 397
 398 Platform::~Platform() = default;
 399
 400 void Platform::GetStatus(Stream &strm) {
 401   strm.Format("  Platform: {0}\n", GetPluginName());
 402
 403   ArchSpec arch(GetSystemArchitecture());
 404   if (arch.IsValid()) {
 405     if (!arch.GetTriple().str().empty()) {
 406       strm.Printf("    Triple: ");
 407       arch.DumpTriple(strm.AsRawOstream());
 408       strm.EOL();
 409     }
 410   }
 411
 412   llvm::VersionTuple os_version = GetOSVersion();
 413   if (!os_version.empty()) {
 414     strm.Format("OS Version: {0}", os_version.getAsString());
 415
 416     if (llvm::Optional<std::string> s = GetOSBuildString())
 417       strm.Format(" ({0})", *s);
 418
 419     strm.EOL();
 420   }
 421
 422   if (IsHost()) {
 423     strm.Printf("  Hostname: %s\n", GetHostname());
 424   } else {
 425     const bool is_connected = IsConnected();
 426     if (is_connected)
 427       strm.Printf("  Hostname: %s\n", GetHostname());
 428     strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no");
 429   }
 430
 431   if (GetWorkingDirectory()) {
 432     strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetCString());
 433   }
 434   if (!IsConnected())
 435     return;
 436
 437   std::string specific_info(GetPlatformSpecificConnectionInformation());
 438
 439   if (!specific_info.empty())
 440     strm.Printf("Platform-specific connection: %s\n", specific_info.c_str());
 441
 442   if (llvm::Optional<std::string> s = GetOSKernelDescription())
 443     strm.Format("    Kernel: {0}\n", *s);
 444 }
 445
 446 llvm::VersionTuple Platform::GetOSVersion(Process *process) {
 447   std::lock_guard<std::mutex> guard(m_mutex);
 448
 449   if (IsHost()) {
 450     if (m_os_version.empty()) {
 451       // We have a local host platform
 452       m_os_version = HostInfo::GetOSVersion();
 453       m_os_version_set_while_connected = !m_os_version.empty();
 454     }
 455   } else {
 456     // We have a remote platform. We can only fetch the remote
 457     // OS version if we are connected, and we don't want to do it
 458     // more than once.
 459
 460     const bool is_connected = IsConnected();
 461
 462     bool fetch = false;
 463     if (!m_os_version.empty()) {
 464       // We have valid OS version info, check to make sure it wasn't manually
 465       // set prior to connecting. If it was manually set prior to connecting,
 466       // then lets fetch the actual OS version info if we are now connected.
 467       if (is_connected && !m_os_version_set_while_connected)
 468         fetch = true;
 469     } else {
 470       // We don't have valid OS version info, fetch it if we are connected
 471       fetch = is_connected;
 472     }
 473
 474     if (fetch)
 475       m_os_version_set_while_connected = GetRemoteOSVersion();
 476   }
 477
 478   if (!m_os_version.empty())
 479     return m_os_version;
 480   if (process) {
 481     // Check with the process in case it can answer the question if a process
 482     // was provided
 483     return process->GetHostOSVersion();
 484   }
 485   return llvm::VersionTuple();
 486 }
 487
 488 llvm::Optional<std::string> Platform::GetOSBuildString() {
 489   if (IsHost())
 490     return HostInfo::GetOSBuildString();
 491   return GetRemoteOSBuildString();
 492 }
 493
 494 llvm::Optional<std::string> Platform::GetOSKernelDescription() {
 495   if (IsHost())
 496     return HostInfo::GetOSKernelDescription();
 497   return GetRemoteOSKernelDescription();
 498 }
 499
 500 void Platform::AddClangModuleCompilationOptions(
 501     Target *target, std::vector<std::string> &options) {
 502   std::vector<std::string> default_compilation_options = {
 503       "-x", "c++", "-Xclang", "-nostdsysteminc", "-Xclang", "-nostdsysteminc"};
 504
 505   options.insert(options.end(), default_compilation_options.begin(),
 506                  default_compilation_options.end());
 507 }
 508
 509 FileSpec Platform::GetWorkingDirectory() {
 510   if (IsHost()) {
 511     llvm::SmallString<64> cwd;
 512     if (llvm::sys::fs::current_path(cwd))
 513       return {};
 514     else {
 515       FileSpec file_spec(cwd);
 516       FileSystem::Instance().Resolve(file_spec);
 517       return file_spec;
 518     }
 519   } else {
 520     if (!m_working_dir)
 521       m_working_dir = GetRemoteWorkingDirectory();
 522     return m_working_dir;
 523   }
 524 }
 525
 526 struct RecurseCopyBaton {
 527   const FileSpec &dst;
 528   Platform *platform_ptr;
 529   Status error;
 530 };
 531
 532 static FileSystem::EnumerateDirectoryResult
 533 RecurseCopy_Callback(void *baton, llvm::sys::fs::file_type ft,
 534                      llvm::StringRef path) {
 535   RecurseCopyBaton *rc_baton = (RecurseCopyBaton *)baton;
 536   FileSpec src(path);
 537   namespace fs = llvm::sys::fs;
 538   switch (ft) {
 539   case fs::file_type::fifo_file:
 540   case fs::file_type::socket_file:
 541     // we have no way to copy pipes and sockets - ignore them and continue
 542     return FileSystem::eEnumerateDirectoryResultNext;
 543     break;
 544
 545   case fs::file_type::directory_file: {
 546     // make the new directory and get in there
 547     FileSpec dst_dir = rc_baton->dst;
 548     if (!dst_dir.GetFilename())
 549       dst_dir.GetFilename() = src.GetLastPathComponent();
 550     Status error = rc_baton->platform_ptr->MakeDirectory(
 551         dst_dir, lldb::eFilePermissionsDirectoryDefault);
 552     if (error.Fail()) {
 553       rc_baton->error.SetErrorStringWithFormat(
 554           "unable to setup directory %s on remote end", dst_dir.GetCString());
 555       return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
 556     }
 557
 558     // now recurse
 559     std::string src_dir_path(src.GetPath());
 560
 561     // Make a filespec that only fills in the directory of a FileSpec so when
 562     // we enumerate we can quickly fill in the filename for dst copies
 563     FileSpec recurse_dst;
 564     recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
 565     RecurseCopyBaton rc_baton2 = {recurse_dst, rc_baton->platform_ptr,
 566                                   Status()};
 567     FileSystem::Instance().EnumerateDirectory(src_dir_path, true, true, true,
 568                                               RecurseCopy_Callback, &rc_baton2);
 569     if (rc_baton2.error.Fail()) {
 570       rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
 571       return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
 572     }
 573     return FileSystem::eEnumerateDirectoryResultNext;
 574   } break;
 575
 576   case fs::file_type::symlink_file: {
 577     // copy the file and keep going
 578     FileSpec dst_file = rc_baton->dst;
 579     if (!dst_file.GetFilename())
 580       dst_file.GetFilename() = src.GetFilename();
 581
 582     FileSpec src_resolved;
 583
 584     rc_baton->error = FileSystem::Instance().Readlink(src, src_resolved);
 585
 586     if (rc_baton->error.Fail())
 587       return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
 588
 589     rc_baton->error =
 590         rc_baton->platform_ptr->CreateSymlink(dst_file, src_resolved);
 591
 592     if (rc_baton->error.Fail())
 593       return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
 594
 595     return FileSystem::eEnumerateDirectoryResultNext;
 596   } break;
 597
 598   case fs::file_type::regular_file: {
 599     // copy the file and keep going
 600     FileSpec dst_file = rc_baton->dst;
 601     if (!dst_file.GetFilename())
 602       dst_file.GetFilename() = src.GetFilename();
 603     Status err = rc_baton->platform_ptr->PutFile(src, dst_file);
 604     if (err.Fail()) {
 605       rc_baton->error.SetErrorString(err.AsCString());
 606       return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
 607     }
 608     return FileSystem::eEnumerateDirectoryResultNext;
 609   } break;
 610
 611   default:
 612     rc_baton->error.SetErrorStringWithFormat(
 613         "invalid file detected during copy: %s", src.GetPath().c_str());
 614     return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
 615     break;
 616   }
 617   llvm_unreachable("Unhandled file_type!");
 618 }
 619
 620 Status Platform::Install(const FileSpec &src, const FileSpec &dst) {
 621   Status error;
 622
 623   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
 624   LLDB_LOGF(log, "Platform::Install (src='%s', dst='%s')",
 625             src.GetPath().c_str(), dst.GetPath().c_str());
 626   FileSpec fixed_dst(dst);
 627
 628   if (!fixed_dst.GetFilename())
 629     fixed_dst.GetFilename() = src.GetFilename();
 630
 631   FileSpec working_dir = GetWorkingDirectory();
 632
 633   if (dst) {
 634     if (dst.GetDirectory()) {
 635       const char first_dst_dir_char = dst.GetDirectory().GetCString()[0];
 636       if (first_dst_dir_char == '/' || first_dst_dir_char == '\\') {
 637         fixed_dst.GetDirectory() = dst.GetDirectory();
 638       }
 639       // If the fixed destination file doesn't have a directory yet, then we
 640       // must have a relative path. We will resolve this relative path against
 641       // the platform's working directory
 642       if (!fixed_dst.GetDirectory()) {
 643         FileSpec relative_spec;
 644         std::string path;
 645         if (working_dir) {
 646           relative_spec = working_dir;
 647           relative_spec.AppendPathComponent(dst.GetPath());
 648           fixed_dst.GetDirectory() = relative_spec.GetDirectory();
 649         } else {
 650           error.SetErrorStringWithFormat(
 651               "platform working directory must be valid for relative path '%s'",
 652               dst.GetPath().c_str());
 653           return error;
 654         }
 655       }
 656     } else {
 657       if (working_dir) {
 658         fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
 659       } else {
 660         error.SetErrorStringWithFormat(
 661             "platform working directory must be valid for relative path '%s'",
 662             dst.GetPath().c_str());
 663         return error;
 664       }
 665     }
 666   } else {
 667     if (working_dir) {
 668       fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
 669     } else {
 670       error.SetErrorStringWithFormat("platform working directory must be valid "
 671                                      "when destination directory is empty");
 672       return error;
 673     }
 674   }
 675
 676   LLDB_LOGF(log, "Platform::Install (src='%s', dst='%s') fixed_dst='%s'",
 677             src.GetPath().c_str(), dst.GetPath().c_str(),
 678             fixed_dst.GetPath().c_str());
 679
 680   if (GetSupportsRSync()) {
 681     error = PutFile(src, dst);
 682   } else {
 683     namespace fs = llvm::sys::fs;
 684     switch (fs::get_file_type(src.GetPath(), false)) {
 685     case fs::file_type::directory_file: {
 686       llvm::sys::fs::remove(fixed_dst.GetPath());
 687       uint32_t permissions = FileSystem::Instance().GetPermissions(src);
 688       if (permissions == 0)
 689         permissions = eFilePermissionsDirectoryDefault;
 690       error = MakeDirectory(fixed_dst, permissions);
 691       if (error.Success()) {
 692         // Make a filespec that only fills in the directory of a FileSpec so
 693         // when we enumerate we can quickly fill in the filename for dst copies
 694         FileSpec recurse_dst;
 695         recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
 696         std::string src_dir_path(src.GetPath());
 697         RecurseCopyBaton baton = {recurse_dst, this, Status()};
 698         FileSystem::Instance().EnumerateDirectory(
 699             src_dir_path, true, true, true, RecurseCopy_Callback, &baton);
 700         return baton.error;
 701       }
 702     } break;
 703
 704     case fs::file_type::regular_file:
 705       llvm::sys::fs::remove(fixed_dst.GetPath());
 706       error = PutFile(src, fixed_dst);
 707       break;
 708
 709     case fs::file_type::symlink_file: {
 710       llvm::sys::fs::remove(fixed_dst.GetPath());
 711       FileSpec src_resolved;
 712       error = FileSystem::Instance().Readlink(src, src_resolved);
 713       if (error.Success())
 714         error = CreateSymlink(dst, src_resolved);
 715     } break;
 716     case fs::file_type::fifo_file:
 717       error.SetErrorString("platform install doesn't handle pipes");
 718       break;
 719     case fs::file_type::socket_file:
 720       error.SetErrorString("platform install doesn't handle sockets");
 721       break;
 722     default:
 723       error.SetErrorString(
 724           "platform install doesn't handle non file or directory items");
 725       break;
 726     }
 727   }
 728   return error;
 729 }
 730
 731 bool Platform::SetWorkingDirectory(const FileSpec &file_spec) {
 732   if (IsHost()) {
 733     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
 734     LLDB_LOG(log, "{0}", file_spec);
 735     if (std::error_code ec = llvm::sys::fs::set_current_path(file_spec.GetPath())) {
 736       LLDB_LOG(log, "error: {0}", ec.message());
 737       return false;
 738     }
 739     return true;
 740   } else {
 741     m_working_dir.Clear();
 742     return SetRemoteWorkingDirectory(file_spec);
 743   }
 744 }
 745
 746 Status Platform::MakeDirectory(const FileSpec &file_spec,
 747                                uint32_t permissions) {
 748   if (IsHost())
 749     return llvm::sys::fs::create_directory(file_spec.GetPath(), permissions);
 750   else {
 751     Status error;
 752     error.SetErrorStringWithFormatv("remote platform {0} doesn't support {1}",
 753                                     GetPluginName(), LLVM_PRETTY_FUNCTION);
 754     return error;
 755   }
 756 }
 757
 758 Status Platform::GetFilePermissions(const FileSpec &file_spec,
 759                                     uint32_t &file_permissions) {
 760   if (IsHost()) {
 761     auto Value = llvm::sys::fs::getPermissions(file_spec.GetPath());
 762     if (Value)
 763       file_permissions = Value.get();
 764     return Status(Value.getError());
 765   } else {
 766     Status error;
 767     error.SetErrorStringWithFormatv("remote platform {0} doesn't support {1}",
 768                                     GetPluginName(), LLVM_PRETTY_FUNCTION);
 769     return error;
 770   }
 771 }
 772
 773 Status Platform::SetFilePermissions(const FileSpec &file_spec,
 774                                     uint32_t file_permissions) {
 775   if (IsHost()) {
 776     auto Perms = static_cast<llvm::sys::fs::perms>(file_permissions);
 777     return llvm::sys::fs::setPermissions(file_spec.GetPath(), Perms);
 778   } else {
 779     Status error;
 780     error.SetErrorStringWithFormatv("remote platform {0} doesn't support {1}",
 781                                     GetPluginName(), LLVM_PRETTY_FUNCTION);
 782     return error;
 783   }
 784 }
 785
 786 ConstString Platform::GetName() { return ConstString(GetPluginName()); }
 787
 788 const char *Platform::GetHostname() {
 789   if (IsHost())
 790     return "127.0.0.1";
 791
 792   if (m_name.empty())
 793     return nullptr;
 794   return m_name.c_str();
 795 }
 796
 797 ConstString Platform::GetFullNameForDylib(ConstString basename) {
 798   return basename;
 799 }
 800
 801 bool Platform::SetRemoteWorkingDirectory(const FileSpec &working_dir) {
 802   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
 803   LLDB_LOGF(log, "Platform::SetRemoteWorkingDirectory('%s')",
 804             working_dir.GetCString());
 805   m_working_dir = working_dir;
 806   return true;
 807 }
 808
 809 bool Platform::SetOSVersion(llvm::VersionTuple version) {
 810   if (IsHost()) {
 811     // We don't need anyone setting the OS version for the host platform, we
 812     // should be able to figure it out by calling HostInfo::GetOSVersion(...).
 813     return false;
 814   } else {
 815     // We have a remote platform, allow setting the target OS version if we
 816     // aren't connected, since if we are connected, we should be able to
 817     // request the remote OS version from the connected platform.
 818     if (IsConnected())
 819       return false;
 820     else {
 821       // We aren't connected and we might want to set the OS version ahead of
 822       // time before we connect so we can peruse files and use a local SDK or
 823       // PDK cache of support files to disassemble or do other things.
 824       m_os_version = version;
 825       return true;
 826     }
 827   }
 828   return false;
 829 }
 830
 831 Status
 832 Platform::ResolveExecutable(const ModuleSpec &module_spec,
 833                             lldb::ModuleSP &exe_module_sp,
 834                             const FileSpecList *module_search_paths_ptr) {
 835   Status error;
 836
 837   if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
 838     if (module_spec.GetArchitecture().IsValid()) {
 839       error = ModuleList::GetSharedModule(module_spec, exe_module_sp,
 840                                           module_search_paths_ptr, nullptr,
 841                                           nullptr);
 842     } else {
 843       // No valid architecture was specified, ask the platform for the
 844       // architectures that we should be using (in the correct order) and see
 845       // if we can find a match that way
 846       ModuleSpec arch_module_spec(module_spec);
 847       for (const ArchSpec &arch : GetSupportedArchitectures()) {
 848         arch_module_spec.GetArchitecture() = arch;
 849         error = ModuleList::GetSharedModule(arch_module_spec, exe_module_sp,
 850                                             module_search_paths_ptr, nullptr,
 851                                             nullptr);
 852         // Did we find an executable using one of the
 853         if (error.Success() && exe_module_sp)
 854           break;
 855       }
 856     }
 857   } else {
 858     error.SetErrorStringWithFormat(
 859         "'%s' does not exist", module_spec.GetFileSpec().GetPath().c_str());
 860   }
 861   return error;
 862 }
 863
 864 Status
 865 Platform::ResolveRemoteExecutable(const ModuleSpec &module_spec,
 866                             lldb::ModuleSP &exe_module_sp,
 867                             const FileSpecList *module_search_paths_ptr) {
 868   Status error;
 869
 870   // We may connect to a process and use the provided executable (Don't use
 871   // local $PATH).
 872   ModuleSpec resolved_module_spec(module_spec);
 873
 874   // Resolve any executable within a bundle on MacOSX
 875   Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
 876
 877   if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()) ||
 878       module_spec.GetUUID().IsValid()) {
 879     if (resolved_module_spec.GetArchitecture().IsValid() ||
 880         resolved_module_spec.GetUUID().IsValid()) {
 881       error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
 882                                           module_search_paths_ptr, nullptr,
 883                                           nullptr);
 884
 885       if (exe_module_sp && exe_module_sp->GetObjectFile())
 886         return error;
 887       exe_module_sp.reset();
 888     }
 889     // No valid architecture was specified or the exact arch wasn't found so
 890     // ask the platform for the architectures that we should be using (in the
 891     // correct order) and see if we can find a match that way
 892     StreamString arch_names;
 893     llvm::ListSeparator LS;
 894     for (const ArchSpec &arch : GetSupportedArchitectures()) {
 895       resolved_module_spec.GetArchitecture() = arch;
 896       error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
 897                                           module_search_paths_ptr, nullptr,
 898                                           nullptr);
 899       // Did we find an executable using one of the
 900       if (error.Success()) {
 901         if (exe_module_sp && exe_module_sp->GetObjectFile())
 902           break;
 903         else
 904           error.SetErrorToGenericError();
 905       }
 906
 907       arch_names << LS << arch.GetArchitectureName();
 908     }
 909
 910     if (error.Fail() || !exe_module_sp) {
 911       if (FileSystem::Instance().Readable(resolved_module_spec.GetFileSpec())) {
 912         error.SetErrorStringWithFormatv(
 913             "'{0}' doesn't contain any '{1}' platform architectures: {2}",
 914             resolved_module_spec.GetFileSpec(), GetPluginName(),
 915             arch_names.GetData());
 916       } else {
 917         error.SetErrorStringWithFormatv("'{0}' is not readable",
 918                                         resolved_module_spec.GetFileSpec());
 919       }
 920     }
 921   } else {
 922     error.SetErrorStringWithFormatv("'{0}' does not exist",
 923                                     resolved_module_spec.GetFileSpec());
 924   }
 925
 926   return error;
 927 }
 928
 929 Status Platform::ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec,
 930                                    FileSpec &sym_file) {
 931   Status error;
 932   if (FileSystem::Instance().Exists(sym_spec.GetSymbolFileSpec()))
 933     sym_file = sym_spec.GetSymbolFileSpec();
 934   else
 935     error.SetErrorString("unable to resolve symbol file");
 936   return error;
 937 }
 938
 939 bool Platform::ResolveRemotePath(const FileSpec &platform_path,
 940                                  FileSpec &resolved_platform_path) {
 941   resolved_platform_path = platform_path;
 942   FileSystem::Instance().Resolve(resolved_platform_path);
 943   return true;
 944 }
 945
 946 const ArchSpec &Platform::GetSystemArchitecture() {
 947   if (IsHost()) {
 948     if (!m_system_arch.IsValid()) {
 949       // We have a local host platform
 950       m_system_arch = HostInfo::GetArchitecture();
 951       m_system_arch_set_while_connected = m_system_arch.IsValid();
 952     }
 953   } else {
 954     // We have a remote platform. We can only fetch the remote system
 955     // architecture if we are connected, and we don't want to do it more than
 956     // once.
 957
 958     const bool is_connected = IsConnected();
 959
 960     bool fetch = false;
 961     if (m_system_arch.IsValid()) {
 962       // We have valid OS version info, check to make sure it wasn't manually
 963       // set prior to connecting. If it was manually set prior to connecting,
 964       // then lets fetch the actual OS version info if we are now connected.
 965       if (is_connected && !m_system_arch_set_while_connected)
 966         fetch = true;
 967     } else {
 968       // We don't have valid OS version info, fetch it if we are connected
 969       fetch = is_connected;
 970     }
 971
 972     if (fetch) {
 973       m_system_arch = GetRemoteSystemArchitecture();
 974       m_system_arch_set_while_connected = m_system_arch.IsValid();
 975     }
 976   }
 977   return m_system_arch;
 978 }
 979
 980 ArchSpec Platform::GetAugmentedArchSpec(llvm::StringRef triple) {
 981   if (triple.empty())
 982     return ArchSpec();
 983   llvm::Triple normalized_triple(llvm::Triple::normalize(triple));
 984   if (!ArchSpec::ContainsOnlyArch(normalized_triple))
 985     return ArchSpec(triple);
 986
 987   if (auto kind = HostInfo::ParseArchitectureKind(triple))
 988     return HostInfo::GetArchitecture(*kind);
 989
 990   ArchSpec compatible_arch;
 991   ArchSpec raw_arch(triple);
 992   if (!IsCompatibleArchitecture(raw_arch, false, &compatible_arch))
 993     return raw_arch;
 994
 995   if (!compatible_arch.IsValid())
 996     return ArchSpec(normalized_triple);
 997
 998   const llvm::Triple &compatible_triple = compatible_arch.GetTriple();
 999   if (normalized_triple.getVendorName().empty())
1000     normalized_triple.setVendor(compatible_triple.getVendor());
1001   if (normalized_triple.getOSName().empty())
1002     normalized_triple.setOS(compatible_triple.getOS());
1003   if (normalized_triple.getEnvironmentName().empty())
1004     normalized_triple.setEnvironment(compatible_triple.getEnvironment());
1005   return ArchSpec(normalized_triple);
1006 }
1007
1008 Status Platform::ConnectRemote(Args &args) {
1009   Status error;
1010   if (IsHost())
1011     error.SetErrorStringWithFormatv(
1012         "The currently selected platform ({0}) is "
1013         "the host platform and is always connected.",
1014         GetPluginName());
1015   else
1016     error.SetErrorStringWithFormatv(
1017         "Platform::ConnectRemote() is not supported by {0}", GetPluginName());
1018   return error;
1019 }
1020
1021 Status Platform::DisconnectRemote() {
1022   Status error;
1023   if (IsHost())
1024     error.SetErrorStringWithFormatv(
1025         "The currently selected platform ({0}) is "
1026         "the host platform and is always connected.",
1027         GetPluginName());
1028   else
1029     error.SetErrorStringWithFormatv(
1030         "Platform::DisconnectRemote() is not supported by {0}",
1031         GetPluginName());
1032   return error;
1033 }
1034
1035 bool Platform::GetProcessInfo(lldb::pid_t pid,
1036                               ProcessInstanceInfo &process_info) {
1037   // Take care of the host case so that each subclass can just call this
1038   // function to get the host functionality.
1039   if (IsHost())
1040     return Host::GetProcessInfo(pid, process_info);
1041   return false;
1042 }
1043
1044 uint32_t Platform::FindProcesses(const ProcessInstanceInfoMatch &match_info,
1045                                  ProcessInstanceInfoList &process_infos) {
1046   // Take care of the host case so that each subclass can just call this
1047   // function to get the host functionality.
1048   uint32_t match_count = 0;
1049   if (IsHost())
1050     match_count = Host::FindProcesses(match_info, process_infos);
1051   return match_count;
1052 }
1053
1054 Status Platform::LaunchProcess(ProcessLaunchInfo &launch_info) {
1055   Status error;
1056   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1057   LLDB_LOGF(log, "Platform::%s()", __FUNCTION__);
1058
1059   // Take care of the host case so that each subclass can just call this
1060   // function to get the host functionality.
1061   if (IsHost()) {
1062     if (::getenv("LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY"))
1063       launch_info.GetFlags().Set(eLaunchFlagLaunchInTTY);
1064
1065     if (launch_info.GetFlags().Test(eLaunchFlagLaunchInShell)) {
1066       const bool will_debug = launch_info.GetFlags().Test(eLaunchFlagDebug);
1067       const bool first_arg_is_full_shell_command = false;
1068       uint32_t num_resumes = GetResumeCountForLaunchInfo(launch_info);
1069       if (log) {
1070         const FileSpec &shell = launch_info.GetShell();
1071         std::string shell_str = (shell) ? shell.GetPath() : "<null>";
1072         LLDB_LOGF(log,
1073                   "Platform::%s GetResumeCountForLaunchInfo() returned %" PRIu32
1074                   ", shell is '%s'",
1075                   __FUNCTION__, num_resumes, shell_str.c_str());
1076       }
1077
1078       if (!launch_info.ConvertArgumentsForLaunchingInShell(
1079               error, will_debug, first_arg_is_full_shell_command, num_resumes))
1080         return error;
1081     } else if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments)) {
1082       error = ShellExpandArguments(launch_info);
1083       if (error.Fail()) {
1084         error.SetErrorStringWithFormat("shell expansion failed (reason: %s). "
1085                                        "consider launching with 'process "
1086                                        "launch'.",
1087                                        error.AsCString("unknown"));
1088         return error;
1089       }
1090     }
1091
1092     LLDB_LOGF(log, "Platform::%s final launch_info resume count: %" PRIu32,
1093               __FUNCTION__, launch_info.GetResumeCount());
1094
1095     error = Host::LaunchProcess(launch_info);
1096   } else
1097     error.SetErrorString(
1098         "base lldb_private::Platform class can't launch remote processes");
1099   return error;
1100 }
1101
1102 Status Platform::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
1103   if (IsHost())
1104     return Host::ShellExpandArguments(launch_info);
1105   return Status("base lldb_private::Platform class can't expand arguments");
1106 }
1107
1108 Status Platform::KillProcess(const lldb::pid_t pid) {
1109   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1110   LLDB_LOGF(log, "Platform::%s, pid %" PRIu64, __FUNCTION__, pid);
1111
1112   if (!IsHost()) {
1113     return Status(
1114         "base lldb_private::Platform class can't kill remote processes");
1115   }
1116   Host::Kill(pid, SIGKILL);
1117   return Status();
1118 }
1119
1120 lldb::ProcessSP Platform::DebugProcess(ProcessLaunchInfo &launch_info,
1121                                        Debugger &debugger, Target &target,
1122                                        Status &error) {
1123   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1124   LLDB_LOG(log, "target = {0})", &target);
1125
1126   ProcessSP process_sp;
1127   // Make sure we stop at the entry point
1128   launch_info.GetFlags().Set(eLaunchFlagDebug);
1129   // We always launch the process we are going to debug in a separate process
1130   // group, since then we can handle ^C interrupts ourselves w/o having to
1131   // worry about the target getting them as well.
1132   launch_info.SetLaunchInSeparateProcessGroup(true);
1133
1134   // Allow any StructuredData process-bound plugins to adjust the launch info
1135   // if needed
1136   size_t i = 0;
1137   bool iteration_complete = false;
1138   // Note iteration can't simply go until a nullptr callback is returned, as it
1139   // is valid for a plugin to not supply a filter.
1140   auto get_filter_func = PluginManager::GetStructuredDataFilterCallbackAtIndex;
1141   for (auto filter_callback = get_filter_func(i, iteration_complete);
1142        !iteration_complete;
1143        filter_callback = get_filter_func(++i, iteration_complete)) {
1144     if (filter_callback) {
1145       // Give this ProcessLaunchInfo filter a chance to adjust the launch info.
1146       error = (*filter_callback)(launch_info, &target);
1147       if (!error.Success()) {
1148         LLDB_LOGF(log,
1149                   "Platform::%s() StructuredDataPlugin launch "
1150                   "filter failed.",
1151                   __FUNCTION__);
1152         return process_sp;
1153       }
1154     }
1155   }
1156
1157   error = LaunchProcess(launch_info);
1158   if (error.Success()) {
1159     LLDB_LOGF(log,
1160               "Platform::%s LaunchProcess() call succeeded (pid=%" PRIu64 ")",
1161               __FUNCTION__, launch_info.GetProcessID());
1162     if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) {
1163       ProcessAttachInfo attach_info(launch_info);
1164       process_sp = Attach(attach_info, debugger, &target, error);
1165       if (process_sp) {
1166         LLDB_LOG(log, "Attach() succeeded, Process plugin: {0}",
1167                  process_sp->GetPluginName());
1168         launch_info.SetHijackListener(attach_info.GetHijackListener());
1169
1170         // Since we attached to the process, it will think it needs to detach
1171         // if the process object just goes away without an explicit call to
1172         // Process::Kill() or Process::Detach(), so let it know to kill the
1173         // process if this happens.
1174         process_sp->SetShouldDetach(false);
1175
1176         // If we didn't have any file actions, the pseudo terminal might have
1177         // been used where the secondary side was given as the file to open for
1178         // stdin/out/err after we have already opened the primary so we can
1179         // read/write stdin/out/err.
1180         int pty_fd = launch_info.GetPTY().ReleasePrimaryFileDescriptor();
1181         if (pty_fd != PseudoTerminal::invalid_fd) {
1182           process_sp->SetSTDIOFileDescriptor(pty_fd);
1183         }
1184       } else {
1185         LLDB_LOGF(log, "Platform::%s Attach() failed: %s", __FUNCTION__,
1186                   error.AsCString());
1187       }
1188     } else {
1189       LLDB_LOGF(log,
1190                 "Platform::%s LaunchProcess() returned launch_info with "
1191                 "invalid process id",
1192                 __FUNCTION__);
1193     }
1194   } else {
1195     LLDB_LOGF(log, "Platform::%s LaunchProcess() failed: %s", __FUNCTION__,
1196               error.AsCString());
1197   }
1198
1199   return process_sp;
1200 }
1201
1202 lldb::PlatformSP
1203 Platform::GetPlatformForArchitecture(const ArchSpec &arch,
1204                                      ArchSpec *platform_arch_ptr) {
1205   lldb::PlatformSP platform_sp;
1206   Status error;
1207   if (arch.IsValid())
1208     platform_sp = Platform::Create(arch, platform_arch_ptr, error);
1209   return platform_sp;
1210 }
1211
1212 std::vector<ArchSpec>
1213 Platform::CreateArchList(llvm::ArrayRef<llvm::Triple::ArchType> archs,
1214                          llvm::Triple::OSType os) {
1215   std::vector<ArchSpec> list;
1216   for(auto arch : archs) {
1217     llvm::Triple triple;
1218     triple.setArch(arch);
1219     triple.setOS(os);
1220     list.push_back(ArchSpec(triple));
1221   }
1222   return list;
1223 }
1224
1225 /// Lets a platform answer if it is compatible with a given
1226 /// architecture and the target triple contained within.
1227 bool Platform::IsCompatibleArchitecture(const ArchSpec &arch,
1228                                         bool exact_arch_match,
1229                                         ArchSpec *compatible_arch_ptr) {
1230   // If the architecture is invalid, we must answer true...
1231   if (arch.IsValid()) {
1232     ArchSpec platform_arch;
1233     auto match = exact_arch_match ? &ArchSpec::IsExactMatch
1234                                   : &ArchSpec::IsCompatibleMatch;
1235     for (const ArchSpec &platform_arch : GetSupportedArchitectures()) {
1236       if ((arch.*match)(platform_arch)) {
1237         if (compatible_arch_ptr)
1238           *compatible_arch_ptr = platform_arch;
1239         return true;
1240       }
1241     }
1242   }
1243   if (compatible_arch_ptr)
1244     compatible_arch_ptr->Clear();
1245   return false;
1246 }
1247
1248 Status Platform::PutFile(const FileSpec &source, const FileSpec &destination,
1249                          uint32_t uid, uint32_t gid) {
1250   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1251   LLDB_LOGF(log, "[PutFile] Using block by block transfer....\n");
1252
1253   auto source_open_options =
1254       File::eOpenOptionReadOnly | File::eOpenOptionCloseOnExec;
1255   namespace fs = llvm::sys::fs;
1256   if (fs::is_symlink_file(source.GetPath()))
1257     source_open_options |= File::eOpenOptionDontFollowSymlinks;
1258
1259   auto source_file = FileSystem::Instance().Open(source, source_open_options,
1260                                                  lldb::eFilePermissionsUserRW);
1261   if (!source_file)
1262     return Status(source_file.takeError());
1263   Status error;
1264   uint32_t permissions = source_file.get()->GetPermissions(error);
1265   if (permissions == 0)
1266     permissions = lldb::eFilePermissionsFileDefault;
1267
1268   lldb::user_id_t dest_file = OpenFile(
1269       destination, File::eOpenOptionCanCreate | File::eOpenOptionWriteOnly |
1270                        File::eOpenOptionTruncate | File::eOpenOptionCloseOnExec,
1271       permissions, error);
1272   LLDB_LOGF(log, "dest_file = %" PRIu64 "\n", dest_file);
1273
1274   if (error.Fail())
1275     return error;
1276   if (dest_file == UINT64_MAX)
1277     return Status("unable to open target file");
1278   lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024 * 16, 0));
1279   uint64_t offset = 0;
1280   for (;;) {
1281     size_t bytes_read = buffer_sp->GetByteSize();
1282     error = source_file.get()->Read(buffer_sp->GetBytes(), bytes_read);
1283     if (error.Fail() || bytes_read == 0)
1284       break;
1285
1286     const uint64_t bytes_written =
1287         WriteFile(dest_file, offset, buffer_sp->GetBytes(), bytes_read, error);
1288     if (error.Fail())
1289       break;
1290
1291     offset += bytes_written;
1292     if (bytes_written != bytes_read) {
1293       // We didn't write the correct number of bytes, so adjust the file
1294       // position in the source file we are reading from...
1295       source_file.get()->SeekFromStart(offset);
1296     }
1297   }
1298   CloseFile(dest_file, error);
1299
1300   if (uid == UINT32_MAX && gid == UINT32_MAX)
1301     return error;
1302
1303   // TODO: ChownFile?
1304
1305   return error;
1306 }
1307
1308 Status Platform::GetFile(const FileSpec &source, const FileSpec &destination) {
1309   Status error("unimplemented");
1310   return error;
1311 }
1312
1313 Status
1314 Platform::CreateSymlink(const FileSpec &src, // The name of the link is in src
1315                         const FileSpec &dst) // The symlink points to dst
1316 {
1317   Status error("unimplemented");
1318   return error;
1319 }
1320
1321 bool Platform::GetFileExists(const lldb_private::FileSpec &file_spec) {
1322   return false;
1323 }
1324
1325 Status Platform::Unlink(const FileSpec &path) {
1326   Status error("unimplemented");
1327   return error;
1328 }
1329
1330 MmapArgList Platform::GetMmapArgumentList(const ArchSpec &arch, addr_t addr,
1331                                           addr_t length, unsigned prot,
1332                                           unsigned flags, addr_t fd,
1333                                           addr_t offset) {
1334   uint64_t flags_platform = 0;
1335   if (flags & eMmapFlagsPrivate)
1336     flags_platform |= MAP_PRIVATE;
1337   if (flags & eMmapFlagsAnon)
1338     flags_platform |= MAP_ANON;
1339
1340   MmapArgList args({addr, length, prot, flags_platform, fd, offset});
1341   return args;
1342 }
1343
1344 lldb_private::Status Platform::RunShellCommand(
1345     llvm::StringRef command,
1346     const FileSpec &
1347         working_dir, // Pass empty FileSpec to use the current working directory
1348     int *status_ptr, // Pass nullptr if you don't want the process exit status
1349     int *signo_ptr, // Pass nullptr if you don't want the signal that caused the
1350                     // process to exit
1351     std::string
1352         *command_output, // Pass nullptr if you don't want the command output
1353     const Timeout<std::micro> &timeout) {
1354   return RunShellCommand(llvm::StringRef(), command, working_dir, status_ptr,
1355                          signo_ptr, command_output, timeout);
1356 }
1357
1358 lldb_private::Status Platform::RunShellCommand(
1359     llvm::StringRef shell,   // Pass empty if you want to use the default
1360                              // shell interpreter
1361     llvm::StringRef command, // Shouldn't be empty
1362     const FileSpec &
1363         working_dir, // Pass empty FileSpec to use the current working directory
1364     int *status_ptr, // Pass nullptr if you don't want the process exit status
1365     int *signo_ptr, // Pass nullptr if you don't want the signal that caused the
1366                     // process to exit
1367     std::string
1368         *command_output, // Pass nullptr if you don't want the command output
1369     const Timeout<std::micro> &timeout) {
1370   if (IsHost())
1371     return Host::RunShellCommand(shell, command, working_dir, status_ptr,
1372                                  signo_ptr, command_output, timeout);
1373   else
1374     return Status("unimplemented");
1375 }
1376
1377 bool Platform::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
1378                             uint64_t &high) {
1379   if (!IsHost())
1380     return false;
1381   auto Result = llvm::sys::fs::md5_contents(file_spec.GetPath());
1382   if (!Result)
1383     return false;
1384   std::tie(high, low) = Result->words();
1385   return true;
1386 }
1387
1388 void Platform::SetLocalCacheDirectory(const char *local) {
1389   m_local_cache_directory.assign(local);
1390 }
1391
1392 const char *Platform::GetLocalCacheDirectory() {
1393   return m_local_cache_directory.c_str();
1394 }
1395
1396 static constexpr OptionDefinition g_rsync_option_table[] = {
1397     {LLDB_OPT_SET_ALL, false, "rsync", 'r', OptionParser::eNoArgument, nullptr,
1398      {}, 0, eArgTypeNone, "Enable rsync."},
1399     {LLDB_OPT_SET_ALL, false, "rsync-opts", 'R',
1400      OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
1401      "Platform-specific options required for rsync to work."},
1402     {LLDB_OPT_SET_ALL, false, "rsync-prefix", 'P',
1403      OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
1404      "Platform-specific rsync prefix put before the remote path."},
1405     {LLDB_OPT_SET_ALL, false, "ignore-remote-hostname", 'i',
1406      OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone,
1407      "Do not automatically fill in the remote hostname when composing the "
1408      "rsync command."},
1409 };
1410
1411 static constexpr OptionDefinition g_ssh_option_table[] = {
1412     {LLDB_OPT_SET_ALL, false, "ssh", 's', OptionParser::eNoArgument, nullptr,
1413      {}, 0, eArgTypeNone, "Enable SSH."},
1414     {LLDB_OPT_SET_ALL, false, "ssh-opts", 'S', OptionParser::eRequiredArgument,
1415      nullptr, {}, 0, eArgTypeCommandName,
1416      "Platform-specific options required for SSH to work."},
1417 };
1418
1419 static constexpr OptionDefinition g_caching_option_table[] = {
1420     {LLDB_OPT_SET_ALL, false, "local-cache-dir", 'c',
1421      OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypePath,
1422      "Path in which to store local copies of files."},
1423 };
1424
1425 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformRSync::GetDefinitions() {
1426   return llvm::makeArrayRef(g_rsync_option_table);
1427 }
1428
1429 void OptionGroupPlatformRSync::OptionParsingStarting(
1430     ExecutionContext *execution_context) {
1431   m_rsync = false;
1432   m_rsync_opts.clear();
1433   m_rsync_prefix.clear();
1434   m_ignores_remote_hostname = false;
1435 }
1436
1437 lldb_private::Status
1438 OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
1439                                          llvm::StringRef option_arg,
1440                                          ExecutionContext *execution_context) {
1441   Status error;
1442   char short_option = (char)GetDefinitions()[option_idx].short_option;
1443   switch (short_option) {
1444   case 'r':
1445     m_rsync = true;
1446     break;
1447
1448   case 'R':
1449     m_rsync_opts.assign(std::string(option_arg));
1450     break;
1451
1452   case 'P':
1453     m_rsync_prefix.assign(std::string(option_arg));
1454     break;
1455
1456   case 'i':
1457     m_ignores_remote_hostname = true;
1458     break;
1459
1460   default:
1461     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
1462     break;
1463   }
1464
1465   return error;
1466 }
1467
1468 lldb::BreakpointSP
1469 Platform::SetThreadCreationBreakpoint(lldb_private::Target &target) {
1470   return lldb::BreakpointSP();
1471 }
1472
1473 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformSSH::GetDefinitions() {
1474   return llvm::makeArrayRef(g_ssh_option_table);
1475 }
1476
1477 void OptionGroupPlatformSSH::OptionParsingStarting(
1478     ExecutionContext *execution_context) {
1479   m_ssh = false;
1480   m_ssh_opts.clear();
1481 }
1482
1483 lldb_private::Status
1484 OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
1485                                        llvm::StringRef option_arg,
1486                                        ExecutionContext *execution_context) {
1487   Status error;
1488   char short_option = (char)GetDefinitions()[option_idx].short_option;
1489   switch (short_option) {
1490   case 's':
1491     m_ssh = true;
1492     break;
1493
1494   case 'S':
1495     m_ssh_opts.assign(std::string(option_arg));
1496     break;
1497
1498   default:
1499     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
1500     break;
1501   }
1502
1503   return error;
1504 }
1505
1506 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformCaching::GetDefinitions() {
1507   return llvm::makeArrayRef(g_caching_option_table);
1508 }
1509
1510 void OptionGroupPlatformCaching::OptionParsingStarting(
1511     ExecutionContext *execution_context) {
1512   m_cache_dir.clear();
1513 }
1514
1515 lldb_private::Status OptionGroupPlatformCaching::SetOptionValue(
1516     uint32_t option_idx, llvm::StringRef option_arg,
1517     ExecutionContext *execution_context) {
1518   Status error;
1519   char short_option = (char)GetDefinitions()[option_idx].short_option;
1520   switch (short_option) {
1521   case 'c':
1522     m_cache_dir.assign(std::string(option_arg));
1523     break;
1524
1525   default:
1526     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
1527     break;
1528   }
1529
1530   return error;
1531 }
1532
1533 Environment Platform::GetEnvironment() { return Environment(); }
1534
1535 const std::vector<ConstString> &Platform::GetTrapHandlerSymbolNames() {
1536   if (!m_calculated_trap_handlers) {
1537     std::lock_guard<std::mutex> guard(m_mutex);
1538     if (!m_calculated_trap_handlers) {
1539       CalculateTrapHandlerSymbolNames();
1540       m_calculated_trap_handlers = true;
1541     }
1542   }
1543   return m_trap_handlers;
1544 }
1545
1546 Status
1547 Platform::GetCachedExecutable(ModuleSpec &module_spec,
1548                               lldb::ModuleSP &module_sp,
1549                               const FileSpecList *module_search_paths_ptr) {
1550   FileSpec platform_spec = module_spec.GetFileSpec();
1551   Status error = GetRemoteSharedModule(
1552       module_spec, nullptr, module_sp,
1553       [&](const ModuleSpec &spec) {
1554         return ResolveRemoteExecutable(spec, module_sp,
1555                                        module_search_paths_ptr);
1556       },
1557       nullptr);
1558   if (error.Success()) {
1559     module_spec.GetFileSpec() = module_sp->GetFileSpec();
1560     module_spec.GetPlatformFileSpec() = platform_spec;
1561   }
1562
1563   return error;
1564 }
1565
1566 Status Platform::GetRemoteSharedModule(const ModuleSpec &module_spec,
1567                                        Process *process,
1568                                        lldb::ModuleSP &module_sp,
1569                                        const ModuleResolver &module_resolver,
1570                                        bool *did_create_ptr) {
1571   // Get module information from a target.
1572   ModuleSpec resolved_module_spec;
1573   bool got_module_spec = false;
1574   if (process) {
1575     // Try to get module information from the process
1576     if (process->GetModuleSpec(module_spec.GetFileSpec(),
1577                                module_spec.GetArchitecture(),
1578                                resolved_module_spec)) {
1579       if (!module_spec.GetUUID().IsValid() ||
1580           module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
1581         got_module_spec = true;
1582       }
1583     }
1584   }
1585
1586   if (!module_spec.GetArchitecture().IsValid()) {
1587     Status error;
1588     // No valid architecture was specified, ask the platform for the
1589     // architectures that we should be using (in the correct order) and see if
1590     // we can find a match that way
1591     ModuleSpec arch_module_spec(module_spec);
1592     for (const ArchSpec &arch : GetSupportedArchitectures()) {
1593       arch_module_spec.GetArchitecture() = arch;
1594       error = ModuleList::GetSharedModule(arch_module_spec, module_sp, nullptr,
1595                                           nullptr, nullptr);
1596       // Did we find an executable using one of the
1597       if (error.Success() && module_sp)
1598         break;
1599     }
1600     if (module_sp) {
1601       resolved_module_spec = arch_module_spec;
1602       got_module_spec = true;
1603     }
1604   }
1605
1606   if (!got_module_spec) {
1607     // Get module information from a target.
1608     if (GetModuleSpec(module_spec.GetFileSpec(), module_spec.GetArchitecture(),
1609                       resolved_module_spec)) {
1610       if (!module_spec.GetUUID().IsValid() ||
1611           module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
1612         got_module_spec = true;
1613       }
1614     }
1615   }
1616
1617   if (!got_module_spec) {
1618     // Fall back to the given module resolver, which may have its own
1619     // search logic.
1620     return module_resolver(module_spec);
1621   }
1622
1623   // If we are looking for a specific UUID, make sure resolved_module_spec has
1624   // the same one before we search.
1625   if (module_spec.GetUUID().IsValid()) {
1626     resolved_module_spec.GetUUID() = module_spec.GetUUID();
1627   }
1628
1629   // Trying to find a module by UUID on local file system.
1630   const auto error = module_resolver(resolved_module_spec);
1631   if (error.Fail()) {
1632     if (GetCachedSharedModule(resolved_module_spec, module_sp, did_create_ptr))
1633       return Status();
1634   }
1635
1636   return error;
1637 }
1638
1639 bool Platform::GetCachedSharedModule(const ModuleSpec &module_spec,
1640                                      lldb::ModuleSP &module_sp,
1641                                      bool *did_create_ptr) {
1642   if (IsHost() || !GetGlobalPlatformProperties().GetUseModuleCache() ||
1643       !GetGlobalPlatformProperties().GetModuleCacheDirectory())
1644     return false;
1645
1646   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
1647
1648   // Check local cache for a module.
1649   auto error = m_module_cache->GetAndPut(
1650       GetModuleCacheRoot(), GetCacheHostname(), module_spec,
1651       [this](const ModuleSpec &module_spec,
1652              const FileSpec &tmp_download_file_spec) {
1653         return DownloadModuleSlice(
1654             module_spec.GetFileSpec(), module_spec.GetObjectOffset(),
1655             module_spec.GetObjectSize(), tmp_download_file_spec);
1656
1657       },
1658       [this](const ModuleSP &module_sp,
1659              const FileSpec &tmp_download_file_spec) {
1660         return DownloadSymbolFile(module_sp, tmp_download_file_spec);
1661       },
1662       module_sp, did_create_ptr);
1663   if (error.Success())
1664     return true;
1665
1666   LLDB_LOGF(log, "Platform::%s - module %s not found in local cache: %s",
1667             __FUNCTION__, module_spec.GetUUID().GetAsString().c_str(),
1668             error.AsCString());
1669   return false;
1670 }
1671
1672 Status Platform::DownloadModuleSlice(const FileSpec &src_file_spec,
1673                                      const uint64_t src_offset,
1674                                      const uint64_t src_size,
1675                                      const FileSpec &dst_file_spec) {
1676   Status error;
1677
1678   std::error_code EC;
1679   llvm::raw_fd_ostream dst(dst_file_spec.GetPath(), EC, llvm::sys::fs::OF_None);
1680   if (EC) {
1681     error.SetErrorStringWithFormat("unable to open destination file: %s",
1682                                    dst_file_spec.GetPath().c_str());
1683     return error;
1684   }
1685
1686   auto src_fd = OpenFile(src_file_spec, File::eOpenOptionReadOnly,
1687                          lldb::eFilePermissionsFileDefault, error);
1688
1689   if (error.Fail()) {
1690     error.SetErrorStringWithFormat("unable to open source file: %s",
1691                                    error.AsCString());
1692     return error;
1693   }
1694
1695   std::vector<char> buffer(1024);
1696   auto offset = src_offset;
1697   uint64_t total_bytes_read = 0;
1698   while (total_bytes_read < src_size) {
1699     const auto to_read = std::min(static_cast<uint64_t>(buffer.size()),
1700                                   src_size - total_bytes_read);
1701     const uint64_t n_read =
1702         ReadFile(src_fd, offset, &buffer[0], to_read, error);
1703     if (error.Fail())
1704       break;
1705     if (n_read == 0) {
1706       error.SetErrorString("read 0 bytes");
1707       break;
1708     }
1709     offset += n_read;
1710     total_bytes_read += n_read;
1711     dst.write(&buffer[0], n_read);
1712   }
1713
1714   Status close_error;
1715   CloseFile(src_fd, close_error); // Ignoring close error.
1716
1717   return error;
1718 }
1719
1720 Status Platform::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
1721                                     const FileSpec &dst_file_spec) {
1722   return Status(
1723       "Symbol file downloading not supported by the default platform.");
1724 }
1725
1726 FileSpec Platform::GetModuleCacheRoot() {
1727   auto dir_spec = GetGlobalPlatformProperties().GetModuleCacheDirectory();
1728   dir_spec.AppendPathComponent(GetName().AsCString());
1729   return dir_spec;
1730 }
1731
1732 const char *Platform::GetCacheHostname() { return GetHostname(); }
1733
1734 const UnixSignalsSP &Platform::GetRemoteUnixSignals() {
1735   static const auto s_default_unix_signals_sp = std::make_shared<UnixSignals>();
1736   return s_default_unix_signals_sp;
1737 }
1738
1739 UnixSignalsSP Platform::GetUnixSignals() {
1740   if (IsHost())
1741     return UnixSignals::CreateForHost();
1742   return GetRemoteUnixSignals();
1743 }
1744
1745 uint32_t Platform::LoadImage(lldb_private::Process *process,
1746                              const lldb_private::FileSpec &local_file,
1747                              const lldb_private::FileSpec &remote_file,
1748                              lldb_private::Status &error) {
1749   if (local_file && remote_file) {
1750     // Both local and remote file was specified. Install the local file to the
1751     // given location.
1752     if (IsRemote() || local_file != remote_file) {
1753       error = Install(local_file, remote_file);
1754       if (error.Fail())
1755         return LLDB_INVALID_IMAGE_TOKEN;
1756     }
1757     return DoLoadImage(process, remote_file, nullptr, error);
1758   }
1759
1760   if (local_file) {
1761     // Only local file was specified. Install it to the current working
1762     // directory.
1763     FileSpec target_file = GetWorkingDirectory();
1764     target_file.AppendPathComponent(local_file.GetFilename().AsCString());
1765     if (IsRemote() || local_file != target_file) {
1766       error = Install(local_file, target_file);
1767       if (error.Fail())
1768         return LLDB_INVALID_IMAGE_TOKEN;
1769     }
1770     return DoLoadImage(process, target_file, nullptr, error);
1771   }
1772
1773   if (remote_file) {
1774     // Only remote file was specified so we don't have to do any copying
1775     return DoLoadImage(process, remote_file, nullptr, error);
1776   }
1777
1778   error.SetErrorString("Neither local nor remote file was specified");
1779   return LLDB_INVALID_IMAGE_TOKEN;
1780 }
1781
1782 uint32_t Platform::DoLoadImage(lldb_private::Process *process,
1783                                const lldb_private::FileSpec &remote_file,
1784                                const std::vector<std::string> *paths,
1785                                lldb_private::Status &error,
1786                                lldb_private::FileSpec *loaded_image) {
1787   error.SetErrorString("LoadImage is not supported on the current platform");
1788   return LLDB_INVALID_IMAGE_TOKEN;
1789 }
1790
1791 uint32_t Platform::LoadImageUsingPaths(lldb_private::Process *process,
1792                                const lldb_private::FileSpec &remote_filename,
1793                                const std::vector<std::string> &paths,
1794                                lldb_private::Status &error,
1795                                lldb_private::FileSpec *loaded_path)
1796 {
1797   FileSpec file_to_use;
1798   if (remote_filename.IsAbsolute())
1799     file_to_use = FileSpec(remote_filename.GetFilename().GetStringRef(),
1800
1801                            remote_filename.GetPathStyle());
1802   else
1803     file_to_use = remote_filename;
1804
1805   return DoLoadImage(process, file_to_use, &paths, error, loaded_path);
1806 }
1807
1808 Status Platform::UnloadImage(lldb_private::Process *process,
1809                              uint32_t image_token) {
1810   return Status("UnloadImage is not supported on the current platform");
1811 }
1812
1813 lldb::ProcessSP Platform::ConnectProcess(llvm::StringRef connect_url,
1814                                          llvm::StringRef plugin_name,
1815                                          Debugger &debugger, Target *target,
1816                                          Status &error) {
1817   return DoConnectProcess(connect_url, plugin_name, debugger, nullptr, target,
1818                           error);
1819 }
1820
1821 lldb::ProcessSP Platform::ConnectProcessSynchronous(
1822     llvm::StringRef connect_url, llvm::StringRef plugin_name,
1823     Debugger &debugger, Stream &stream, Target *target, Status &error) {
1824   return DoConnectProcess(connect_url, plugin_name, debugger, &stream, target,
1825                           error);
1826 }
1827
1828 lldb::ProcessSP Platform::DoConnectProcess(llvm::StringRef connect_url,
1829                                            llvm::StringRef plugin_name,
1830                                            Debugger &debugger, Stream *stream,
1831                                            Target *target, Status &error) {
1832   error.Clear();
1833
1834   if (!target) {
1835     ArchSpec arch;
1836     if (target && target->GetArchitecture().IsValid())
1837       arch = target->GetArchitecture();
1838     else
1839       arch = Target::GetDefaultArchitecture();
1840
1841     const char *triple = "";
1842     if (arch.IsValid())
1843       triple = arch.GetTriple().getTriple().c_str();
1844
1845     TargetSP new_target_sp;
1846     error = debugger.GetTargetList().CreateTarget(
1847         debugger, "", triple, eLoadDependentsNo, nullptr, new_target_sp);
1848     target = new_target_sp.get();
1849   }
1850
1851   if (!target || error.Fail())
1852     return nullptr;
1853
1854   lldb::ProcessSP process_sp =
1855       target->CreateProcess(debugger.GetListener(), plugin_name, nullptr, true);
1856
1857   if (!process_sp)
1858     return nullptr;
1859
1860   // If this private method is called with a stream we are synchronous.
1861   const bool synchronous = stream != nullptr;
1862
1863   ListenerSP listener_sp(
1864       Listener::MakeListener("lldb.Process.ConnectProcess.hijack"));
1865   if (synchronous)
1866     process_sp->HijackProcessEvents(listener_sp);
1867
1868   error = process_sp->ConnectRemote(connect_url);
1869   if (error.Fail()) {
1870     if (synchronous)
1871       process_sp->RestoreProcessEvents();
1872     return nullptr;
1873   }
1874
1875   if (synchronous) {
1876     EventSP event_sp;
1877     process_sp->WaitForProcessToStop(llvm::None, &event_sp, true, listener_sp,
1878                                      nullptr);
1879     process_sp->RestoreProcessEvents();
1880     bool pop_process_io_handler = false;
1881     Process::HandleProcessStateChangedEvent(event_sp, stream,
1882                                             pop_process_io_handler);
1883   }
1884
1885   return process_sp;
1886 }
1887
1888 size_t Platform::ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
1889                                            lldb_private::Status &error) {
1890   error.Clear();
1891   return 0;
1892 }
1893
1894 size_t Platform::GetSoftwareBreakpointTrapOpcode(Target &target,
1895                                                  BreakpointSite *bp_site) {
1896   ArchSpec arch = target.GetArchitecture();
1897   assert(arch.IsValid());
1898   const uint8_t *trap_opcode = nullptr;
1899   size_t trap_opcode_size = 0;
1900
1901   switch (arch.GetMachine()) {
1902   case llvm::Triple::aarch64_32:
1903   case llvm::Triple::aarch64: {
1904     static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xd4};
1905     trap_opcode = g_aarch64_opcode;
1906     trap_opcode_size = sizeof(g_aarch64_opcode);
1907   } break;
1908
1909   case llvm::Triple::arc: {
1910     static const uint8_t g_hex_opcode[] = { 0xff, 0x7f };
1911     trap_opcode = g_hex_opcode;
1912     trap_opcode_size = sizeof(g_hex_opcode);
1913   } break;
1914
1915   // TODO: support big-endian arm and thumb trap codes.
1916   case llvm::Triple::arm: {
1917     // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the
1918     // linux kernel does otherwise.
1919     static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
1920     static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
1921
1922     lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
1923     AddressClass addr_class = AddressClass::eUnknown;
1924
1925     if (bp_loc_sp) {
1926       addr_class = bp_loc_sp->GetAddress().GetAddressClass();
1927       if (addr_class == AddressClass::eUnknown &&
1928           (bp_loc_sp->GetAddress().GetFileAddress() & 1))
1929         addr_class = AddressClass::eCodeAlternateISA;
1930     }
1931
1932     if (addr_class == AddressClass::eCodeAlternateISA) {
1933       trap_opcode = g_thumb_breakpoint_opcode;
1934       trap_opcode_size = sizeof(g_thumb_breakpoint_opcode);
1935     } else {
1936       trap_opcode = g_arm_breakpoint_opcode;
1937       trap_opcode_size = sizeof(g_arm_breakpoint_opcode);
1938     }
1939   } break;
1940
1941   case llvm::Triple::avr: {
1942     static const uint8_t g_hex_opcode[] = {0x98, 0x95};
1943     trap_opcode = g_hex_opcode;
1944     trap_opcode_size = sizeof(g_hex_opcode);
1945   } break;
1946
1947   case llvm::Triple::mips:
1948   case llvm::Triple::mips64: {
1949     static const uint8_t g_hex_opcode[] = {0x00, 0x00, 0x00, 0x0d};
1950     trap_opcode = g_hex_opcode;
1951     trap_opcode_size = sizeof(g_hex_opcode);
1952   } break;
1953
1954   case llvm::Triple::mipsel:
1955   case llvm::Triple::mips64el: {
1956     static const uint8_t g_hex_opcode[] = {0x0d, 0x00, 0x00, 0x00};
1957     trap_opcode = g_hex_opcode;
1958     trap_opcode_size = sizeof(g_hex_opcode);
1959   } break;
1960
1961   case llvm::Triple::systemz: {
1962     static const uint8_t g_hex_opcode[] = {0x00, 0x01};
1963     trap_opcode = g_hex_opcode;
1964     trap_opcode_size = sizeof(g_hex_opcode);
1965   } break;
1966
1967   case llvm::Triple::hexagon: {
1968     static const uint8_t g_hex_opcode[] = {0x0c, 0xdb, 0x00, 0x54};
1969     trap_opcode = g_hex_opcode;
1970     trap_opcode_size = sizeof(g_hex_opcode);
1971   } break;
1972
1973   case llvm::Triple::ppc:
1974   case llvm::Triple::ppc64: {
1975     static const uint8_t g_ppc_opcode[] = {0x7f, 0xe0, 0x00, 0x08};
1976     trap_opcode = g_ppc_opcode;
1977     trap_opcode_size = sizeof(g_ppc_opcode);
1978   } break;
1979
1980   case llvm::Triple::ppc64le: {
1981     static const uint8_t g_ppc64le_opcode[] = {0x08, 0x00, 0xe0, 0x7f}; // trap
1982     trap_opcode = g_ppc64le_opcode;
1983     trap_opcode_size = sizeof(g_ppc64le_opcode);
1984   } break;
1985
1986   case llvm::Triple::x86:
1987   case llvm::Triple::x86_64: {
1988     static const uint8_t g_i386_opcode[] = {0xCC};
1989     trap_opcode = g_i386_opcode;
1990     trap_opcode_size = sizeof(g_i386_opcode);
1991   } break;
1992
1993   default:
1994     return 0;
1995   }
1996
1997   assert(bp_site);
1998   if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size))
1999     return trap_opcode_size;
2000
2001   return 0;
2002 }