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