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