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