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

source code of lldb/source/Target/Platform.cpp