1 //===-- Platform.cpp --------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
15 #include "llvm/Support/FileSystem.h"
16 #include "llvm/Support/Path.h"
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"
43 #include "llvm/Support/FileSystem.h"
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.
48 #define MAP_ANON 0x1000
51 using namespace lldb_private;
53 static uint32_t g_initialize_count = 0;
55 // Use a singleton function for g_local_platform_sp to avoid init constructors
56 // since LLDB is often part of a shared library
57 static PlatformSP &GetHostPlatformSP() {
58 static PlatformSP g_platform_sp;
62 const char *Platform::GetHostPlatformName() { return "host"; }
66 static 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."}};
72 enum { ePropertyUseModuleCache, ePropertyModuleCacheDirectory };
76 ConstString PlatformProperties::GetSettingName() {
77 static ConstString g_setting_name("platform");
78 return g_setting_name;
81 PlatformProperties::PlatformProperties() {
82 m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
83 m_collection_sp->Initialize(g_properties);
85 auto module_cache_dir = GetModuleCacheDirectory();
89 llvm::SmallString<64> user_home_dir;
90 if (!llvm::sys::path::home_directory(user_home_dir))
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);
99 bool PlatformProperties::GetUseModuleCache() const {
100 const auto idx = ePropertyUseModuleCache;
101 return m_collection_sp->GetPropertyAtIndexAsBoolean(
102 nullptr, idx, g_properties[idx].default_uint_value != 0);
105 bool PlatformProperties::SetUseModuleCache(bool use_module_cache) {
106 return m_collection_sp->SetPropertyAtIndexAsBoolean(
107 nullptr, ePropertyUseModuleCache, use_module_cache);
110 FileSpec PlatformProperties::GetModuleCacheDirectory() const {
111 return m_collection_sp->GetPropertyAtIndexAsFileSpec(
112 nullptr, ePropertyModuleCacheDirectory);
115 bool PlatformProperties::SetModuleCacheDirectory(const FileSpec &dir_spec) {
116 return m_collection_sp->SetPropertyAtIndexAsFileSpec(
117 nullptr, ePropertyModuleCacheDirectory, dir_spec);
120 //------------------------------------------------------------------
121 /// Get the native host platform plug-in.
123 /// There should only be one of these for each host that LLDB runs
124 /// upon that should be statically compiled in and registered using
125 /// preprocessor macros or other similar build mechanisms.
127 /// This platform will be used as the default platform when launching
128 /// or attaching to processes unless another platform is specified.
129 //------------------------------------------------------------------
130 PlatformSP Platform::GetHostPlatform() { return GetHostPlatformSP(); }
132 static std::vector<PlatformSP> &GetPlatformList() {
133 static std::vector<PlatformSP> g_platform_list;
134 return g_platform_list;
137 static std::recursive_mutex &GetPlatformListMutex() {
138 static std::recursive_mutex g_mutex;
142 void Platform::Initialize() { g_initialize_count++; }
144 void Platform::Terminate() {
145 if (g_initialize_count > 0) {
146 if (--g_initialize_count == 0) {
147 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
148 GetPlatformList().clear();
153 const PlatformPropertiesSP &Platform::GetGlobalPlatformProperties() {
154 static const auto g_settings_sp(std::make_shared<PlatformProperties>());
155 return g_settings_sp;
158 void Platform::SetHostPlatform(const lldb::PlatformSP &platform_sp) {
159 // The native platform should use its static void Platform::Initialize()
160 // function to register itself as the native platform.
161 GetHostPlatformSP() = platform_sp;
164 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
165 GetPlatformList().push_back(platform_sp);
169 Status Platform::GetFileWithUUID(const FileSpec &platform_file,
170 const UUID *uuid_ptr, FileSpec &local_file) {
171 // Default to the local case
172 local_file = platform_file;
177 Platform::LocateExecutableScriptingResources(Target *target, Module &module,
178 Stream *feedback_stream) {
179 return FileSpecList();
183 // Platform::FindPlugin (Process *process, const ConstString &plugin_name)
185 // PlatformCreateInstance create_callback = nullptr;
189 // PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name);
190 // if (create_callback)
195 // arch = process->GetTarget().GetArchitecture();
197 // PlatformSP platform_sp(create_callback(process, &arch));
199 // return platform_sp;
204 // for (uint32_t idx = 0; (create_callback =
205 // PluginManager::GetPlatformCreateCallbackAtIndex(idx)) != nullptr;
208 // PlatformSP platform_sp(create_callback(process, nullptr));
210 // return platform_sp;
213 // return PlatformSP();
216 Status Platform::GetSharedModule(const ModuleSpec &module_spec,
217 Process *process, ModuleSP &module_sp,
218 const FileSpecList *module_search_paths_ptr,
219 ModuleSP *old_module_sp_ptr,
220 bool *did_create_ptr) {
222 return ModuleList::GetSharedModule(
223 module_spec, module_sp, module_search_paths_ptr, old_module_sp_ptr,
224 did_create_ptr, false);
226 // Module resolver lambda.
227 auto resolver = [&](const ModuleSpec &spec) {
228 Status error(eErrorTypeGeneric);
229 ModuleSpec resolved_spec;
230 // Check if we have sysroot set.
232 // Prepend sysroot to module spec.
233 resolved_spec = spec;
234 resolved_spec.GetFileSpec().PrependPathComponent(
235 m_sdk_sysroot.GetStringRef());
236 // Try to get shared module with resolved spec.
237 error = ModuleList::GetSharedModule(
238 resolved_spec, module_sp, module_search_paths_ptr, old_module_sp_ptr,
239 did_create_ptr, false);
241 // If we don't have sysroot or it didn't work then
242 // try original module spec.
243 if (!error.Success()) {
244 resolved_spec = spec;
245 error = ModuleList::GetSharedModule(
246 resolved_spec, module_sp, module_search_paths_ptr, old_module_sp_ptr,
247 did_create_ptr, false);
249 if (error.Success() && module_sp)
250 module_sp->SetPlatformFileSpec(resolved_spec.GetFileSpec());
254 return GetRemoteSharedModule(module_spec, process, module_sp, resolver,
258 bool Platform::GetModuleSpec(const FileSpec &module_file_spec,
259 const ArchSpec &arch, ModuleSpec &module_spec) {
260 ModuleSpecList module_specs;
261 if (ObjectFile::GetModuleSpecifications(module_file_spec, 0, 0,
265 ModuleSpec matched_module_spec;
266 return module_specs.FindMatchingModuleSpec(ModuleSpec(module_file_spec, arch),
270 PlatformSP Platform::Find(const ConstString &name) {
272 static ConstString g_host_platform_name("host");
273 if (name == g_host_platform_name)
274 return GetHostPlatform();
276 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
277 for (const auto &platform_sp : GetPlatformList()) {
278 if (platform_sp->GetName() == name)
285 PlatformSP Platform::Create(const ConstString &name, Status &error) {
286 PlatformCreateInstance create_callback = nullptr;
287 lldb::PlatformSP platform_sp;
289 static ConstString g_host_platform_name("host");
290 if (name == g_host_platform_name)
291 return GetHostPlatform();
294 PluginManager::GetPlatformCreateCallbackForPluginName(name);
296 platform_sp = create_callback(true, nullptr);
298 error.SetErrorStringWithFormat(
299 "unable to find a plug-in for the platform named \"%s\"",
302 error.SetErrorString("invalid platform name");
305 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
306 GetPlatformList().push_back(platform_sp);
312 PlatformSP Platform::Create(const ArchSpec &arch, ArchSpec *platform_arch_ptr,
314 lldb::PlatformSP platform_sp;
315 if (arch.IsValid()) {
318 // First try exact arch matches across all platforms already created
319 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
320 for (const auto &platform_sp : GetPlatformList()) {
321 if (platform_sp->IsCompatibleArchitecture(arch, true,
326 // Next try compatible arch matches across all platforms already created
327 for (const auto &platform_sp : GetPlatformList()) {
328 if (platform_sp->IsCompatibleArchitecture(arch, false,
334 PlatformCreateInstance create_callback;
335 // First try exact arch matches across all platform plug-ins
337 for (idx = 0; (create_callback =
338 PluginManager::GetPlatformCreateCallbackAtIndex(idx));
340 if (create_callback) {
341 platform_sp = create_callback(false, &arch);
343 platform_sp->IsCompatibleArchitecture(arch, true,
344 platform_arch_ptr)) {
345 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
346 GetPlatformList().push_back(platform_sp);
351 // Next try compatible arch matches across all platform plug-ins
352 for (idx = 0; (create_callback =
353 PluginManager::GetPlatformCreateCallbackAtIndex(idx));
355 if (create_callback) {
356 platform_sp = create_callback(false, &arch);
358 platform_sp->IsCompatibleArchitecture(arch, false,
359 platform_arch_ptr)) {
360 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
361 GetPlatformList().push_back(platform_sp);
367 error.SetErrorString("invalid platform name");
368 if (platform_arch_ptr)
369 platform_arch_ptr->Clear();
374 ArchSpec Platform::GetAugmentedArchSpec(Platform *platform, llvm::StringRef triple) {
376 return platform->GetAugmentedArchSpec(triple);
377 return HostInfo::GetAugmentedArchSpec(triple);
380 //------------------------------------------------------------------
381 /// Default Constructor
382 //------------------------------------------------------------------
383 Platform::Platform(bool is_host)
384 : m_is_host(is_host), m_os_version_set_while_connected(false),
385 m_system_arch_set_while_connected(false), m_sdk_sysroot(), m_sdk_build(),
386 m_working_dir(), m_remote_url(), m_name(), m_system_arch(), m_mutex(),
387 m_uid_map(), m_gid_map(), m_max_uid_name_len(0), m_max_gid_name_len(0),
388 m_supports_rsync(false), m_rsync_opts(), m_rsync_prefix(),
389 m_supports_ssh(false), m_ssh_opts(), m_ignores_remote_hostname(false),
390 m_trap_handlers(), m_calculated_trap_handlers(false),
391 m_module_cache(llvm::make_unique<ModuleCache>()) {
392 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
394 log->Printf("%p Platform::Platform()", static_cast<void *>(this));
397 //------------------------------------------------------------------
400 /// The destructor is virtual since this class is designed to be
401 /// inherited from by the plug-in instance.
402 //------------------------------------------------------------------
403 Platform::~Platform() {
404 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
406 log->Printf("%p Platform::~Platform()", static_cast<void *>(this));
409 void Platform::GetStatus(Stream &strm) {
411 strm.Printf(" Platform: %s\n", GetPluginName().GetCString());
413 ArchSpec arch(GetSystemArchitecture());
414 if (arch.IsValid()) {
415 if (!arch.GetTriple().str().empty()) {
416 strm.Printf(" Triple: ");
417 arch.DumpTriple(strm);
422 llvm::VersionTuple os_version = GetOSVersion();
423 if (!os_version.empty()) {
424 strm.Format("OS Version: {0}", os_version.getAsString());
426 if (GetOSBuildString(s))
427 strm.Printf(" (%s)", s.c_str());
432 if (GetOSKernelDescription(s))
433 strm.Printf(" Kernel: %s\n", s.c_str());
436 strm.Printf(" Hostname: %s\n", GetHostname());
438 const bool is_connected = IsConnected();
440 strm.Printf(" Hostname: %s\n", GetHostname());
441 strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no");
444 if (GetWorkingDirectory()) {
445 strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetCString());
450 std::string specific_info(GetPlatformSpecificConnectionInformation());
452 if (!specific_info.empty())
453 strm.Printf("Platform-specific connection: %s\n", specific_info.c_str());
456 llvm::VersionTuple Platform::GetOSVersion(Process *process) {
457 std::lock_guard<std::mutex> guard(m_mutex);
460 if (m_os_version.empty()) {
461 // We have a local host platform
462 m_os_version = HostInfo::GetOSVersion();
463 m_os_version_set_while_connected = !m_os_version.empty();
466 // We have a remote platform. We can only fetch the remote
467 // OS version if we are connected, and we don't want to do it
470 const bool is_connected = IsConnected();
473 if (!m_os_version.empty()) {
474 // We have valid OS version info, check to make sure it wasn't manually
475 // set prior to connecting. If it was manually set prior to connecting,
476 // then lets fetch the actual OS version info if we are now connected.
477 if (is_connected && !m_os_version_set_while_connected)
480 // We don't have valid OS version info, fetch it if we are connected
481 fetch = is_connected;
485 m_os_version_set_while_connected = GetRemoteOSVersion();
488 if (!m_os_version.empty())
491 // Check with the process in case it can answer the question if a process
493 return process->GetHostOSVersion();
495 return llvm::VersionTuple();
498 bool Platform::GetOSBuildString(std::string &s) {
502 #if !defined(__linux__)
503 return HostInfo::GetOSBuildString(s);
508 return GetRemoteOSBuildString(s);
511 bool Platform::GetOSKernelDescription(std::string &s) {
513 #if !defined(__linux__)
514 return HostInfo::GetOSKernelDescription(s);
519 return GetRemoteOSKernelDescription(s);
522 void Platform::AddClangModuleCompilationOptions(
523 Target *target, std::vector<std::string> &options) {
524 std::vector<std::string> default_compilation_options = {
525 "-x", "c++", "-Xclang", "-nostdsysteminc", "-Xclang", "-nostdsysteminc"};
527 options.insert(options.end(), default_compilation_options.begin(),
528 default_compilation_options.end());
531 FileSpec Platform::GetWorkingDirectory() {
533 llvm::SmallString<64> cwd;
534 if (llvm::sys::fs::current_path(cwd))
537 FileSpec file_spec(cwd);
538 FileSystem::Instance().Resolve(file_spec);
543 m_working_dir = GetRemoteWorkingDirectory();
544 return m_working_dir;
548 struct RecurseCopyBaton {
550 Platform *platform_ptr;
554 static FileSystem::EnumerateDirectoryResult
555 RecurseCopy_Callback(void *baton, llvm::sys::fs::file_type ft,
556 llvm::StringRef path) {
557 RecurseCopyBaton *rc_baton = (RecurseCopyBaton *)baton;
559 namespace fs = llvm::sys::fs;
561 case fs::file_type::fifo_file:
562 case fs::file_type::socket_file:
563 // we have no way to copy pipes and sockets - ignore them and continue
564 return FileSystem::eEnumerateDirectoryResultNext;
567 case fs::file_type::directory_file: {
568 // make the new directory and get in there
569 FileSpec dst_dir = rc_baton->dst;
570 if (!dst_dir.GetFilename())
571 dst_dir.GetFilename() = src.GetLastPathComponent();
572 Status error = rc_baton->platform_ptr->MakeDirectory(
573 dst_dir, lldb::eFilePermissionsDirectoryDefault);
575 rc_baton->error.SetErrorStringWithFormat(
576 "unable to setup directory %s on remote end", dst_dir.GetCString());
577 return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
581 std::string src_dir_path(src.GetPath());
583 // Make a filespec that only fills in the directory of a FileSpec so when
584 // we enumerate we can quickly fill in the filename for dst copies
585 FileSpec recurse_dst;
586 recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
587 RecurseCopyBaton rc_baton2 = {recurse_dst, rc_baton->platform_ptr,
589 FileSystem::Instance().EnumerateDirectory(src_dir_path, true, true, true,
590 RecurseCopy_Callback, &rc_baton2);
591 if (rc_baton2.error.Fail()) {
592 rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
593 return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
595 return FileSystem::eEnumerateDirectoryResultNext;
598 case fs::file_type::symlink_file: {
599 // copy the file and keep going
600 FileSpec dst_file = rc_baton->dst;
601 if (!dst_file.GetFilename())
602 dst_file.GetFilename() = src.GetFilename();
604 FileSpec src_resolved;
606 rc_baton->error = FileSystem::Instance().Readlink(src, src_resolved);
608 if (rc_baton->error.Fail())
609 return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
612 rc_baton->platform_ptr->CreateSymlink(dst_file, src_resolved);
614 if (rc_baton->error.Fail())
615 return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
617 return FileSystem::eEnumerateDirectoryResultNext;
620 case fs::file_type::regular_file: {
621 // copy the file and keep going
622 FileSpec dst_file = rc_baton->dst;
623 if (!dst_file.GetFilename())
624 dst_file.GetFilename() = src.GetFilename();
625 Status err = rc_baton->platform_ptr->PutFile(src, dst_file);
627 rc_baton->error.SetErrorString(err.AsCString());
628 return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
630 return FileSystem::eEnumerateDirectoryResultNext;
634 rc_baton->error.SetErrorStringWithFormat(
635 "invalid file detected during copy: %s", src.GetPath().c_str());
636 return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
639 llvm_unreachable("Unhandled file_type!");
642 Status Platform::Install(const FileSpec &src, const FileSpec &dst) {
645 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
647 log->Printf("Platform::Install (src='%s', dst='%s')", src.GetPath().c_str(),
648 dst.GetPath().c_str());
649 FileSpec fixed_dst(dst);
651 if (!fixed_dst.GetFilename())
652 fixed_dst.GetFilename() = src.GetFilename();
654 FileSpec working_dir = GetWorkingDirectory();
657 if (dst.GetDirectory()) {
658 const char first_dst_dir_char = dst.GetDirectory().GetCString()[0];
659 if (first_dst_dir_char == '/' || first_dst_dir_char == '\\') {
660 fixed_dst.GetDirectory() = dst.GetDirectory();
662 // If the fixed destination file doesn't have a directory yet, then we
663 // must have a relative path. We will resolve this relative path against
664 // the platform's working directory
665 if (!fixed_dst.GetDirectory()) {
666 FileSpec relative_spec;
669 relative_spec = working_dir;
670 relative_spec.AppendPathComponent(dst.GetPath());
671 fixed_dst.GetDirectory() = relative_spec.GetDirectory();
673 error.SetErrorStringWithFormat(
674 "platform working directory must be valid for relative path '%s'",
675 dst.GetPath().c_str());
681 fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
683 error.SetErrorStringWithFormat(
684 "platform working directory must be valid for relative path '%s'",
685 dst.GetPath().c_str());
691 fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
693 error.SetErrorStringWithFormat("platform working directory must be valid "
694 "when destination directory is empty");
700 log->Printf("Platform::Install (src='%s', dst='%s') fixed_dst='%s'",
701 src.GetPath().c_str(), dst.GetPath().c_str(),
702 fixed_dst.GetPath().c_str());
704 if (GetSupportsRSync()) {
705 error = PutFile(src, dst);
707 namespace fs = llvm::sys::fs;
708 switch (fs::get_file_type(src.GetPath(), false)) {
709 case fs::file_type::directory_file: {
710 llvm::sys::fs::remove(fixed_dst.GetPath());
711 uint32_t permissions = FileSystem::Instance().GetPermissions(src);
712 if (permissions == 0)
713 permissions = eFilePermissionsDirectoryDefault;
714 error = MakeDirectory(fixed_dst, permissions);
715 if (error.Success()) {
716 // Make a filespec that only fills in the directory of a FileSpec so
717 // when we enumerate we can quickly fill in the filename for dst copies
718 FileSpec recurse_dst;
719 recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
720 std::string src_dir_path(src.GetPath());
721 RecurseCopyBaton baton = {recurse_dst, this, Status()};
722 FileSystem::Instance().EnumerateDirectory(
723 src_dir_path, true, true, true, RecurseCopy_Callback, &baton);
728 case fs::file_type::regular_file:
729 llvm::sys::fs::remove(fixed_dst.GetPath());
730 error = PutFile(src, fixed_dst);
733 case fs::file_type::symlink_file: {
734 llvm::sys::fs::remove(fixed_dst.GetPath());
735 FileSpec src_resolved;
736 error = FileSystem::Instance().Readlink(src, src_resolved);
738 error = CreateSymlink(dst, src_resolved);
740 case fs::file_type::fifo_file:
741 error.SetErrorString("platform install doesn't handle pipes");
743 case fs::file_type::socket_file:
744 error.SetErrorString("platform install doesn't handle sockets");
747 error.SetErrorString(
748 "platform install doesn't handle non file or directory items");
755 bool Platform::SetWorkingDirectory(const FileSpec &file_spec) {
757 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
758 LLDB_LOG(log, "{0}", file_spec);
759 if (std::error_code ec = llvm::sys::fs::set_current_path(file_spec.GetPath())) {
760 LLDB_LOG(log, "error: {0}", ec.message());
765 m_working_dir.Clear();
766 return SetRemoteWorkingDirectory(file_spec);
770 Status Platform::MakeDirectory(const FileSpec &file_spec,
771 uint32_t permissions) {
773 return llvm::sys::fs::create_directory(file_spec.GetPath(), permissions);
776 error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
777 GetPluginName().GetCString(),
778 LLVM_PRETTY_FUNCTION);
783 Status Platform::GetFilePermissions(const FileSpec &file_spec,
784 uint32_t &file_permissions) {
786 auto Value = llvm::sys::fs::getPermissions(file_spec.GetPath());
788 file_permissions = Value.get();
789 return Status(Value.getError());
792 error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
793 GetPluginName().GetCString(),
794 LLVM_PRETTY_FUNCTION);
799 Status Platform::SetFilePermissions(const FileSpec &file_spec,
800 uint32_t file_permissions) {
802 auto Perms = static_cast<llvm::sys::fs::perms>(file_permissions);
803 return llvm::sys::fs::setPermissions(file_spec.GetPath(), Perms);
806 error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
807 GetPluginName().GetCString(),
808 LLVM_PRETTY_FUNCTION);
813 ConstString Platform::GetName() { return GetPluginName(); }
815 const char *Platform::GetHostname() {
821 return m_name.c_str();
824 ConstString Platform::GetFullNameForDylib(ConstString basename) {
828 bool Platform::SetRemoteWorkingDirectory(const FileSpec &working_dir) {
829 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
831 log->Printf("Platform::SetRemoteWorkingDirectory('%s')",
832 working_dir.GetCString());
833 m_working_dir = working_dir;
837 const char *Platform::GetUserName(uint32_t uid) {
838 #if !defined(LLDB_DISABLE_POSIX)
839 const char *user_name = GetCachedUserName(uid);
844 if (HostInfo::LookupUserName(uid, name))
845 return SetCachedUserName(uid, name.c_str(), name.size());
851 const char *Platform::GetGroupName(uint32_t gid) {
852 #if !defined(LLDB_DISABLE_POSIX)
853 const char *group_name = GetCachedGroupName(gid);
858 if (HostInfo::LookupGroupName(gid, name))
859 return SetCachedGroupName(gid, name.c_str(), name.size());
865 bool Platform::SetOSVersion(llvm::VersionTuple version) {
867 // We don't need anyone setting the OS version for the host platform, we
868 // should be able to figure it out by calling HostInfo::GetOSVersion(...).
871 // We have a remote platform, allow setting the target OS version if we
872 // aren't connected, since if we are connected, we should be able to
873 // request the remote OS version from the connected platform.
877 // We aren't connected and we might want to set the OS version ahead of
878 // time before we connect so we can peruse files and use a local SDK or
879 // PDK cache of support files to disassemble or do other things.
880 m_os_version = version;
888 Platform::ResolveExecutable(const ModuleSpec &module_spec,
889 lldb::ModuleSP &exe_module_sp,
890 const FileSpecList *module_search_paths_ptr) {
892 if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
893 if (module_spec.GetArchitecture().IsValid()) {
894 error = ModuleList::GetSharedModule(module_spec, exe_module_sp,
895 module_search_paths_ptr, nullptr,
898 // No valid architecture was specified, ask the platform for the
899 // architectures that we should be using (in the correct order) and see
900 // if we can find a match that way
901 ModuleSpec arch_module_spec(module_spec);
902 for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
903 idx, arch_module_spec.GetArchitecture());
905 error = ModuleList::GetSharedModule(arch_module_spec, exe_module_sp,
906 module_search_paths_ptr, nullptr,
908 // Did we find an executable using one of the
909 if (error.Success() && exe_module_sp)
914 error.SetErrorStringWithFormat("'%s' does not exist",
915 module_spec.GetFileSpec().GetPath().c_str());
920 Status Platform::ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec,
921 FileSpec &sym_file) {
923 if (FileSystem::Instance().Exists(sym_spec.GetSymbolFileSpec()))
924 sym_file = sym_spec.GetSymbolFileSpec();
926 error.SetErrorString("unable to resolve symbol file");
930 bool Platform::ResolveRemotePath(const FileSpec &platform_path,
931 FileSpec &resolved_platform_path) {
932 resolved_platform_path = platform_path;
933 FileSystem::Instance().Resolve(resolved_platform_path);
937 const ArchSpec &Platform::GetSystemArchitecture() {
939 if (!m_system_arch.IsValid()) {
940 // We have a local host platform
941 m_system_arch = HostInfo::GetArchitecture();
942 m_system_arch_set_while_connected = m_system_arch.IsValid();
945 // We have a remote platform. We can only fetch the remote system
946 // architecture if we are connected, and we don't want to do it more than
949 const bool is_connected = IsConnected();
952 if (m_system_arch.IsValid()) {
953 // We have valid OS version info, check to make sure it wasn't manually
954 // set prior to connecting. If it was manually set prior to connecting,
955 // then lets fetch the actual OS version info if we are now connected.
956 if (is_connected && !m_system_arch_set_while_connected)
959 // We don't have valid OS version info, fetch it if we are connected
960 fetch = is_connected;
964 m_system_arch = GetRemoteSystemArchitecture();
965 m_system_arch_set_while_connected = m_system_arch.IsValid();
968 return m_system_arch;
971 ArchSpec Platform::GetAugmentedArchSpec(llvm::StringRef triple) {
974 llvm::Triple normalized_triple(llvm::Triple::normalize(triple));
975 if (!ArchSpec::ContainsOnlyArch(normalized_triple))
976 return ArchSpec(triple);
978 if (auto kind = HostInfo::ParseArchitectureKind(triple))
979 return HostInfo::GetArchitecture(*kind);
981 ArchSpec compatible_arch;
982 ArchSpec raw_arch(triple);
983 if (!IsCompatibleArchitecture(raw_arch, false, &compatible_arch))
986 if (!compatible_arch.IsValid())
987 return ArchSpec(normalized_triple);
989 const llvm::Triple &compatible_triple = compatible_arch.GetTriple();
990 if (normalized_triple.getVendorName().empty())
991 normalized_triple.setVendor(compatible_triple.getVendor());
992 if (normalized_triple.getOSName().empty())
993 normalized_triple.setOS(compatible_triple.getOS());
994 if (normalized_triple.getEnvironmentName().empty())
995 normalized_triple.setEnvironment(compatible_triple.getEnvironment());
996 return ArchSpec(normalized_triple);
999 Status Platform::ConnectRemote(Args &args) {
1002 error.SetErrorStringWithFormat("The currently selected platform (%s) is "
1003 "the host platform and is always connected.",
1004 GetPluginName().GetCString());
1006 error.SetErrorStringWithFormat(
1007 "Platform::ConnectRemote() is not supported by %s",
1008 GetPluginName().GetCString());
1012 Status Platform::DisconnectRemote() {
1015 error.SetErrorStringWithFormat("The currently selected platform (%s) is "
1016 "the host platform and is always connected.",
1017 GetPluginName().GetCString());
1019 error.SetErrorStringWithFormat(
1020 "Platform::DisconnectRemote() is not supported by %s",
1021 GetPluginName().GetCString());
1025 bool Platform::GetProcessInfo(lldb::pid_t pid,
1026 ProcessInstanceInfo &process_info) {
1027 // Take care of the host case so that each subclass can just call this
1028 // function to get the host functionality.
1030 return Host::GetProcessInfo(pid, process_info);
1034 uint32_t Platform::FindProcesses(const ProcessInstanceInfoMatch &match_info,
1035 ProcessInstanceInfoList &process_infos) {
1036 // Take care of the host case so that each subclass can just call this
1037 // function to get the host functionality.
1038 uint32_t match_count = 0;
1040 match_count = Host::FindProcesses(match_info, process_infos);
1044 Status Platform::LaunchProcess(ProcessLaunchInfo &launch_info) {
1046 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1048 log->Printf("Platform::%s()", __FUNCTION__);
1050 // Take care of the host case so that each subclass can just call this
1051 // function to get the host functionality.
1053 if (::getenv("LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY"))
1054 launch_info.GetFlags().Set(eLaunchFlagLaunchInTTY);
1056 if (launch_info.GetFlags().Test(eLaunchFlagLaunchInShell)) {
1057 const bool is_localhost = true;
1058 const bool will_debug = launch_info.GetFlags().Test(eLaunchFlagDebug);
1059 const bool first_arg_is_full_shell_command = false;
1060 uint32_t num_resumes = GetResumeCountForLaunchInfo(launch_info);
1062 const FileSpec &shell = launch_info.GetShell();
1063 const char *shell_str = (shell) ? shell.GetPath().c_str() : "<null>";
1065 "Platform::%s GetResumeCountForLaunchInfo() returned %" PRIu32
1067 __FUNCTION__, num_resumes, shell_str);
1070 if (!launch_info.ConvertArgumentsForLaunchingInShell(
1071 error, is_localhost, will_debug, first_arg_is_full_shell_command,
1074 } else if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments)) {
1075 error = ShellExpandArguments(launch_info);
1077 error.SetErrorStringWithFormat("shell expansion failed (reason: %s). "
1078 "consider launching with 'process "
1080 error.AsCString("unknown"));
1086 log->Printf("Platform::%s final launch_info resume count: %" PRIu32,
1087 __FUNCTION__, launch_info.GetResumeCount());
1089 error = Host::LaunchProcess(launch_info);
1091 error.SetErrorString(
1092 "base lldb_private::Platform class can't launch remote processes");
1096 Status Platform::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
1098 return Host::ShellExpandArguments(launch_info);
1099 return Status("base lldb_private::Platform class can't expand arguments");
1102 Status Platform::KillProcess(const lldb::pid_t pid) {
1103 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1105 log->Printf("Platform::%s, pid %" PRIu64, __FUNCTION__, pid);
1107 // Try to find a process plugin to handle this Kill request. If we can't,
1108 // fall back to the default OS implementation.
1109 size_t num_debuggers = Debugger::GetNumDebuggers();
1110 for (size_t didx = 0; didx < num_debuggers; ++didx) {
1111 DebuggerSP debugger = Debugger::GetDebuggerAtIndex(didx);
1112 lldb_private::TargetList &targets = debugger->GetTargetList();
1113 for (int tidx = 0; tidx < targets.GetNumTargets(); ++tidx) {
1114 ProcessSP process = targets.GetTargetAtIndex(tidx)->GetProcessSP();
1115 if (process->GetID() == pid)
1116 return process->Destroy(true);
1122 "base lldb_private::Platform class can't kill remote processes unless "
1123 "they are controlled by a process plugin");
1125 Host::Kill(pid, SIGTERM);
1130 Platform::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
1131 Target *target, // Can be nullptr, if nullptr create a
1132 // new target, else use existing one
1134 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1136 log->Printf("Platform::%s entered (target %p)", __FUNCTION__,
1137 static_cast<void *>(target));
1139 ProcessSP process_sp;
1140 // Make sure we stop at the entry point
1141 launch_info.GetFlags().Set(eLaunchFlagDebug);
1142 // We always launch the process we are going to debug in a separate process
1143 // group, since then we can handle ^C interrupts ourselves w/o having to
1144 // worry about the target getting them as well.
1145 launch_info.SetLaunchInSeparateProcessGroup(true);
1147 // Allow any StructuredData process-bound plugins to adjust the launch info
1150 bool iteration_complete = false;
1151 // Note iteration can't simply go until a nullptr callback is returned, as it
1152 // is valid for a plugin to not supply a filter.
1153 auto get_filter_func = PluginManager::GetStructuredDataFilterCallbackAtIndex;
1154 for (auto filter_callback = get_filter_func(i, iteration_complete);
1155 !iteration_complete;
1156 filter_callback = get_filter_func(++i, iteration_complete)) {
1157 if (filter_callback) {
1158 // Give this ProcessLaunchInfo filter a chance to adjust the launch info.
1159 error = (*filter_callback)(launch_info, target);
1160 if (!error.Success()) {
1162 log->Printf("Platform::%s() StructuredDataPlugin launch "
1170 error = LaunchProcess(launch_info);
1171 if (error.Success()) {
1173 log->Printf("Platform::%s LaunchProcess() call succeeded (pid=%" PRIu64
1175 __FUNCTION__, launch_info.GetProcessID());
1176 if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) {
1177 ProcessAttachInfo attach_info(launch_info);
1178 process_sp = Attach(attach_info, debugger, target, error);
1181 log->Printf("Platform::%s Attach() succeeded, Process plugin: %s",
1182 __FUNCTION__, process_sp->GetPluginName().AsCString());
1183 launch_info.SetHijackListener(attach_info.GetHijackListener());
1185 // Since we attached to the process, it will think it needs to detach
1186 // if the process object just goes away without an explicit call to
1187 // Process::Kill() or Process::Detach(), so let it know to kill the
1188 // process if this happens.
1189 process_sp->SetShouldDetach(false);
1191 // If we didn't have any file actions, the pseudo terminal might have
1192 // been used where the slave side was given as the file to open for
1193 // stdin/out/err after we have already opened the master so we can
1194 // read/write stdin/out/err.
1195 int pty_fd = launch_info.GetPTY().ReleaseMasterFileDescriptor();
1196 if (pty_fd != PseudoTerminal::invalid_fd) {
1197 process_sp->SetSTDIOFileDescriptor(pty_fd);
1201 log->Printf("Platform::%s Attach() failed: %s", __FUNCTION__,
1206 log->Printf("Platform::%s LaunchProcess() returned launch_info with "
1207 "invalid process id",
1212 log->Printf("Platform::%s LaunchProcess() failed: %s", __FUNCTION__,
1220 Platform::GetPlatformForArchitecture(const ArchSpec &arch,
1221 ArchSpec *platform_arch_ptr) {
1222 lldb::PlatformSP platform_sp;
1225 platform_sp = Platform::Create(arch, platform_arch_ptr, error);
1229 //------------------------------------------------------------------
1230 /// Lets a platform answer if it is compatible with a given
1231 /// architecture and the target triple contained within.
1232 //------------------------------------------------------------------
1233 bool Platform::IsCompatibleArchitecture(const ArchSpec &arch,
1234 bool exact_arch_match,
1235 ArchSpec *compatible_arch_ptr) {
1236 // If the architecture is invalid, we must answer true...
1237 if (arch.IsValid()) {
1238 ArchSpec platform_arch;
1239 // Try for an exact architecture match first.
1240 if (exact_arch_match) {
1241 for (uint32_t arch_idx = 0;
1242 GetSupportedArchitectureAtIndex(arch_idx, platform_arch);
1244 if (arch.IsExactMatch(platform_arch)) {
1245 if (compatible_arch_ptr)
1246 *compatible_arch_ptr = platform_arch;
1251 for (uint32_t arch_idx = 0;
1252 GetSupportedArchitectureAtIndex(arch_idx, platform_arch);
1254 if (arch.IsCompatibleMatch(platform_arch)) {
1255 if (compatible_arch_ptr)
1256 *compatible_arch_ptr = platform_arch;
1262 if (compatible_arch_ptr)
1263 compatible_arch_ptr->Clear();
1267 Status Platform::PutFile(const FileSpec &source, const FileSpec &destination,
1268 uint32_t uid, uint32_t gid) {
1269 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1271 log->Printf("[PutFile] Using block by block transfer....\n");
1273 uint32_t source_open_options =
1274 File::eOpenOptionRead | File::eOpenOptionCloseOnExec;
1275 namespace fs = llvm::sys::fs;
1276 if (fs::is_symlink_file(source.GetPath()))
1277 source_open_options |= File::eOpenOptionDontFollowSymlinks;
1280 Status error = FileSystem::Instance().Open(
1281 source_file, source, source_open_options, lldb::eFilePermissionsUserRW);
1282 uint32_t permissions = source_file.GetPermissions(error);
1283 if (permissions == 0)
1284 permissions = lldb::eFilePermissionsFileDefault;
1286 if (!source_file.IsValid())
1287 return Status("PutFile: unable to open source file");
1288 lldb::user_id_t dest_file = OpenFile(
1289 destination, File::eOpenOptionCanCreate | File::eOpenOptionWrite |
1290 File::eOpenOptionTruncate | File::eOpenOptionCloseOnExec,
1291 permissions, error);
1293 log->Printf("dest_file = %" PRIu64 "\n", dest_file);
1297 if (dest_file == UINT64_MAX)
1298 return Status("unable to open target file");
1299 lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024 * 16, 0));
1300 uint64_t offset = 0;
1302 size_t bytes_read = buffer_sp->GetByteSize();
1303 error = source_file.Read(buffer_sp->GetBytes(), bytes_read);
1304 if (error.Fail() || bytes_read == 0)
1307 const uint64_t bytes_written =
1308 WriteFile(dest_file, offset, buffer_sp->GetBytes(), bytes_read, error);
1312 offset += bytes_written;
1313 if (bytes_written != bytes_read) {
1314 // We didn't write the correct number of bytes, so adjust the file
1315 // position in the source file we are reading from...
1316 source_file.SeekFromStart(offset);
1319 CloseFile(dest_file, error);
1321 if (uid == UINT32_MAX && gid == UINT32_MAX)
1329 Status Platform::GetFile(const FileSpec &source, const FileSpec &destination) {
1330 Status error("unimplemented");
1335 Platform::CreateSymlink(const FileSpec &src, // The name of the link is in src
1336 const FileSpec &dst) // The symlink points to dst
1338 Status error("unimplemented");
1342 bool Platform::GetFileExists(const lldb_private::FileSpec &file_spec) {
1346 Status Platform::Unlink(const FileSpec &path) {
1347 Status error("unimplemented");
1351 MmapArgList Platform::GetMmapArgumentList(const ArchSpec &arch, addr_t addr,
1352 addr_t length, unsigned prot,
1353 unsigned flags, addr_t fd,
1355 uint64_t flags_platform = 0;
1356 if (flags & eMmapFlagsPrivate)
1357 flags_platform |= MAP_PRIVATE;
1358 if (flags & eMmapFlagsAnon)
1359 flags_platform |= MAP_ANON;
1361 MmapArgList args({addr, length, prot, flags_platform, fd, offset});
1365 lldb_private::Status Platform::RunShellCommand(
1366 const char *command, // Shouldn't be nullptr
1368 working_dir, // Pass empty FileSpec to use the current working directory
1369 int *status_ptr, // Pass nullptr if you don't want the process exit status
1370 int *signo_ptr, // Pass nullptr if you don't want the signal that caused the
1373 *command_output, // Pass nullptr if you don't want the command output
1374 const Timeout<std::micro> &timeout) {
1376 return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr,
1377 command_output, timeout);
1379 return Status("unimplemented");
1382 bool Platform::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
1386 auto Result = llvm::sys::fs::md5_contents(file_spec.GetPath());
1389 std::tie(high, low) = Result->words();
1393 void Platform::SetLocalCacheDirectory(const char *local) {
1394 m_local_cache_directory.assign(local);
1397 const char *Platform::GetLocalCacheDirectory() {
1398 return m_local_cache_directory.c_str();
1401 static constexpr OptionDefinition g_rsync_option_table[] = {
1402 {LLDB_OPT_SET_ALL, false, "rsync", 'r', OptionParser::eNoArgument, nullptr,
1403 {}, 0, eArgTypeNone, "Enable rsync."},
1404 {LLDB_OPT_SET_ALL, false, "rsync-opts", 'R',
1405 OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
1406 "Platform-specific options required for rsync to work."},
1407 {LLDB_OPT_SET_ALL, false, "rsync-prefix", 'P',
1408 OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
1409 "Platform-specific rsync prefix put before the remote path."},
1410 {LLDB_OPT_SET_ALL, false, "ignore-remote-hostname", 'i',
1411 OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone,
1412 "Do not automatically fill in the remote hostname when composing the "
1416 static constexpr OptionDefinition g_ssh_option_table[] = {
1417 {LLDB_OPT_SET_ALL, false, "ssh", 's', OptionParser::eNoArgument, nullptr,
1418 {}, 0, eArgTypeNone, "Enable SSH."},
1419 {LLDB_OPT_SET_ALL, false, "ssh-opts", 'S', OptionParser::eRequiredArgument,
1420 nullptr, {}, 0, eArgTypeCommandName,
1421 "Platform-specific options required for SSH to work."},
1424 static constexpr OptionDefinition g_caching_option_table[] = {
1425 {LLDB_OPT_SET_ALL, false, "local-cache-dir", 'c',
1426 OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypePath,
1427 "Path in which to store local copies of files."},
1430 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformRSync::GetDefinitions() {
1431 return llvm::makeArrayRef(g_rsync_option_table);
1434 void OptionGroupPlatformRSync::OptionParsingStarting(
1435 ExecutionContext *execution_context) {
1437 m_rsync_opts.clear();
1438 m_rsync_prefix.clear();
1439 m_ignores_remote_hostname = false;
1442 lldb_private::Status
1443 OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
1444 llvm::StringRef option_arg,
1445 ExecutionContext *execution_context) {
1447 char short_option = (char)GetDefinitions()[option_idx].short_option;
1448 switch (short_option) {
1454 m_rsync_opts.assign(option_arg);
1458 m_rsync_prefix.assign(option_arg);
1462 m_ignores_remote_hostname = true;
1466 error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
1474 Platform::SetThreadCreationBreakpoint(lldb_private::Target &target) {
1475 return lldb::BreakpointSP();
1478 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformSSH::GetDefinitions() {
1479 return llvm::makeArrayRef(g_ssh_option_table);
1482 void OptionGroupPlatformSSH::OptionParsingStarting(
1483 ExecutionContext *execution_context) {
1488 lldb_private::Status
1489 OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
1490 llvm::StringRef option_arg,
1491 ExecutionContext *execution_context) {
1493 char short_option = (char)GetDefinitions()[option_idx].short_option;
1494 switch (short_option) {
1500 m_ssh_opts.assign(option_arg);
1504 error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
1511 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformCaching::GetDefinitions() {
1512 return llvm::makeArrayRef(g_caching_option_table);
1515 void OptionGroupPlatformCaching::OptionParsingStarting(
1516 ExecutionContext *execution_context) {
1517 m_cache_dir.clear();
1520 lldb_private::Status OptionGroupPlatformCaching::SetOptionValue(
1521 uint32_t option_idx, llvm::StringRef option_arg,
1522 ExecutionContext *execution_context) {
1524 char short_option = (char)GetDefinitions()[option_idx].short_option;
1525 switch (short_option) {
1527 m_cache_dir.assign(option_arg);
1531 error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
1538 Environment Platform::GetEnvironment() { return Environment(); }
1540 const std::vector<ConstString> &Platform::GetTrapHandlerSymbolNames() {
1541 if (!m_calculated_trap_handlers) {
1542 std::lock_guard<std::mutex> guard(m_mutex);
1543 if (!m_calculated_trap_handlers) {
1544 CalculateTrapHandlerSymbolNames();
1545 m_calculated_trap_handlers = true;
1548 return m_trap_handlers;
1551 Status Platform::GetCachedExecutable(
1552 ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
1553 const FileSpecList *module_search_paths_ptr, Platform &remote_platform) {
1554 const auto platform_spec = module_spec.GetFileSpec();
1555 const auto error = LoadCachedExecutable(
1556 module_spec, module_sp, module_search_paths_ptr, remote_platform);
1557 if (error.Success()) {
1558 module_spec.GetFileSpec() = module_sp->GetFileSpec();
1559 module_spec.GetPlatformFileSpec() = platform_spec;
1565 Status Platform::LoadCachedExecutable(
1566 const ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
1567 const FileSpecList *module_search_paths_ptr, Platform &remote_platform) {
1568 return GetRemoteSharedModule(module_spec, nullptr, module_sp,
1569 [&](const ModuleSpec &spec) {
1570 return remote_platform.ResolveExecutable(
1571 spec, module_sp, module_search_paths_ptr);
1576 Status Platform::GetRemoteSharedModule(const ModuleSpec &module_spec,
1578 lldb::ModuleSP &module_sp,
1579 const ModuleResolver &module_resolver,
1580 bool *did_create_ptr) {
1581 // Get module information from a target.
1582 ModuleSpec resolved_module_spec;
1583 bool got_module_spec = false;
1585 // Try to get module information from the process
1586 if (process->GetModuleSpec(module_spec.GetFileSpec(),
1587 module_spec.GetArchitecture(),
1588 resolved_module_spec)) {
1589 if (!module_spec.GetUUID().IsValid() ||
1590 module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
1591 got_module_spec = true;
1596 if (!module_spec.GetArchitecture().IsValid()) {
1598 // No valid architecture was specified, ask the platform for the
1599 // architectures that we should be using (in the correct order) and see if
1600 // we can find a match that way
1601 ModuleSpec arch_module_spec(module_spec);
1602 for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
1603 idx, arch_module_spec.GetArchitecture());
1605 error = ModuleList::GetSharedModule(arch_module_spec, module_sp, nullptr,
1607 // Did we find an executable using one of the
1608 if (error.Success() && module_sp)
1612 got_module_spec = true;
1615 if (!got_module_spec) {
1616 // Get module information from a target.
1617 if (!GetModuleSpec(module_spec.GetFileSpec(), module_spec.GetArchitecture(),
1618 resolved_module_spec)) {
1619 if (!module_spec.GetUUID().IsValid() ||
1620 module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
1621 return module_resolver(module_spec);
1626 // If we are looking for a specific UUID, make sure resolved_module_spec has
1627 // the same one before we search.
1628 if (module_spec.GetUUID().IsValid()) {
1629 resolved_module_spec.GetUUID() = module_spec.GetUUID();
1632 // Trying to find a module by UUID on local file system.
1633 const auto error = module_resolver(resolved_module_spec);
1635 if (GetCachedSharedModule(resolved_module_spec, module_sp, did_create_ptr))
1642 bool Platform::GetCachedSharedModule(const ModuleSpec &module_spec,
1643 lldb::ModuleSP &module_sp,
1644 bool *did_create_ptr) {
1645 if (IsHost() || !GetGlobalPlatformProperties()->GetUseModuleCache() ||
1646 !GetGlobalPlatformProperties()->GetModuleCacheDirectory())
1649 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
1651 // Check local cache for a module.
1652 auto error = m_module_cache->GetAndPut(
1653 GetModuleCacheRoot(), GetCacheHostname(), module_spec,
1654 [this](const ModuleSpec &module_spec,
1655 const FileSpec &tmp_download_file_spec) {
1656 return DownloadModuleSlice(
1657 module_spec.GetFileSpec(), module_spec.GetObjectOffset(),
1658 module_spec.GetObjectSize(), tmp_download_file_spec);
1661 [this](const ModuleSP &module_sp,
1662 const FileSpec &tmp_download_file_spec) {
1663 return DownloadSymbolFile(module_sp, tmp_download_file_spec);
1665 module_sp, did_create_ptr);
1666 if (error.Success())
1670 log->Printf("Platform::%s - module %s not found in local cache: %s",
1671 __FUNCTION__, module_spec.GetUUID().GetAsString().c_str(),
1676 Status Platform::DownloadModuleSlice(const FileSpec &src_file_spec,
1677 const uint64_t src_offset,
1678 const uint64_t src_size,
1679 const FileSpec &dst_file_spec) {
1683 llvm::raw_fd_ostream dst(dst_file_spec.GetPath(), EC, llvm::sys::fs::F_None);
1685 error.SetErrorStringWithFormat("unable to open destination file: %s",
1686 dst_file_spec.GetPath().c_str());
1690 auto src_fd = OpenFile(src_file_spec, File::eOpenOptionRead,
1691 lldb::eFilePermissionsFileDefault, error);
1694 error.SetErrorStringWithFormat("unable to open source file: %s",
1699 std::vector<char> buffer(1024);
1700 auto offset = src_offset;
1701 uint64_t total_bytes_read = 0;
1702 while (total_bytes_read < src_size) {
1703 const auto to_read = std::min(static_cast<uint64_t>(buffer.size()),
1704 src_size - total_bytes_read);
1705 const uint64_t n_read =
1706 ReadFile(src_fd, offset, &buffer[0], to_read, error);
1710 error.SetErrorString("read 0 bytes");
1714 total_bytes_read += n_read;
1715 dst.write(&buffer[0], n_read);
1719 CloseFile(src_fd, close_error); // Ignoring close error.
1724 Status Platform::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
1725 const FileSpec &dst_file_spec) {
1727 "Symbol file downloading not supported by the default platform.");
1730 FileSpec Platform::GetModuleCacheRoot() {
1731 auto dir_spec = GetGlobalPlatformProperties()->GetModuleCacheDirectory();
1732 dir_spec.AppendPathComponent(GetName().AsCString());
1736 const char *Platform::GetCacheHostname() { return GetHostname(); }
1738 const UnixSignalsSP &Platform::GetRemoteUnixSignals() {
1739 static const auto s_default_unix_signals_sp = std::make_shared<UnixSignals>();
1740 return s_default_unix_signals_sp;
1743 const UnixSignalsSP &Platform::GetUnixSignals() {
1745 return Host::GetUnixSignals();
1746 return GetRemoteUnixSignals();
1749 uint32_t Platform::LoadImage(lldb_private::Process *process,
1750 const lldb_private::FileSpec &local_file,
1751 const lldb_private::FileSpec &remote_file,
1752 lldb_private::Status &error) {
1753 if (local_file && remote_file) {
1754 // Both local and remote file was specified. Install the local file to the
1756 if (IsRemote() || local_file != remote_file) {
1757 error = Install(local_file, remote_file);
1759 return LLDB_INVALID_IMAGE_TOKEN;
1761 return DoLoadImage(process, remote_file, nullptr, error);
1765 // Only local file was specified. Install it to the current working
1767 FileSpec target_file = GetWorkingDirectory();
1768 target_file.AppendPathComponent(local_file.GetFilename().AsCString());
1769 if (IsRemote() || local_file != target_file) {
1770 error = Install(local_file, target_file);
1772 return LLDB_INVALID_IMAGE_TOKEN;
1774 return DoLoadImage(process, target_file, nullptr, error);
1778 // Only remote file was specified so we don't have to do any copying
1779 return DoLoadImage(process, remote_file, nullptr, error);
1782 error.SetErrorString("Neither local nor remote file was specified");
1783 return LLDB_INVALID_IMAGE_TOKEN;
1786 uint32_t Platform::DoLoadImage(lldb_private::Process *process,
1787 const lldb_private::FileSpec &remote_file,
1788 const std::vector<std::string> *paths,
1789 lldb_private::Status &error,
1790 lldb_private::FileSpec *loaded_image) {
1791 error.SetErrorString("LoadImage is not supported on the current platform");
1792 return LLDB_INVALID_IMAGE_TOKEN;
1795 uint32_t Platform::LoadImageUsingPaths(lldb_private::Process *process,
1796 const lldb_private::FileSpec &remote_filename,
1797 const std::vector<std::string> &paths,
1798 lldb_private::Status &error,
1799 lldb_private::FileSpec *loaded_path)
1801 FileSpec file_to_use;
1802 if (remote_filename.IsAbsolute())
1803 file_to_use = FileSpec(remote_filename.GetFilename().GetStringRef(),
1805 remote_filename.GetPathStyle());
1807 file_to_use = remote_filename;
1809 return DoLoadImage(process, file_to_use, &paths, error, loaded_path);
1812 Status Platform::UnloadImage(lldb_private::Process *process,
1813 uint32_t image_token) {
1814 return Status("UnloadImage is not supported on the current platform");
1817 lldb::ProcessSP Platform::ConnectProcess(llvm::StringRef connect_url,
1818 llvm::StringRef plugin_name,
1819 lldb_private::Debugger &debugger,
1820 lldb_private::Target *target,
1821 lldb_private::Status &error) {
1826 if (target && target->GetArchitecture().IsValid())
1827 arch = target->GetArchitecture();
1829 arch = Target::GetDefaultArchitecture();
1831 const char *triple = "";
1833 triple = arch.GetTriple().getTriple().c_str();
1835 TargetSP new_target_sp;
1836 error = debugger.GetTargetList().CreateTarget(
1837 debugger, "", triple, eLoadDependentsNo, nullptr, new_target_sp);
1838 target = new_target_sp.get();
1841 if (!target || error.Fail())
1844 debugger.GetTargetList().SetSelectedTarget(target);
1846 lldb::ProcessSP process_sp =
1847 target->CreateProcess(debugger.GetListener(), plugin_name, nullptr);
1852 process_sp->ConnectRemote(debugger.GetOutputFile().get(), connect_url);
1859 size_t Platform::ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
1860 lldb_private::Status &error) {
1865 size_t Platform::GetSoftwareBreakpointTrapOpcode(Target &target,
1866 BreakpointSite *bp_site) {
1867 ArchSpec arch = target.GetArchitecture();
1868 const uint8_t *trap_opcode = nullptr;
1869 size_t trap_opcode_size = 0;
1871 switch (arch.GetMachine()) {
1872 case llvm::Triple::aarch64: {
1873 static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xd4};
1874 trap_opcode = g_aarch64_opcode;
1875 trap_opcode_size = sizeof(g_aarch64_opcode);
1878 // TODO: support big-endian arm and thumb trap codes.
1879 case llvm::Triple::arm: {
1880 // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the
1881 // linux kernel does otherwise.
1882 static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
1883 static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
1885 lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
1886 AddressClass addr_class = AddressClass::eUnknown;
1889 addr_class = bp_loc_sp->GetAddress().GetAddressClass();
1890 if (addr_class == AddressClass::eUnknown &&
1891 (bp_loc_sp->GetAddress().GetFileAddress() & 1))
1892 addr_class = AddressClass::eCodeAlternateISA;
1895 if (addr_class == AddressClass::eCodeAlternateISA) {
1896 trap_opcode = g_thumb_breakpoint_opcode;
1897 trap_opcode_size = sizeof(g_thumb_breakpoint_opcode);
1899 trap_opcode = g_arm_breakpoint_opcode;
1900 trap_opcode_size = sizeof(g_arm_breakpoint_opcode);
1904 case llvm::Triple::mips:
1905 case llvm::Triple::mips64: {
1906 static const uint8_t g_hex_opcode[] = {0x00, 0x00, 0x00, 0x0d};
1907 trap_opcode = g_hex_opcode;
1908 trap_opcode_size = sizeof(g_hex_opcode);
1911 case llvm::Triple::mipsel:
1912 case llvm::Triple::mips64el: {
1913 static const uint8_t g_hex_opcode[] = {0x0d, 0x00, 0x00, 0x00};
1914 trap_opcode = g_hex_opcode;
1915 trap_opcode_size = sizeof(g_hex_opcode);
1918 case llvm::Triple::systemz: {
1919 static const uint8_t g_hex_opcode[] = {0x00, 0x01};
1920 trap_opcode = g_hex_opcode;
1921 trap_opcode_size = sizeof(g_hex_opcode);
1924 case llvm::Triple::hexagon: {
1925 static const uint8_t g_hex_opcode[] = {0x0c, 0xdb, 0x00, 0x54};
1926 trap_opcode = g_hex_opcode;
1927 trap_opcode_size = sizeof(g_hex_opcode);
1930 case llvm::Triple::ppc:
1931 case llvm::Triple::ppc64: {
1932 static const uint8_t g_ppc_opcode[] = {0x7f, 0xe0, 0x00, 0x08};
1933 trap_opcode = g_ppc_opcode;
1934 trap_opcode_size = sizeof(g_ppc_opcode);
1937 case llvm::Triple::ppc64le: {
1938 static const uint8_t g_ppc64le_opcode[] = {0x08, 0x00, 0xe0, 0x7f}; // trap
1939 trap_opcode = g_ppc64le_opcode;
1940 trap_opcode_size = sizeof(g_ppc64le_opcode);
1943 case llvm::Triple::x86:
1944 case llvm::Triple::x86_64: {
1945 static const uint8_t g_i386_opcode[] = {0xCC};
1946 trap_opcode = g_i386_opcode;
1947 trap_opcode_size = sizeof(g_i386_opcode);
1952 "Unhandled architecture in Platform::GetSoftwareBreakpointTrapOpcode");
1956 if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size))
1957 return trap_opcode_size;