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 //===----------------------------------------------------------------------===//
16 // Other libraries and framework includes
17 #include "llvm/Support/FileSystem.h"
18 #include "llvm/Support/Path.h"
21 #include "lldb/Breakpoint/BreakpointIDList.h"
22 #include "lldb/Breakpoint/BreakpointLocation.h"
23 #include "lldb/Core/Debugger.h"
24 #include "lldb/Core/Module.h"
25 #include "lldb/Core/ModuleSpec.h"
26 #include "lldb/Core/PluginManager.h"
27 #include "lldb/Core/StreamFile.h"
28 #include "lldb/Host/FileSystem.h"
29 #include "lldb/Host/Host.h"
30 #include "lldb/Host/HostInfo.h"
31 #include "lldb/Host/OptionParser.h"
32 #include "lldb/Interpreter/OptionValueProperties.h"
33 #include "lldb/Interpreter/Property.h"
34 #include "lldb/Symbol/ObjectFile.h"
35 #include "lldb/Target/ModuleCache.h"
36 #include "lldb/Target/Platform.h"
37 #include "lldb/Target/Process.h"
38 #include "lldb/Target/Target.h"
39 #include "lldb/Target/UnixSignals.h"
40 #include "lldb/Utility/DataBufferHeap.h"
41 #include "lldb/Utility/FileSpec.h"
42 #include "lldb/Utility/Log.h"
43 #include "lldb/Utility/Status.h"
44 #include "lldb/Utility/StructuredData.h"
46 #include "llvm/Support/FileSystem.h"
48 // Define these constants from POSIX mman.h rather than include the file
49 // so that they will be correct even when compiled on Linux.
51 #define MAP_ANON 0x1000
54 using namespace lldb_private;
56 static uint32_t g_initialize_count = 0;
58 // Use a singleton function for g_local_platform_sp to avoid init
59 // constructors since LLDB is often part of a shared library
60 static PlatformSP &GetHostPlatformSP() {
61 static PlatformSP g_platform_sp;
65 const char *Platform::GetHostPlatformName() { return "host"; }
69 PropertyDefinition g_properties[] = {
70 {"use-module-cache", OptionValue::eTypeBoolean, true, true, nullptr,
71 nullptr, "Use module cache."},
72 {"module-cache-directory", OptionValue::eTypeFileSpec, true, 0, nullptr,
73 nullptr, "Root directory for cached modules."},
74 {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, nullptr, nullptr}};
76 enum { ePropertyUseModuleCache, ePropertyModuleCacheDirectory };
80 ConstString PlatformProperties::GetSettingName() {
81 static ConstString g_setting_name("platform");
82 return g_setting_name;
85 PlatformProperties::PlatformProperties() {
86 m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
87 m_collection_sp->Initialize(g_properties);
89 auto module_cache_dir = GetModuleCacheDirectory();
93 llvm::SmallString<64> user_home_dir;
94 if (!llvm::sys::path::home_directory(user_home_dir))
97 module_cache_dir = FileSpec(user_home_dir.c_str(), false);
98 module_cache_dir.AppendPathComponent(".lldb");
99 module_cache_dir.AppendPathComponent("module_cache");
100 SetModuleCacheDirectory(module_cache_dir);
103 bool PlatformProperties::GetUseModuleCache() const {
104 const auto idx = ePropertyUseModuleCache;
105 return m_collection_sp->GetPropertyAtIndexAsBoolean(
106 nullptr, idx, g_properties[idx].default_uint_value != 0);
109 bool PlatformProperties::SetUseModuleCache(bool use_module_cache) {
110 return m_collection_sp->SetPropertyAtIndexAsBoolean(
111 nullptr, ePropertyUseModuleCache, use_module_cache);
114 FileSpec PlatformProperties::GetModuleCacheDirectory() const {
115 return m_collection_sp->GetPropertyAtIndexAsFileSpec(
116 nullptr, ePropertyModuleCacheDirectory);
119 bool PlatformProperties::SetModuleCacheDirectory(const FileSpec &dir_spec) {
120 return m_collection_sp->SetPropertyAtIndexAsFileSpec(
121 nullptr, ePropertyModuleCacheDirectory, dir_spec);
124 //------------------------------------------------------------------
125 /// Get the native host platform plug-in.
127 /// There should only be one of these for each host that LLDB runs
128 /// upon that should be statically compiled in and registered using
129 /// preprocessor macros or other similar build mechanisms.
131 /// This platform will be used as the default platform when launching
132 /// or attaching to processes unless another platform is specified.
133 //------------------------------------------------------------------
134 PlatformSP Platform::GetHostPlatform() { return GetHostPlatformSP(); }
136 static std::vector<PlatformSP> &GetPlatformList() {
137 static std::vector<PlatformSP> g_platform_list;
138 return g_platform_list;
141 static std::recursive_mutex &GetPlatformListMutex() {
142 static std::recursive_mutex g_mutex;
146 void Platform::Initialize() { g_initialize_count++; }
148 void Platform::Terminate() {
149 if (g_initialize_count > 0) {
150 if (--g_initialize_count == 0) {
151 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
152 GetPlatformList().clear();
157 const PlatformPropertiesSP &Platform::GetGlobalPlatformProperties() {
158 static const auto g_settings_sp(std::make_shared<PlatformProperties>());
159 return g_settings_sp;
162 void Platform::SetHostPlatform(const lldb::PlatformSP &platform_sp) {
163 // The native platform should use its static void Platform::Initialize()
164 // function to register itself as the native platform.
165 GetHostPlatformSP() = platform_sp;
168 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
169 GetPlatformList().push_back(platform_sp);
173 Status Platform::GetFileWithUUID(const FileSpec &platform_file,
174 const UUID *uuid_ptr, FileSpec &local_file) {
175 // Default to the local case
176 local_file = platform_file;
181 Platform::LocateExecutableScriptingResources(Target *target, Module &module,
182 Stream *feedback_stream) {
183 return FileSpecList();
187 // Platform::FindPlugin (Process *process, const ConstString &plugin_name)
189 // PlatformCreateInstance create_callback = nullptr;
193 // PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name);
194 // if (create_callback)
199 // arch = process->GetTarget().GetArchitecture();
201 // PlatformSP platform_sp(create_callback(process, &arch));
203 // return platform_sp;
208 // for (uint32_t idx = 0; (create_callback =
209 // PluginManager::GetPlatformCreateCallbackAtIndex(idx)) != nullptr;
212 // PlatformSP platform_sp(create_callback(process, nullptr));
214 // return platform_sp;
217 // return PlatformSP();
220 Status Platform::GetSharedModule(const ModuleSpec &module_spec,
221 Process *process, ModuleSP &module_sp,
222 const FileSpecList *module_search_paths_ptr,
223 ModuleSP *old_module_sp_ptr,
224 bool *did_create_ptr) {
226 return ModuleList::GetSharedModule(
227 module_spec, module_sp, module_search_paths_ptr, old_module_sp_ptr,
228 did_create_ptr, false);
230 return GetRemoteSharedModule(module_spec, process, module_sp,
231 [&](const ModuleSpec &spec) {
232 Status error = ModuleList::GetSharedModule(
233 spec, module_sp, module_search_paths_ptr,
234 old_module_sp_ptr, did_create_ptr, false);
235 if (error.Success() && module_sp)
236 module_sp->SetPlatformFileSpec(
243 bool Platform::GetModuleSpec(const FileSpec &module_file_spec,
244 const ArchSpec &arch, ModuleSpec &module_spec) {
245 ModuleSpecList module_specs;
246 if (ObjectFile::GetModuleSpecifications(module_file_spec, 0, 0,
250 ModuleSpec matched_module_spec;
251 return module_specs.FindMatchingModuleSpec(ModuleSpec(module_file_spec, arch),
255 PlatformSP Platform::Find(const ConstString &name) {
257 static ConstString g_host_platform_name("host");
258 if (name == g_host_platform_name)
259 return GetHostPlatform();
261 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
262 for (const auto &platform_sp : GetPlatformList()) {
263 if (platform_sp->GetName() == name)
270 PlatformSP Platform::Create(const ConstString &name, Status &error) {
271 PlatformCreateInstance create_callback = nullptr;
272 lldb::PlatformSP platform_sp;
274 static ConstString g_host_platform_name("host");
275 if (name == g_host_platform_name)
276 return GetHostPlatform();
279 PluginManager::GetPlatformCreateCallbackForPluginName(name);
281 platform_sp = create_callback(true, nullptr);
283 error.SetErrorStringWithFormat(
284 "unable to find a plug-in for the platform named \"%s\"",
287 error.SetErrorString("invalid platform name");
290 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
291 GetPlatformList().push_back(platform_sp);
297 PlatformSP Platform::Create(const ArchSpec &arch, ArchSpec *platform_arch_ptr,
299 lldb::PlatformSP platform_sp;
300 if (arch.IsValid()) {
303 // First try exact arch matches across all platforms already created
304 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
305 for (const auto &platform_sp : GetPlatformList()) {
306 if (platform_sp->IsCompatibleArchitecture(arch, true,
311 // Next try compatible arch matches across all platforms already created
312 for (const auto &platform_sp : GetPlatformList()) {
313 if (platform_sp->IsCompatibleArchitecture(arch, false,
319 PlatformCreateInstance create_callback;
320 // First try exact arch matches across all platform plug-ins
322 for (idx = 0; (create_callback =
323 PluginManager::GetPlatformCreateCallbackAtIndex(idx));
325 if (create_callback) {
326 platform_sp = create_callback(false, &arch);
328 platform_sp->IsCompatibleArchitecture(arch, true,
329 platform_arch_ptr)) {
330 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
331 GetPlatformList().push_back(platform_sp);
336 // Next try compatible 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, false,
344 platform_arch_ptr)) {
345 std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
346 GetPlatformList().push_back(platform_sp);
352 error.SetErrorString("invalid platform name");
353 if (platform_arch_ptr)
354 platform_arch_ptr->Clear();
359 ArchSpec Platform::GetAugmentedArchSpec(Platform *platform, llvm::StringRef triple) {
361 return platform->GetAugmentedArchSpec(triple);
362 return HostInfo::GetAugmentedArchSpec(triple);
365 //------------------------------------------------------------------
366 /// Default Constructor
367 //------------------------------------------------------------------
368 Platform::Platform(bool is_host)
369 : m_is_host(is_host), m_os_version_set_while_connected(false),
370 m_system_arch_set_while_connected(false), m_sdk_sysroot(), m_sdk_build(),
371 m_working_dir(), m_remote_url(), m_name(), m_major_os_version(UINT32_MAX),
372 m_minor_os_version(UINT32_MAX), m_update_os_version(UINT32_MAX),
373 m_system_arch(), m_mutex(), m_uid_map(), m_gid_map(),
374 m_max_uid_name_len(0), m_max_gid_name_len(0), m_supports_rsync(false),
375 m_rsync_opts(), m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(),
376 m_ignores_remote_hostname(false), m_trap_handlers(),
377 m_calculated_trap_handlers(false),
378 m_module_cache(llvm::make_unique<ModuleCache>()) {
379 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
381 log->Printf("%p Platform::Platform()", static_cast<void *>(this));
384 //------------------------------------------------------------------
387 /// The destructor is virtual since this class is designed to be
388 /// inherited from by the plug-in instance.
389 //------------------------------------------------------------------
390 Platform::~Platform() {
391 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
393 log->Printf("%p Platform::~Platform()", static_cast<void *>(this));
396 void Platform::GetStatus(Stream &strm) {
397 uint32_t major = UINT32_MAX;
398 uint32_t minor = UINT32_MAX;
399 uint32_t update = UINT32_MAX;
401 strm.Printf(" Platform: %s\n", GetPluginName().GetCString());
403 ArchSpec arch(GetSystemArchitecture());
404 if (arch.IsValid()) {
405 if (!arch.GetTriple().str().empty()) {
406 strm.Printf(" Triple: ");
407 arch.DumpTriple(strm);
412 if (GetOSVersion(major, minor, update)) {
413 strm.Printf("OS Version: %u", major);
414 if (minor != UINT32_MAX)
415 strm.Printf(".%u", minor);
416 if (update != UINT32_MAX)
417 strm.Printf(".%u", update);
419 if (GetOSBuildString(s))
420 strm.Printf(" (%s)", s.c_str());
425 if (GetOSKernelDescription(s))
426 strm.Printf(" Kernel: %s\n", s.c_str());
429 strm.Printf(" Hostname: %s\n", GetHostname());
431 const bool is_connected = IsConnected();
433 strm.Printf(" Hostname: %s\n", GetHostname());
434 strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no");
437 if (GetWorkingDirectory()) {
438 strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetCString());
443 std::string specific_info(GetPlatformSpecificConnectionInformation());
445 if (!specific_info.empty())
446 strm.Printf("Platform-specific connection: %s\n", specific_info.c_str());
449 bool Platform::GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update,
451 std::lock_guard<std::mutex> guard(m_mutex);
453 bool success = m_major_os_version != UINT32_MAX;
456 // We have a local host platform
457 success = HostInfo::GetOSVersion(m_major_os_version, m_minor_os_version,
458 m_update_os_version);
459 m_os_version_set_while_connected = success;
462 // We have a remote platform. We can only fetch the remote
463 // OS version if we are connected, and we don't want to do it
466 const bool is_connected = IsConnected();
470 // We have valid OS version info, check to make sure it wasn't
471 // manually set prior to connecting. If it was manually set prior
472 // to connecting, then lets fetch the actual OS version info
473 // if we are now connected.
474 if (is_connected && !m_os_version_set_while_connected)
477 // We don't have valid OS version info, fetch it if we are connected
478 fetch = is_connected;
482 success = GetRemoteOSVersion();
483 m_os_version_set_while_connected = success;
488 major = m_major_os_version;
489 minor = m_minor_os_version;
490 update = m_update_os_version;
491 } else if (process) {
492 // Check with the process in case it can answer the question if
493 // a process was provided
494 return process->GetHostOSVersion(major, minor, update);
499 bool Platform::GetOSBuildString(std::string &s) {
503 #if !defined(__linux__)
504 return HostInfo::GetOSBuildString(s);
509 return GetRemoteOSBuildString(s);
512 bool Platform::GetOSKernelDescription(std::string &s) {
514 #if !defined(__linux__)
515 return HostInfo::GetOSKernelDescription(s);
520 return GetRemoteOSKernelDescription(s);
523 void Platform::AddClangModuleCompilationOptions(
524 Target *target, std::vector<std::string> &options) {
525 std::vector<std::string> default_compilation_options = {
526 "-x", "c++", "-Xclang", "-nostdsysteminc", "-Xclang", "-nostdsysteminc"};
528 options.insert(options.end(), default_compilation_options.begin(),
529 default_compilation_options.end());
532 FileSpec Platform::GetWorkingDirectory() {
534 llvm::SmallString<64> cwd;
535 if (llvm::sys::fs::current_path(cwd))
538 return FileSpec(cwd, true);
541 m_working_dir = GetRemoteWorkingDirectory();
542 return m_working_dir;
546 struct RecurseCopyBaton {
548 Platform *platform_ptr;
552 static FileSpec::EnumerateDirectoryResult
553 RecurseCopy_Callback(void *baton, llvm::sys::fs::file_type ft,
554 const FileSpec &src) {
555 RecurseCopyBaton *rc_baton = (RecurseCopyBaton *)baton;
556 namespace fs = llvm::sys::fs;
558 case fs::file_type::fifo_file:
559 case fs::file_type::socket_file:
560 // we have no way to copy pipes and sockets - ignore them and continue
561 return FileSpec::eEnumerateDirectoryResultNext;
564 case fs::file_type::directory_file: {
565 // make the new directory and get in there
566 FileSpec dst_dir = rc_baton->dst;
567 if (!dst_dir.GetFilename())
568 dst_dir.GetFilename() = src.GetLastPathComponent();
569 Status error = rc_baton->platform_ptr->MakeDirectory(
570 dst_dir, lldb::eFilePermissionsDirectoryDefault);
572 rc_baton->error.SetErrorStringWithFormat(
573 "unable to setup directory %s on remote end", dst_dir.GetCString());
574 return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
578 std::string src_dir_path(src.GetPath());
580 // Make a filespec that only fills in the directory of a FileSpec so
581 // when we enumerate we can quickly fill in the filename for dst copies
582 FileSpec recurse_dst;
583 recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
584 RecurseCopyBaton rc_baton2 = {recurse_dst, rc_baton->platform_ptr,
586 FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
587 RecurseCopy_Callback, &rc_baton2);
588 if (rc_baton2.error.Fail()) {
589 rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
590 return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
592 return FileSpec::eEnumerateDirectoryResultNext;
595 case fs::file_type::symlink_file: {
596 // copy the file and keep going
597 FileSpec dst_file = rc_baton->dst;
598 if (!dst_file.GetFilename())
599 dst_file.GetFilename() = src.GetFilename();
601 FileSpec src_resolved;
603 rc_baton->error = FileSystem::Readlink(src, src_resolved);
605 if (rc_baton->error.Fail())
606 return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
609 rc_baton->platform_ptr->CreateSymlink(dst_file, src_resolved);
611 if (rc_baton->error.Fail())
612 return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
614 return FileSpec::eEnumerateDirectoryResultNext;
617 case fs::file_type::regular_file: {
618 // copy the file and keep going
619 FileSpec dst_file = rc_baton->dst;
620 if (!dst_file.GetFilename())
621 dst_file.GetFilename() = src.GetFilename();
622 Status err = rc_baton->platform_ptr->PutFile(src, dst_file);
624 rc_baton->error.SetErrorString(err.AsCString());
625 return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
627 return FileSpec::eEnumerateDirectoryResultNext;
631 rc_baton->error.SetErrorStringWithFormat(
632 "invalid file detected during copy: %s", src.GetPath().c_str());
633 return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
636 llvm_unreachable("Unhandled file_type!");
639 Status Platform::Install(const FileSpec &src, const FileSpec &dst) {
642 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
644 log->Printf("Platform::Install (src='%s', dst='%s')", src.GetPath().c_str(),
645 dst.GetPath().c_str());
646 FileSpec fixed_dst(dst);
648 if (!fixed_dst.GetFilename())
649 fixed_dst.GetFilename() = src.GetFilename();
651 FileSpec working_dir = GetWorkingDirectory();
654 if (dst.GetDirectory()) {
655 const char first_dst_dir_char = dst.GetDirectory().GetCString()[0];
656 if (first_dst_dir_char == '/' || first_dst_dir_char == '\\') {
657 fixed_dst.GetDirectory() = dst.GetDirectory();
659 // If the fixed destination file doesn't have a directory yet,
660 // then we must have a relative path. We will resolve this relative
661 // path against the platform's working directory
662 if (!fixed_dst.GetDirectory()) {
663 FileSpec relative_spec;
666 relative_spec = working_dir;
667 relative_spec.AppendPathComponent(dst.GetPath());
668 fixed_dst.GetDirectory() = relative_spec.GetDirectory();
670 error.SetErrorStringWithFormat(
671 "platform working directory must be valid for relative path '%s'",
672 dst.GetPath().c_str());
678 fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
680 error.SetErrorStringWithFormat(
681 "platform working directory must be valid for relative path '%s'",
682 dst.GetPath().c_str());
688 fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
690 error.SetErrorStringWithFormat("platform working directory must be valid "
691 "when destination directory is empty");
697 log->Printf("Platform::Install (src='%s', dst='%s') fixed_dst='%s'",
698 src.GetPath().c_str(), dst.GetPath().c_str(),
699 fixed_dst.GetPath().c_str());
701 if (GetSupportsRSync()) {
702 error = PutFile(src, dst);
704 namespace fs = llvm::sys::fs;
705 switch (fs::get_file_type(src.GetPath(), false)) {
706 case fs::file_type::directory_file: {
707 llvm::sys::fs::remove(fixed_dst.GetPath());
708 uint32_t permissions = src.GetPermissions();
709 if (permissions == 0)
710 permissions = eFilePermissionsDirectoryDefault;
711 error = MakeDirectory(fixed_dst, permissions);
712 if (error.Success()) {
713 // Make a filespec that only fills in the directory of a FileSpec so
714 // when we enumerate we can quickly fill in the filename for dst copies
715 FileSpec recurse_dst;
716 recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
717 std::string src_dir_path(src.GetPath());
718 RecurseCopyBaton baton = {recurse_dst, this, Status()};
719 FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
720 RecurseCopy_Callback, &baton);
725 case fs::file_type::regular_file:
726 llvm::sys::fs::remove(fixed_dst.GetPath());
727 error = PutFile(src, fixed_dst);
730 case fs::file_type::symlink_file: {
731 llvm::sys::fs::remove(fixed_dst.GetPath());
732 FileSpec src_resolved;
733 error = FileSystem::Readlink(src, src_resolved);
735 error = CreateSymlink(dst, src_resolved);
737 case fs::file_type::fifo_file:
738 error.SetErrorString("platform install doesn't handle pipes");
740 case fs::file_type::socket_file:
741 error.SetErrorString("platform install doesn't handle sockets");
744 error.SetErrorString(
745 "platform install doesn't handle non file or directory items");
752 bool Platform::SetWorkingDirectory(const FileSpec &file_spec) {
754 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
755 LLDB_LOG(log, "{0}", file_spec);
756 if (std::error_code ec = llvm::sys::fs::set_current_path(file_spec.GetPath())) {
757 LLDB_LOG(log, "error: {0}", ec.message());
762 m_working_dir.Clear();
763 return SetRemoteWorkingDirectory(file_spec);
767 Status Platform::MakeDirectory(const FileSpec &file_spec,
768 uint32_t permissions) {
770 return llvm::sys::fs::create_directory(file_spec.GetPath(), permissions);
773 error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
774 GetPluginName().GetCString(),
775 LLVM_PRETTY_FUNCTION);
780 Status Platform::GetFilePermissions(const FileSpec &file_spec,
781 uint32_t &file_permissions) {
783 auto Value = llvm::sys::fs::getPermissions(file_spec.GetPath());
785 file_permissions = Value.get();
786 return Status(Value.getError());
789 error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
790 GetPluginName().GetCString(),
791 LLVM_PRETTY_FUNCTION);
796 Status Platform::SetFilePermissions(const FileSpec &file_spec,
797 uint32_t file_permissions) {
799 auto Perms = static_cast<llvm::sys::fs::perms>(file_permissions);
800 return llvm::sys::fs::setPermissions(file_spec.GetPath(), Perms);
803 error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
804 GetPluginName().GetCString(),
805 LLVM_PRETTY_FUNCTION);
810 ConstString Platform::GetName() { return GetPluginName(); }
812 const char *Platform::GetHostname() {
818 return m_name.c_str();
821 ConstString Platform::GetFullNameForDylib(ConstString basename) {
825 bool Platform::SetRemoteWorkingDirectory(const FileSpec &working_dir) {
826 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
828 log->Printf("Platform::SetRemoteWorkingDirectory('%s')",
829 working_dir.GetCString());
830 m_working_dir = working_dir;
834 const char *Platform::GetUserName(uint32_t uid) {
835 #if !defined(LLDB_DISABLE_POSIX)
836 const char *user_name = GetCachedUserName(uid);
841 if (HostInfo::LookupUserName(uid, name))
842 return SetCachedUserName(uid, name.c_str(), name.size());
848 const char *Platform::GetGroupName(uint32_t gid) {
849 #if !defined(LLDB_DISABLE_POSIX)
850 const char *group_name = GetCachedGroupName(gid);
855 if (HostInfo::LookupGroupName(gid, name))
856 return SetCachedGroupName(gid, name.c_str(), name.size());
862 bool Platform::SetOSVersion(uint32_t major, uint32_t minor, uint32_t update) {
864 // We don't need anyone setting the OS version for the host platform,
865 // we should be able to figure it out by calling
866 // HostInfo::GetOSVersion(...).
869 // We have a remote platform, allow setting the target OS version if
870 // we aren't connected, since if we are connected, we should be able to
871 // request the remote OS version from the connected platform.
875 // We aren't connected and we might want to set the OS version
876 // ahead of time before we connect so we can peruse files and
877 // use a local SDK or PDK cache of support files to disassemble
878 // or do other things.
879 m_major_os_version = major;
880 m_minor_os_version = minor;
881 m_update_os_version = update;
889 Platform::ResolveExecutable(const ModuleSpec &module_spec,
890 lldb::ModuleSP &exe_module_sp,
891 const FileSpecList *module_search_paths_ptr) {
893 if (module_spec.GetFileSpec().Exists()) {
894 if (module_spec.GetArchitecture().IsValid()) {
895 error = ModuleList::GetSharedModule(module_spec, exe_module_sp,
896 module_search_paths_ptr, nullptr,
899 // No valid architecture was specified, ask the platform for
900 // the architectures that we should be using (in the correct order)
901 // and see if we can find a match that way
902 ModuleSpec arch_module_spec(module_spec);
903 for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
904 idx, arch_module_spec.GetArchitecture());
906 error = ModuleList::GetSharedModule(arch_module_spec, exe_module_sp,
907 module_search_paths_ptr, nullptr,
909 // Did we find an executable using one of the
910 if (error.Success() && exe_module_sp)
915 error.SetErrorStringWithFormat("'%s' does not exist",
916 module_spec.GetFileSpec().GetPath().c_str());
921 Status Platform::ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec,
922 FileSpec &sym_file) {
924 if (sym_spec.GetSymbolFileSpec().Exists())
925 sym_file = sym_spec.GetSymbolFileSpec();
927 error.SetErrorString("unable to resolve symbol file");
931 bool Platform::ResolveRemotePath(const FileSpec &platform_path,
932 FileSpec &resolved_platform_path) {
933 resolved_platform_path = platform_path;
934 return resolved_platform_path.ResolvePath();
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
946 // system architecture if we are connected, and we don't want to do it
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
954 // manually set prior to connecting. If it was manually set prior
955 // to connecting, then lets fetch the actual OS version info
956 // if we are now connected.
957 if (is_connected && !m_system_arch_set_while_connected)
960 // We don't have valid OS version info, fetch it if we are connected
961 fetch = is_connected;
965 m_system_arch = GetRemoteSystemArchitecture();
966 m_system_arch_set_while_connected = m_system_arch.IsValid();
969 return m_system_arch;
972 ArchSpec Platform::GetAugmentedArchSpec(llvm::StringRef triple) {
975 llvm::Triple normalized_triple(llvm::Triple::normalize(triple));
976 if (!ArchSpec::ContainsOnlyArch(normalized_triple))
977 return ArchSpec(triple);
979 if (auto kind = HostInfo::ParseArchitectureKind(triple))
980 return HostInfo::GetArchitecture(*kind);
982 ArchSpec compatible_arch;
983 ArchSpec raw_arch(triple);
984 if (!IsCompatibleArchitecture(raw_arch, false, &compatible_arch))
987 if (!compatible_arch.IsValid())
988 return ArchSpec(normalized_triple);
990 const llvm::Triple &compatible_triple = compatible_arch.GetTriple();
991 if (normalized_triple.getVendorName().empty())
992 normalized_triple.setVendor(compatible_triple.getVendor());
993 if (normalized_triple.getOSName().empty())
994 normalized_triple.setOS(compatible_triple.getOS());
995 if (normalized_triple.getEnvironmentName().empty())
996 normalized_triple.setEnvironment(compatible_triple.getEnvironment());
997 return ArchSpec(normalized_triple);
1000 Status Platform::ConnectRemote(Args &args) {
1003 error.SetErrorStringWithFormat("The currently selected platform (%s) is "
1004 "the host platform and is always connected.",
1005 GetPluginName().GetCString());
1007 error.SetErrorStringWithFormat(
1008 "Platform::ConnectRemote() is not supported by %s",
1009 GetPluginName().GetCString());
1013 Status Platform::DisconnectRemote() {
1016 error.SetErrorStringWithFormat("The currently selected platform (%s) is "
1017 "the host platform and is always connected.",
1018 GetPluginName().GetCString());
1020 error.SetErrorStringWithFormat(
1021 "Platform::DisconnectRemote() is not supported by %s",
1022 GetPluginName().GetCString());
1026 bool Platform::GetProcessInfo(lldb::pid_t pid,
1027 ProcessInstanceInfo &process_info) {
1028 // Take care of the host case so that each subclass can just
1029 // call this function to get the host functionality.
1031 return Host::GetProcessInfo(pid, process_info);
1035 uint32_t Platform::FindProcesses(const ProcessInstanceInfoMatch &match_info,
1036 ProcessInstanceInfoList &process_infos) {
1037 // Take care of the host case so that each subclass can just
1038 // call this function to get the host functionality.
1039 uint32_t match_count = 0;
1041 match_count = Host::FindProcesses(match_info, process_infos);
1045 Status Platform::LaunchProcess(ProcessLaunchInfo &launch_info) {
1047 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1049 log->Printf("Platform::%s()", __FUNCTION__);
1051 // Take care of the host case so that each subclass can just
1052 // call this function to get the host functionality.
1054 if (::getenv("LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY"))
1055 launch_info.GetFlags().Set(eLaunchFlagLaunchInTTY);
1057 if (launch_info.GetFlags().Test(eLaunchFlagLaunchInShell)) {
1058 const bool is_localhost = true;
1059 const bool will_debug = launch_info.GetFlags().Test(eLaunchFlagDebug);
1060 const bool first_arg_is_full_shell_command = false;
1061 uint32_t num_resumes = GetResumeCountForLaunchInfo(launch_info);
1063 const FileSpec &shell = launch_info.GetShell();
1064 const char *shell_str = (shell) ? shell.GetPath().c_str() : "<null>";
1066 "Platform::%s GetResumeCountForLaunchInfo() returned %" PRIu32
1068 __FUNCTION__, num_resumes, shell_str);
1071 if (!launch_info.ConvertArgumentsForLaunchingInShell(
1072 error, is_localhost, will_debug, first_arg_is_full_shell_command,
1075 } else if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments)) {
1076 error = ShellExpandArguments(launch_info);
1078 error.SetErrorStringWithFormat("shell expansion failed (reason: %s). "
1079 "consider launching with 'process "
1081 error.AsCString("unknown"));
1087 log->Printf("Platform::%s final launch_info resume count: %" PRIu32,
1088 __FUNCTION__, launch_info.GetResumeCount());
1090 error = Host::LaunchProcess(launch_info);
1092 error.SetErrorString(
1093 "base lldb_private::Platform class can't launch remote processes");
1097 Status Platform::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
1099 return Host::ShellExpandArguments(launch_info);
1100 return Status("base lldb_private::Platform class can't expand arguments");
1103 Status Platform::KillProcess(const lldb::pid_t pid) {
1104 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1106 log->Printf("Platform::%s, pid %" PRIu64, __FUNCTION__, pid);
1108 // Try to find a process plugin to handle this Kill request. If we can't,
1110 // the default OS implementation.
1111 size_t num_debuggers = Debugger::GetNumDebuggers();
1112 for (size_t didx = 0; didx < num_debuggers; ++didx) {
1113 DebuggerSP debugger = Debugger::GetDebuggerAtIndex(didx);
1114 lldb_private::TargetList &targets = debugger->GetTargetList();
1115 for (int tidx = 0; tidx < targets.GetNumTargets(); ++tidx) {
1116 ProcessSP process = targets.GetTargetAtIndex(tidx)->GetProcessSP();
1117 if (process->GetID() == pid)
1118 return process->Destroy(true);
1124 "base lldb_private::Platform class can't kill remote processes unless "
1125 "they are controlled by a process plugin");
1127 Host::Kill(pid, SIGTERM);
1132 Platform::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
1133 Target *target, // Can be nullptr, if nullptr create a
1134 // new target, else use existing one
1136 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1138 log->Printf("Platform::%s entered (target %p)", __FUNCTION__,
1139 static_cast<void *>(target));
1141 ProcessSP process_sp;
1142 // Make sure we stop at the entry point
1143 launch_info.GetFlags().Set(eLaunchFlagDebug);
1144 // We always launch the process we are going to debug in a separate process
1145 // group, since then we can handle ^C interrupts ourselves w/o having to worry
1146 // about the target getting them as well.
1147 launch_info.SetLaunchInSeparateProcessGroup(true);
1149 // Allow any StructuredData process-bound plugins to adjust the launch info
1152 bool iteration_complete = false;
1153 // Note iteration can't simply go until a nullptr callback is returned, as
1154 // it is valid for a plugin to not supply a filter.
1155 auto get_filter_func = PluginManager::GetStructuredDataFilterCallbackAtIndex;
1156 for (auto filter_callback = get_filter_func(i, iteration_complete);
1157 !iteration_complete;
1158 filter_callback = get_filter_func(++i, iteration_complete)) {
1159 if (filter_callback) {
1160 // Give this ProcessLaunchInfo filter a chance to adjust the launch
1162 error = (*filter_callback)(launch_info, target);
1163 if (!error.Success()) {
1165 log->Printf("Platform::%s() StructuredDataPlugin launch "
1173 error = LaunchProcess(launch_info);
1174 if (error.Success()) {
1176 log->Printf("Platform::%s LaunchProcess() call succeeded (pid=%" PRIu64
1178 __FUNCTION__, launch_info.GetProcessID());
1179 if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) {
1180 ProcessAttachInfo attach_info(launch_info);
1181 process_sp = Attach(attach_info, debugger, target, error);
1184 log->Printf("Platform::%s Attach() succeeded, Process plugin: %s",
1185 __FUNCTION__, process_sp->GetPluginName().AsCString());
1186 launch_info.SetHijackListener(attach_info.GetHijackListener());
1188 // Since we attached to the process, it will think it needs to detach
1189 // if the process object just goes away without an explicit call to
1190 // Process::Kill() or Process::Detach(), so let it know to kill the
1191 // process if this happens.
1192 process_sp->SetShouldDetach(false);
1194 // If we didn't have any file actions, the pseudo terminal might
1195 // have been used where the slave side was given as the file to
1196 // open for stdin/out/err after we have already opened the master
1197 // so we can read/write stdin/out/err.
1198 int pty_fd = launch_info.GetPTY().ReleaseMasterFileDescriptor();
1199 if (pty_fd != PseudoTerminal::invalid_fd) {
1200 process_sp->SetSTDIOFileDescriptor(pty_fd);
1204 log->Printf("Platform::%s Attach() failed: %s", __FUNCTION__,
1209 log->Printf("Platform::%s LaunchProcess() returned launch_info with "
1210 "invalid process id",
1215 log->Printf("Platform::%s LaunchProcess() failed: %s", __FUNCTION__,
1223 Platform::GetPlatformForArchitecture(const ArchSpec &arch,
1224 ArchSpec *platform_arch_ptr) {
1225 lldb::PlatformSP platform_sp;
1228 platform_sp = Platform::Create(arch, platform_arch_ptr, error);
1232 //------------------------------------------------------------------
1233 /// Lets a platform answer if it is compatible with a given
1234 /// architecture and the target triple contained within.
1235 //------------------------------------------------------------------
1236 bool Platform::IsCompatibleArchitecture(const ArchSpec &arch,
1237 bool exact_arch_match,
1238 ArchSpec *compatible_arch_ptr) {
1239 // If the architecture is invalid, we must answer true...
1240 if (arch.IsValid()) {
1241 ArchSpec platform_arch;
1242 // Try for an exact architecture match first.
1243 if (exact_arch_match) {
1244 for (uint32_t arch_idx = 0;
1245 GetSupportedArchitectureAtIndex(arch_idx, platform_arch);
1247 if (arch.IsExactMatch(platform_arch)) {
1248 if (compatible_arch_ptr)
1249 *compatible_arch_ptr = platform_arch;
1254 for (uint32_t arch_idx = 0;
1255 GetSupportedArchitectureAtIndex(arch_idx, platform_arch);
1257 if (arch.IsCompatibleMatch(platform_arch)) {
1258 if (compatible_arch_ptr)
1259 *compatible_arch_ptr = platform_arch;
1265 if (compatible_arch_ptr)
1266 compatible_arch_ptr->Clear();
1270 Status Platform::PutFile(const FileSpec &source, const FileSpec &destination,
1271 uint32_t uid, uint32_t gid) {
1272 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
1274 log->Printf("[PutFile] Using block by block transfer....\n");
1276 uint32_t source_open_options =
1277 File::eOpenOptionRead | File::eOpenOptionCloseOnExec;
1278 namespace fs = llvm::sys::fs;
1279 if (fs::is_symlink_file(source.GetPath()))
1280 source_open_options |= File::eOpenOptionDontFollowSymlinks;
1282 File source_file(source, source_open_options, lldb::eFilePermissionsUserRW);
1284 uint32_t permissions = source_file.GetPermissions(error);
1285 if (permissions == 0)
1286 permissions = lldb::eFilePermissionsFileDefault;
1288 if (!source_file.IsValid())
1289 return Status("PutFile: unable to open source file");
1290 lldb::user_id_t dest_file = OpenFile(
1291 destination, File::eOpenOptionCanCreate | File::eOpenOptionWrite |
1292 File::eOpenOptionTruncate | File::eOpenOptionCloseOnExec,
1293 permissions, error);
1295 log->Printf("dest_file = %" PRIu64 "\n", dest_file);
1299 if (dest_file == UINT64_MAX)
1300 return Status("unable to open target file");
1301 lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
1302 uint64_t offset = 0;
1304 size_t bytes_read = buffer_sp->GetByteSize();
1305 error = source_file.Read(buffer_sp->GetBytes(), bytes_read);
1306 if (error.Fail() || bytes_read == 0)
1309 const uint64_t bytes_written =
1310 WriteFile(dest_file, offset, buffer_sp->GetBytes(), bytes_read, error);
1314 offset += bytes_written;
1315 if (bytes_written != bytes_read) {
1316 // We didn't write the correct number of bytes, so adjust
1317 // the file position in the source file we are reading from...
1318 source_file.SeekFromStart(offset);
1321 CloseFile(dest_file, error);
1323 if (uid == UINT32_MAX && gid == UINT32_MAX)
1331 Status Platform::GetFile(const FileSpec &source, const FileSpec &destination) {
1332 Status error("unimplemented");
1337 Platform::CreateSymlink(const FileSpec &src, // The name of the link is in src
1338 const FileSpec &dst) // The symlink points to dst
1340 Status error("unimplemented");
1344 bool Platform::GetFileExists(const lldb_private::FileSpec &file_spec) {
1348 Status Platform::Unlink(const FileSpec &path) {
1349 Status error("unimplemented");
1353 MmapArgList Platform::GetMmapArgumentList(const ArchSpec &arch, addr_t addr,
1354 addr_t length, unsigned prot,
1355 unsigned flags, addr_t fd,
1357 uint64_t flags_platform = 0;
1358 if (flags & eMmapFlagsPrivate)
1359 flags_platform |= MAP_PRIVATE;
1360 if (flags & eMmapFlagsAnon)
1361 flags_platform |= MAP_ANON;
1363 MmapArgList args({addr, length, prot, flags_platform, fd, offset});
1367 lldb_private::Status Platform::RunShellCommand(
1368 const char *command, // Shouldn't be nullptr
1370 working_dir, // Pass empty FileSpec to use the current working directory
1371 int *status_ptr, // Pass nullptr if you don't want the process exit status
1372 int *signo_ptr, // Pass nullptr if you don't want the signal that caused the
1375 *command_output, // Pass nullptr if you don't want the command output
1377 timeout_sec) // Timeout in seconds to wait for shell program to finish
1380 return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr,
1381 command_output, timeout_sec);
1383 return Status("unimplemented");
1386 bool Platform::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
1390 auto Result = llvm::sys::fs::md5_contents(file_spec.GetPath());
1393 std::tie(high, low) = Result->words();
1397 void Platform::SetLocalCacheDirectory(const char *local) {
1398 m_local_cache_directory.assign(local);
1401 const char *Platform::GetLocalCacheDirectory() {
1402 return m_local_cache_directory.c_str();
1405 static OptionDefinition g_rsync_option_table[] = {
1406 {LLDB_OPT_SET_ALL, false, "rsync", 'r', OptionParser::eNoArgument, nullptr,
1407 nullptr, 0, eArgTypeNone, "Enable rsync."},
1408 {LLDB_OPT_SET_ALL, false, "rsync-opts", 'R',
1409 OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCommandName,
1410 "Platform-specific options required for rsync to work."},
1411 {LLDB_OPT_SET_ALL, false, "rsync-prefix", 'P',
1412 OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCommandName,
1413 "Platform-specific rsync prefix put before the remote path."},
1414 {LLDB_OPT_SET_ALL, false, "ignore-remote-hostname", 'i',
1415 OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
1416 "Do not automatically fill in the remote hostname when composing the "
1420 static OptionDefinition g_ssh_option_table[] = {
1421 {LLDB_OPT_SET_ALL, false, "ssh", 's', OptionParser::eNoArgument, nullptr,
1422 nullptr, 0, eArgTypeNone, "Enable SSH."},
1423 {LLDB_OPT_SET_ALL, false, "ssh-opts", 'S', OptionParser::eRequiredArgument,
1424 nullptr, nullptr, 0, eArgTypeCommandName,
1425 "Platform-specific options required for SSH to work."},
1428 static OptionDefinition g_caching_option_table[] = {
1429 {LLDB_OPT_SET_ALL, false, "local-cache-dir", 'c',
1430 OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePath,
1431 "Path in which to store local copies of files."},
1434 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformRSync::GetDefinitions() {
1435 return llvm::makeArrayRef(g_rsync_option_table);
1438 void OptionGroupPlatformRSync::OptionParsingStarting(
1439 ExecutionContext *execution_context) {
1441 m_rsync_opts.clear();
1442 m_rsync_prefix.clear();
1443 m_ignores_remote_hostname = false;
1446 lldb_private::Status
1447 OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
1448 llvm::StringRef option_arg,
1449 ExecutionContext *execution_context) {
1451 char short_option = (char)GetDefinitions()[option_idx].short_option;
1452 switch (short_option) {
1458 m_rsync_opts.assign(option_arg);
1462 m_rsync_prefix.assign(option_arg);
1466 m_ignores_remote_hostname = true;
1470 error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
1478 Platform::SetThreadCreationBreakpoint(lldb_private::Target &target) {
1479 return lldb::BreakpointSP();
1482 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformSSH::GetDefinitions() {
1483 return llvm::makeArrayRef(g_ssh_option_table);
1486 void OptionGroupPlatformSSH::OptionParsingStarting(
1487 ExecutionContext *execution_context) {
1492 lldb_private::Status
1493 OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
1494 llvm::StringRef option_arg,
1495 ExecutionContext *execution_context) {
1497 char short_option = (char)GetDefinitions()[option_idx].short_option;
1498 switch (short_option) {
1504 m_ssh_opts.assign(option_arg);
1508 error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
1515 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformCaching::GetDefinitions() {
1516 return llvm::makeArrayRef(g_caching_option_table);
1519 void OptionGroupPlatformCaching::OptionParsingStarting(
1520 ExecutionContext *execution_context) {
1521 m_cache_dir.clear();
1524 lldb_private::Status OptionGroupPlatformCaching::SetOptionValue(
1525 uint32_t option_idx, llvm::StringRef option_arg,
1526 ExecutionContext *execution_context) {
1528 char short_option = (char)GetDefinitions()[option_idx].short_option;
1529 switch (short_option) {
1531 m_cache_dir.assign(option_arg);
1535 error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
1542 size_t Platform::GetEnvironment(StringList &environment) {
1543 environment.Clear();
1547 const std::vector<ConstString> &Platform::GetTrapHandlerSymbolNames() {
1548 if (!m_calculated_trap_handlers) {
1549 std::lock_guard<std::mutex> guard(m_mutex);
1550 if (!m_calculated_trap_handlers) {
1551 CalculateTrapHandlerSymbolNames();
1552 m_calculated_trap_handlers = true;
1555 return m_trap_handlers;
1558 Status Platform::GetCachedExecutable(
1559 ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
1560 const FileSpecList *module_search_paths_ptr, Platform &remote_platform) {
1561 const auto platform_spec = module_spec.GetFileSpec();
1562 const auto error = LoadCachedExecutable(
1563 module_spec, module_sp, module_search_paths_ptr, remote_platform);
1564 if (error.Success()) {
1565 module_spec.GetFileSpec() = module_sp->GetFileSpec();
1566 module_spec.GetPlatformFileSpec() = platform_spec;
1572 Status Platform::LoadCachedExecutable(
1573 const ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
1574 const FileSpecList *module_search_paths_ptr, Platform &remote_platform) {
1575 return GetRemoteSharedModule(module_spec, nullptr, module_sp,
1576 [&](const ModuleSpec &spec) {
1577 return remote_platform.ResolveExecutable(
1578 spec, module_sp, module_search_paths_ptr);
1583 Status Platform::GetRemoteSharedModule(const ModuleSpec &module_spec,
1585 lldb::ModuleSP &module_sp,
1586 const ModuleResolver &module_resolver,
1587 bool *did_create_ptr) {
1588 // Get module information from a target.
1589 ModuleSpec resolved_module_spec;
1590 bool got_module_spec = false;
1592 // Try to get module information from the process
1593 if (process->GetModuleSpec(module_spec.GetFileSpec(),
1594 module_spec.GetArchitecture(),
1595 resolved_module_spec)) {
1596 if (module_spec.GetUUID().IsValid() == false ||
1597 module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
1598 got_module_spec = true;
1603 if (module_spec.GetArchitecture().IsValid() == false) {
1605 // No valid architecture was specified, ask the platform for
1606 // the architectures that we should be using (in the correct order)
1607 // and see if we can find a match that way
1608 ModuleSpec arch_module_spec(module_spec);
1609 for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
1610 idx, arch_module_spec.GetArchitecture());
1612 error = ModuleList::GetSharedModule(arch_module_spec, module_sp, nullptr,
1614 // Did we find an executable using one of the
1615 if (error.Success() && module_sp)
1619 got_module_spec = true;
1622 if (!got_module_spec) {
1623 // Get module information from a target.
1624 if (!GetModuleSpec(module_spec.GetFileSpec(), module_spec.GetArchitecture(),
1625 resolved_module_spec)) {
1626 if (module_spec.GetUUID().IsValid() == false ||
1627 module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
1628 return module_resolver(module_spec);
1633 // If we are looking for a specific UUID, make sure resolved_module_spec has
1634 // the same one before we search.
1635 if (module_spec.GetUUID().IsValid()) {
1636 resolved_module_spec.GetUUID() = module_spec.GetUUID();
1639 // Trying to find a module by UUID on local file system.
1640 const auto error = module_resolver(resolved_module_spec);
1642 if (GetCachedSharedModule(resolved_module_spec, module_sp, did_create_ptr))
1649 bool Platform::GetCachedSharedModule(const ModuleSpec &module_spec,
1650 lldb::ModuleSP &module_sp,
1651 bool *did_create_ptr) {
1652 if (IsHost() || !GetGlobalPlatformProperties()->GetUseModuleCache() ||
1653 !GetGlobalPlatformProperties()->GetModuleCacheDirectory())
1656 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
1658 // Check local cache for a module.
1659 auto error = m_module_cache->GetAndPut(
1660 GetModuleCacheRoot(), GetCacheHostname(), module_spec,
1661 [this](const ModuleSpec &module_spec,
1662 const FileSpec &tmp_download_file_spec) {
1663 return DownloadModuleSlice(
1664 module_spec.GetFileSpec(), module_spec.GetObjectOffset(),
1665 module_spec.GetObjectSize(), tmp_download_file_spec);
1668 [this](const ModuleSP &module_sp,
1669 const FileSpec &tmp_download_file_spec) {
1670 return DownloadSymbolFile(module_sp, tmp_download_file_spec);
1672 module_sp, did_create_ptr);
1673 if (error.Success())
1677 log->Printf("Platform::%s - module %s not found in local cache: %s",
1678 __FUNCTION__, module_spec.GetUUID().GetAsString().c_str(),
1683 Status Platform::DownloadModuleSlice(const FileSpec &src_file_spec,
1684 const uint64_t src_offset,
1685 const uint64_t src_size,
1686 const FileSpec &dst_file_spec) {
1690 llvm::raw_fd_ostream dst(dst_file_spec.GetPath(), EC, llvm::sys::fs::F_None);
1692 error.SetErrorStringWithFormat("unable to open destination file: %s",
1693 dst_file_spec.GetPath().c_str());
1697 auto src_fd = OpenFile(src_file_spec, File::eOpenOptionRead,
1698 lldb::eFilePermissionsFileDefault, error);
1701 error.SetErrorStringWithFormat("unable to open source file: %s",
1706 std::vector<char> buffer(1024);
1707 auto offset = src_offset;
1708 uint64_t total_bytes_read = 0;
1709 while (total_bytes_read < src_size) {
1710 const auto to_read = std::min(static_cast<uint64_t>(buffer.size()),
1711 src_size - total_bytes_read);
1712 const uint64_t n_read =
1713 ReadFile(src_fd, offset, &buffer[0], to_read, error);
1717 error.SetErrorString("read 0 bytes");
1721 total_bytes_read += n_read;
1722 dst.write(&buffer[0], n_read);
1726 CloseFile(src_fd, close_error); // Ignoring close error.
1731 Status Platform::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
1732 const FileSpec &dst_file_spec) {
1734 "Symbol file downloading not supported by the default platform.");
1737 FileSpec Platform::GetModuleCacheRoot() {
1738 auto dir_spec = GetGlobalPlatformProperties()->GetModuleCacheDirectory();
1739 dir_spec.AppendPathComponent(GetName().AsCString());
1743 const char *Platform::GetCacheHostname() { return GetHostname(); }
1745 const UnixSignalsSP &Platform::GetRemoteUnixSignals() {
1746 static const auto s_default_unix_signals_sp = std::make_shared<UnixSignals>();
1747 return s_default_unix_signals_sp;
1750 const UnixSignalsSP &Platform::GetUnixSignals() {
1752 return Host::GetUnixSignals();
1753 return GetRemoteUnixSignals();
1756 uint32_t Platform::LoadImage(lldb_private::Process *process,
1757 const lldb_private::FileSpec &local_file,
1758 const lldb_private::FileSpec &remote_file,
1759 lldb_private::Status &error) {
1760 if (local_file && remote_file) {
1761 // Both local and remote file was specified. Install the local file to the
1763 if (IsRemote() || local_file != remote_file) {
1764 error = Install(local_file, remote_file);
1766 return LLDB_INVALID_IMAGE_TOKEN;
1768 return DoLoadImage(process, remote_file, error);
1772 // Only local file was specified. Install it to the current working
1774 FileSpec target_file = GetWorkingDirectory();
1775 target_file.AppendPathComponent(local_file.GetFilename().AsCString());
1776 if (IsRemote() || local_file != target_file) {
1777 error = Install(local_file, target_file);
1779 return LLDB_INVALID_IMAGE_TOKEN;
1781 return DoLoadImage(process, target_file, error);
1785 // Only remote file was specified so we don't have to do any copying
1786 return DoLoadImage(process, remote_file, error);
1789 error.SetErrorString("Neither local nor remote file was specified");
1790 return LLDB_INVALID_IMAGE_TOKEN;
1793 uint32_t Platform::DoLoadImage(lldb_private::Process *process,
1794 const lldb_private::FileSpec &remote_file,
1795 lldb_private::Status &error) {
1796 error.SetErrorString("LoadImage is not supported on the current platform");
1797 return LLDB_INVALID_IMAGE_TOKEN;
1800 Status Platform::UnloadImage(lldb_private::Process *process,
1801 uint32_t image_token) {
1802 return Status("UnloadImage is not supported on the current platform");
1805 lldb::ProcessSP Platform::ConnectProcess(llvm::StringRef connect_url,
1806 llvm::StringRef plugin_name,
1807 lldb_private::Debugger &debugger,
1808 lldb_private::Target *target,
1809 lldb_private::Status &error) {
1813 TargetSP new_target_sp;
1814 error = debugger.GetTargetList().CreateTarget(debugger, "", "", false,
1815 nullptr, new_target_sp);
1816 target = new_target_sp.get();
1819 if (!target || error.Fail())
1822 debugger.GetTargetList().SetSelectedTarget(target);
1824 lldb::ProcessSP process_sp =
1825 target->CreateProcess(debugger.GetListener(), plugin_name, nullptr);
1830 process_sp->ConnectRemote(debugger.GetOutputFile().get(), connect_url);
1837 size_t Platform::ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
1838 lldb_private::Status &error) {
1843 size_t Platform::GetSoftwareBreakpointTrapOpcode(Target &target,
1844 BreakpointSite *bp_site) {
1845 ArchSpec arch = target.GetArchitecture();
1846 const uint8_t *trap_opcode = nullptr;
1847 size_t trap_opcode_size = 0;
1849 switch (arch.GetMachine()) {
1850 case llvm::Triple::aarch64: {
1851 static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xd4};
1852 trap_opcode = g_aarch64_opcode;
1853 trap_opcode_size = sizeof(g_aarch64_opcode);
1856 // TODO: support big-endian arm and thumb trap codes.
1857 case llvm::Triple::arm: {
1858 // The ARM reference recommends the use of 0xe7fddefe and 0xdefe
1859 // but the linux kernel does otherwise.
1860 static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
1861 static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
1863 lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
1864 AddressClass addr_class = eAddressClassUnknown;
1867 addr_class = bp_loc_sp->GetAddress().GetAddressClass();
1868 if (addr_class == eAddressClassUnknown &&
1869 (bp_loc_sp->GetAddress().GetFileAddress() & 1))
1870 addr_class = eAddressClassCodeAlternateISA;
1873 if (addr_class == eAddressClassCodeAlternateISA) {
1874 trap_opcode = g_thumb_breakpoint_opcode;
1875 trap_opcode_size = sizeof(g_thumb_breakpoint_opcode);
1877 trap_opcode = g_arm_breakpoint_opcode;
1878 trap_opcode_size = sizeof(g_arm_breakpoint_opcode);
1882 case llvm::Triple::mips:
1883 case llvm::Triple::mips64: {
1884 static const uint8_t g_hex_opcode[] = {0x00, 0x00, 0x00, 0x0d};
1885 trap_opcode = g_hex_opcode;
1886 trap_opcode_size = sizeof(g_hex_opcode);
1889 case llvm::Triple::mipsel:
1890 case llvm::Triple::mips64el: {
1891 static const uint8_t g_hex_opcode[] = {0x0d, 0x00, 0x00, 0x00};
1892 trap_opcode = g_hex_opcode;
1893 trap_opcode_size = sizeof(g_hex_opcode);
1896 case llvm::Triple::systemz: {
1897 static const uint8_t g_hex_opcode[] = {0x00, 0x01};
1898 trap_opcode = g_hex_opcode;
1899 trap_opcode_size = sizeof(g_hex_opcode);
1902 case llvm::Triple::hexagon: {
1903 static const uint8_t g_hex_opcode[] = {0x0c, 0xdb, 0x00, 0x54};
1904 trap_opcode = g_hex_opcode;
1905 trap_opcode_size = sizeof(g_hex_opcode);
1908 case llvm::Triple::ppc:
1909 case llvm::Triple::ppc64: {
1910 static const uint8_t g_ppc_opcode[] = {0x7f, 0xe0, 0x00, 0x08};
1911 trap_opcode = g_ppc_opcode;
1912 trap_opcode_size = sizeof(g_ppc_opcode);
1915 case llvm::Triple::ppc64le: {
1916 static const uint8_t g_ppc64le_opcode[] = {0x08, 0x00, 0xe0, 0x7f}; // trap
1917 trap_opcode = g_ppc64le_opcode;
1918 trap_opcode_size = sizeof(g_ppc64le_opcode);
1921 case llvm::Triple::x86:
1922 case llvm::Triple::x86_64: {
1923 static const uint8_t g_i386_opcode[] = {0xCC};
1924 trap_opcode = g_i386_opcode;
1925 trap_opcode_size = sizeof(g_i386_opcode);
1930 "Unhandled architecture in Platform::GetSoftwareBreakpointTrapOpcode");
1934 if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size))
1935 return trap_opcode_size;