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