contrib/llvm/tools/lldb/source/Target/Platform.cpp

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