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