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