This is an archive of the discontinued LLVM Phabricator instance.

Differential D29406

Unify PlatformPOSIX::ResolveExecutable
ClosedPublic

Authored by labath on Feb 1 2017, 10:48 AM.

Details

Reviewers
emaste
krytarowski
clayborg
Commits
rGfc89bbcc7125: Unify PlatformPOSIX::ResolveExecutable
rLLDB293910: Unify PlatformPOSIX::ResolveExecutable
rL293910: Unify PlatformPOSIX::ResolveExecutable
Summary

various platforms very using nearly identical code for this method. As far as I
can tell there was nothing platform-specific about the differences, but rather
it looked like it was caused by tiny tweaks being made to individual copies
without affecting the overall functionality. I have taken the superset of all
these tweaks and put it into one method in the base class (incidentaly, nobody
was using the base class implementation of the method, as all classes were
overriding it). From the darwin class I took the slightly improved error
reporting (checking whether the file is readable) and the
ResolveExecutableInBundle call (which has no effect elsewhere as the function
is already a no-op on non-darwin platforms). From the linux class I took the
set-the-triple-vendor-to-host-if-unspecified tweak (present in PlatformKalimba
as well).

PlatformWindows has an identical copy as well. We could resolve that by pushing
this code further down into Platform class, that that would require pushing the
m_remote_platform_sp member as well, which seems like a bad design choice.

Diff Detail

Repository
rL LLVM

Event Timeline

labath created this revision.Feb 1 2017, 10:48 AM
labath added inline comments.Feb 1 2017, 10:50 AM
source/Plugins/Platform/POSIX/PlatformPOSIX.cpp
163 ↗(On Diff #86672)

This is the bit that was only present on darwin.

198 ↗(On Diff #86672)

This is the bit that was only present on linux.

krytarowski edited edge metadata.Feb 1 2017, 11:12 AM

It looks good.

krytarowski accepted this revision.Feb 1 2017, 12:33 PM
This revision is now accepted and ready to land.Feb 1 2017, 12:33 PM
clayborg accepted this revision.Feb 1 2017, 2:22 PM
Closed by commit rL293910: Unify PlatformPOSIX::ResolveExecutable (authored by labath). · Explain WhyFeb 2 2017, 10:01 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lldb/
trunk/
source/
Plugins/
Platform/
FreeBSD/
4 lines
106 lines
Kalimba/
4 lines
92 lines
Linux/
4 lines
125 lines
MacOSX/
4 lines
114 lines
NetBSD/
4 lines
106 lines
POSIX/
4 lines
139 lines

Diff 86846

lldb/trunk/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linespublic:
bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch, bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch,
ModuleSpec &module_spec) override; ModuleSpec &module_spec) override;
Error RunShellCommand(const char *command, const FileSpec &working_dir, Error RunShellCommand(const char *command, const FileSpec &working_dir,
int *status_ptr, int *signo_ptr, int *status_ptr, int *signo_ptr,
std::string *command_output, std::string *command_output,
uint32_t timeout_sec) override; uint32_t timeout_sec) override;
Error ResolveExecutable(const ModuleSpec &module_spec,
lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr) override;
size_t GetSoftwareBreakpointTrapOpcode(Target &target, size_t GetSoftwareBreakpointTrapOpcode(Target &target,
BreakpointSite *bp_site) override; BreakpointSite *bp_site) override;
bool GetRemoteOSVersion() override; bool GetRemoteOSVersion() override;
bool GetRemoteOSBuildString(std::string &s) override; bool GetRemoteOSBuildString(std::string &s) override;
bool GetRemoteOSKernelDescription(std::string &s) override; bool GetRemoteOSKernelDescription(std::string &s) override;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Lines if (m_remote_platform_sp)
return m_remote_platform_sp->RunShellCommand(command, working_dir, return m_remote_platform_sp->RunShellCommand(command, working_dir,
status_ptr, signo_ptr, status_ptr, signo_ptr,
command_output, timeout_sec); command_output, timeout_sec);
else else
return Error("unable to run a remote command without a platform"); return Error("unable to run a remote command without a platform");
} }
} }
Error PlatformFreeBSD::ResolveExecutable(
const ModuleSpec &module_spec, lldb::ModuleSP &exe_module_sp,
const FileSpecList *module_search_paths_ptr) {
Error error;
// Nothing special to do here, just use the actual file and architecture
char exe_path[PATH_MAX];
ModuleSpec resolved_module_spec(module_spec);
if (IsHost()) {
// If we have "ls" as the module_spec's file, resolve the executable
// location based on
// the current path variables
if (!resolved_module_spec.GetFileSpec().Exists()) {
module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
resolved_module_spec.GetFileSpec().SetFile(exe_path, true);
}
if (!resolved_module_spec.GetFileSpec().Exists())
resolved_module_spec.GetFileSpec().ResolveExecutableLocation();
if (resolved_module_spec.GetFileSpec().Exists())
error.Clear();
else {
error.SetErrorStringWithFormat(
"unable to find executable for '%s'",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
} else {
if (m_remote_platform_sp) {
error =
GetCachedExecutable(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, *m_remote_platform_sp);
} else {
// We may connect to a process and use the provided executable (Don't use
// local $PATH).
// Resolve any executable within a bundle on MacOSX
Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
if (resolved_module_spec.GetFileSpec().Exists()) {
error.Clear();
} else {
error.SetErrorStringWithFormat(
"the platform is not currently connected, and '%s' doesn't exist "
"in the system root.",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
}
}
if (error.Success()) {
if (resolved_module_spec.GetArchitecture().IsValid()) {
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, NULL, NULL);
if (!exe_module_sp || exe_module_sp->GetObjectFile() == NULL) {
exe_module_sp.reset();
error.SetErrorStringWithFormat(
"'%s' doesn't contain the architecture %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
} else {
// No valid architecture was specified, ask the platform for
// the architectures that we should be using (in the correct order)
// and see if we can find a match that way
StreamString arch_names;
for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
idx, resolved_module_spec.GetArchitecture());
++idx) {
error =
ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, NULL, NULL);
// Did we find an executable using one of the
if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile())
break;
else
error.SetErrorToGenericError();
}
if (idx > 0)
arch_names.PutCString(", ");
arch_names.PutCString(
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetData());
} else {
error.SetErrorStringWithFormat(
"'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
}
}
}
return error;
}
// From PlatformMacOSX only // From PlatformMacOSX only
Error PlatformFreeBSD::GetFileWithUUID(const FileSpec &platform_file, Error PlatformFreeBSD::GetFileWithUUID(const FileSpec &platform_file,
const UUID *uuid_ptr, const UUID *uuid_ptr,
FileSpec &local_file) { FileSpec &local_file) {
if (IsRemote()) { if (IsRemote()) {
if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr, return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
local_file); local_file);
▲ Show 20 Lines • Show All 367 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/Kalimba/PlatformKalimba.h

Show All 39 Linespublic:
lldb_private::ConstString GetPluginName() override; lldb_private::ConstString GetPluginName() override;
uint32_t GetPluginVersion() override { return 1; } uint32_t GetPluginVersion() override { return 1; }
//------------------------------------------------------------ //------------------------------------------------------------
// lldb_private::Platform functions // lldb_private::Platform functions
//------------------------------------------------------------ //------------------------------------------------------------
Error ResolveExecutable(const lldb_private::ModuleSpec &module_spec,
lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr) override;
const char *GetDescription() override { const char *GetDescription() override {
return GetPluginDescriptionStatic(IsHost()); return GetPluginDescriptionStatic(IsHost());
} }
void GetStatus(Stream &strm) override; void GetStatus(Stream &strm) override;
Error GetFileWithUUID(const FileSpec &platform_file, const UUID *uuid, Error GetFileWithUUID(const FileSpec &platform_file, const UUID *uuid,
FileSpec &local_file) override; FileSpec &local_file) override;
Show All 29 Lines

lldb/trunk/source/Plugins/Platform/Kalimba/PlatformKalimba.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines if (g_initialize_count > 0) {
if (--g_initialize_count == 0) { if (--g_initialize_count == 0) {
PluginManager::UnregisterPlugin(PlatformKalimba::CreateInstance); PluginManager::UnregisterPlugin(PlatformKalimba::CreateInstance);
} }
} }
Platform::Terminate(); Platform::Terminate();
} }
Error PlatformKalimba::ResolveExecutable(
const ModuleSpec &ms, lldb::ModuleSP &exe_module_sp,
const FileSpecList *module_search_paths_ptr) {
Error error;
char exe_path[PATH_MAX];
ModuleSpec resolved_module_spec(ms);
if (!resolved_module_spec.GetFileSpec().Exists()) {
resolved_module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
error.SetErrorStringWithFormat("unable to find executable for '%s'",
exe_path);
}
if (error.Success()) {
if (resolved_module_spec.GetArchitecture().IsValid()) {
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
NULL, NULL, NULL);
if (error.Fail()) {
// If we failed, it may be because the vendor and os aren't known. If
// that is the
// case, try setting them to the host architecture and give it another
// try.
llvm::Triple &module_triple =
resolved_module_spec.GetArchitecture().GetTriple();
bool is_vendor_specified =
(module_triple.getVendor() != llvm::Triple::UnknownVendor);
bool is_os_specified =
(module_triple.getOS() != llvm::Triple::UnknownOS);
if (!is_vendor_specified || !is_os_specified) {
const llvm::Triple &host_triple =
HostInfo::GetArchitecture(HostInfo::eArchKindDefault).GetTriple();
if (!is_vendor_specified)
module_triple.setVendorName(host_triple.getVendorName());
if (!is_os_specified)
module_triple.setOSName(host_triple.getOSName());
error = ModuleList::GetSharedModule(resolved_module_spec,
exe_module_sp, NULL, NULL, NULL);
}
}
// TODO find out why exe_module_sp might be NULL
if (!exe_module_sp || exe_module_sp->GetObjectFile() == NULL) {
exe_module_sp.reset();
error.SetErrorStringWithFormat(
"'%s' doesn't contain the architecture %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
} else {
// No valid architecture was specified, ask the platform for
// the architectures that we should be using (in the correct order)
// and see if we can find a match that way
StreamString arch_names;
for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
idx, resolved_module_spec.GetArchitecture());
++idx) {
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
NULL, NULL, NULL);
// Did we find an executable using one of the
if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile())
break;
else
error.SetErrorToGenericError();
}
if (idx > 0)
arch_names.PutCString(", ");
arch_names.PutCString(
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetData());
} else {
error.SetErrorStringWithFormat(
"'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
}
}
}
return error;
}
Error PlatformKalimba::GetFileWithUUID(const FileSpec & /*platform_file*/, Error PlatformKalimba::GetFileWithUUID(const FileSpec & /*platform_file*/,
const UUID * /*uuid_ptr*/, const UUID * /*uuid_ptr*/,
FileSpec & /*local_file*/) { FileSpec & /*local_file*/) {
return Error(); return Error();
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Default Constructor /// Default Constructor
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.h

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linespublic:
ConstString GetPluginName() override; ConstString GetPluginName() override;
uint32_t GetPluginVersion() override { return 1; } uint32_t GetPluginVersion() override { return 1; }
//------------------------------------------------------------ //------------------------------------------------------------
// lldb_private::Platform functions // lldb_private::Platform functions
//------------------------------------------------------------ //------------------------------------------------------------
Error ResolveExecutable(const ModuleSpec &module_spec,
lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr) override;
const char *GetDescription() override { const char *GetDescription() override {
return GetPluginDescriptionStatic(IsHost()); return GetPluginDescriptionStatic(IsHost());
} }
void GetStatus(Stream &strm) override; void GetStatus(Stream &strm) override;
Error GetFileWithUUID(const FileSpec &platform_file, const UUID *uuid, Error GetFileWithUUID(const FileSpec &platform_file, const UUID *uuid,
FileSpec &local_file) override; FileSpec &local_file) override;
Show All 31 Lines

lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp

Show First 20 Lines • Show All 199 Lines • ▼ Show 20 Lines if (g_initialize_count > 0) {
if (--g_initialize_count == 0) { if (--g_initialize_count == 0) {
PluginManager::UnregisterPlugin(PlatformLinux::CreateInstance); PluginManager::UnregisterPlugin(PlatformLinux::CreateInstance);
} }
} }
PlatformPOSIX::Terminate(); PlatformPOSIX::Terminate();
} }
Error PlatformLinux::ResolveExecutable(
const ModuleSpec &ms, lldb::ModuleSP &exe_module_sp,
const FileSpecList *module_search_paths_ptr) {
Error error;
// Nothing special to do here, just use the actual file and architecture
char exe_path[PATH_MAX];
ModuleSpec resolved_module_spec(ms);
if (IsHost()) {
// If we have "ls" as the exe_file, resolve the executable location based on
// the current path variables
if (!resolved_module_spec.GetFileSpec().Exists()) {
resolved_module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
resolved_module_spec.GetFileSpec().SetFile(exe_path, true);
}
if (!resolved_module_spec.GetFileSpec().Exists())
resolved_module_spec.GetFileSpec().ResolveExecutableLocation();
if (resolved_module_spec.GetFileSpec().Exists())
error.Clear();
else {
error.SetErrorStringWithFormat(
"unable to find executable for '%s'",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
} else {
if (m_remote_platform_sp) {
error =
GetCachedExecutable(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, *m_remote_platform_sp);
} else {
// We may connect to a process and use the provided executable (Don't use
// local $PATH).
if (resolved_module_spec.GetFileSpec().Exists())
error.Clear();
else
error.SetErrorStringWithFormat("the platform is not currently "
"connected, and '%s' doesn't exist in "
"the system root.",
exe_path);
}
}
if (error.Success()) {
if (resolved_module_spec.GetArchitecture().IsValid()) {
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
NULL, NULL, NULL);
if (error.Fail()) {
// If we failed, it may be because the vendor and os aren't known. If
// that is the
// case, try setting them to the host architecture and give it another
// try.
llvm::Triple &module_triple =
resolved_module_spec.GetArchitecture().GetTriple();
bool is_vendor_specified =
(module_triple.getVendor() != llvm::Triple::UnknownVendor);
bool is_os_specified =
(module_triple.getOS() != llvm::Triple::UnknownOS);
if (!is_vendor_specified || !is_os_specified) {
const llvm::Triple &host_triple =
HostInfo::GetArchitecture(HostInfo::eArchKindDefault).GetTriple();
if (!is_vendor_specified)
module_triple.setVendorName(host_triple.getVendorName());
if (!is_os_specified)
module_triple.setOSName(host_triple.getOSName());
error = ModuleList::GetSharedModule(resolved_module_spec,
exe_module_sp, NULL, NULL, NULL);
}
}
// TODO find out why exe_module_sp might be NULL
if (!exe_module_sp || exe_module_sp->GetObjectFile() == NULL) {
exe_module_sp.reset();
error.SetErrorStringWithFormat(
"'%s' doesn't contain the architecture %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
} else {
// No valid architecture was specified, ask the platform for
// the architectures that we should be using (in the correct order)
// and see if we can find a match that way
StreamString arch_names;
for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
idx, resolved_module_spec.GetArchitecture());
++idx) {
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
NULL, NULL, NULL);
// Did we find an executable using one of the
if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile())
break;
else
error.SetErrorToGenericError();
}
if (idx > 0)
arch_names.PutCString(", ");
arch_names.PutCString(
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetData());
} else {
error.SetErrorStringWithFormat(
"'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
}
}
}
return error;
}
Error PlatformLinux::GetFileWithUUID(const FileSpec &platform_file, Error PlatformLinux::GetFileWithUUID(const FileSpec &platform_file,
const UUID *uuid_ptr, const UUID *uuid_ptr,
FileSpec &local_file) { FileSpec &local_file) {
if (IsRemote()) { if (IsRemote()) {
if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr, return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
local_file); local_file);
} }
▲ Show 20 Lines • Show All 377 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.h

Show All 25 Lines
public: public:
PlatformDarwin(bool is_host); PlatformDarwin(bool is_host);
~PlatformDarwin() override; ~PlatformDarwin() override;
//------------------------------------------------------------ //------------------------------------------------------------
// lldb_private::Platform functions // lldb_private::Platform functions
//------------------------------------------------------------ //------------------------------------------------------------
lldb_private::Error ResolveExecutable(
const lldb_private::ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
const lldb_private::FileSpecList *module_search_paths_ptr) override;
lldb_private::Error lldb_private::Error
ResolveSymbolFile(lldb_private::Target &target, ResolveSymbolFile(lldb_private::Target &target,
const lldb_private::ModuleSpec &sym_spec, const lldb_private::ModuleSpec &sym_spec,
lldb_private::FileSpec &sym_file) override; lldb_private::FileSpec &sym_file) override;
lldb_private::FileSpecList LocateExecutableScriptingResources( lldb_private::FileSpecList LocateExecutableScriptingResources(
lldb_private::Target *target, lldb_private::Module &module, lldb_private::Target *target, lldb_private::Module &module,
lldb_private::Stream *feedback_stream) override; lldb_private::Stream *feedback_stream) override;
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines if (module_spec) {
} }
} }
} }
} }
} }
return file_list; return file_list;
} }
Error PlatformDarwin::ResolveExecutable(
const ModuleSpec &module_spec, lldb::ModuleSP &exe_module_sp,
const FileSpecList *module_search_paths_ptr) {
Error error;
// Nothing special to do here, just use the actual file and architecture
char exe_path[PATH_MAX];
ModuleSpec resolved_module_spec(module_spec);
if (IsHost()) {
// If we have "ls" as the exe_file, resolve the executable loation based on
// the current path variables
if (!resolved_module_spec.GetFileSpec().Exists()) {
module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
resolved_module_spec.GetFileSpec().SetFile(exe_path, true);
}
if (!resolved_module_spec.GetFileSpec().Exists())
resolved_module_spec.GetFileSpec().ResolveExecutableLocation();
// Resolve any executable within a bundle on MacOSX
Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
if (resolved_module_spec.GetFileSpec().Exists())
error.Clear();
else {
const uint32_t permissions =
resolved_module_spec.GetFileSpec().GetPermissions();
if (permissions && (permissions & eFilePermissionsEveryoneR) == 0)
error.SetErrorStringWithFormat(
"executable '%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str());
else
error.SetErrorStringWithFormat(
"unable to find executable for '%s'",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
} else {
if (m_remote_platform_sp) {
error =
GetCachedExecutable(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, *m_remote_platform_sp);
} else {
// We may connect to a process and use the provided executable (Don't use
// local $PATH).
// Resolve any executable within a bundle on MacOSX
Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
if (resolved_module_spec.GetFileSpec().Exists())
error.Clear();
else
error.SetErrorStringWithFormat(
"the platform is not currently connected, and '%s' doesn't exist "
"in the system root.",
resolved_module_spec.GetFileSpec().GetFilename().AsCString(""));
}
}
if (error.Success()) {
if (resolved_module_spec.GetArchitecture().IsValid()) {
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, NULL, NULL);
if (error.Fail() || exe_module_sp.get() == NULL ||
exe_module_sp->GetObjectFile() == NULL) {
exe_module_sp.reset();
error.SetErrorStringWithFormat(
"'%s' doesn't contain the architecture %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
} else {
// No valid architecture was specified, ask the platform for
// the architectures that we should be using (in the correct order)
// and see if we can find a match that way
StreamString arch_names;
for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
idx, resolved_module_spec.GetArchitecture());
++idx) {
error = GetSharedModule(resolved_module_spec, NULL, exe_module_sp,
module_search_paths_ptr, NULL, NULL);
// Did we find an executable using one of the
if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile())
break;
else
error.SetErrorToGenericError();
}
if (idx > 0)
arch_names.PutCString(", ");
arch_names.PutCString(
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetData());
} else {
error.SetErrorStringWithFormat(
"'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
}
}
}
return error;
}
Error PlatformDarwin::ResolveSymbolFile(Target &target, Error PlatformDarwin::ResolveSymbolFile(Target &target,
const ModuleSpec &sym_spec, const ModuleSpec &sym_spec,
FileSpec &sym_file) { FileSpec &sym_file) {
Error error; Error error;
sym_file = sym_spec.GetSymbolFileSpec(); sym_file = sym_spec.GetSymbolFileSpec();
if (sym_file.Exists()) { if (sym_file.Exists()) {
if (sym_file.GetFileType() == FileSpec::eFileTypeDirectory) { if (sym_file.GetFileType() == FileSpec::eFileTypeDirectory) {
sym_file = Symbols::FindSymbolFileInBundle( sym_file = Symbols::FindSymbolFileInBundle(
▲ Show 20 Lines • Show All 1,573 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/NetBSD/PlatformNetBSD.h

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linespublic:
bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch, bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch,
ModuleSpec &module_spec) override; ModuleSpec &module_spec) override;
Error RunShellCommand(const char *command, const FileSpec &working_dir, Error RunShellCommand(const char *command, const FileSpec &working_dir,
int *status_ptr, int *signo_ptr, int *status_ptr, int *signo_ptr,
std::string *command_output, std::string *command_output,
uint32_t timeout_sec) override; uint32_t timeout_sec) override;
Error ResolveExecutable(const ModuleSpec &module_spec,
lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr) override;
bool GetRemoteOSVersion() override; bool GetRemoteOSVersion() override;
bool GetRemoteOSBuildString(std::string &s) override; bool GetRemoteOSBuildString(std::string &s) override;
bool GetRemoteOSKernelDescription(std::string &s) override; bool GetRemoteOSKernelDescription(std::string &s) override;
// Remote Platform subclasses need to override this function // Remote Platform subclasses need to override this function
ArchSpec GetRemoteSystemArchitecture() override; ArchSpec GetRemoteSystemArchitecture() override;
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines if (m_remote_platform_sp)
return m_remote_platform_sp->RunShellCommand(command, working_dir, return m_remote_platform_sp->RunShellCommand(command, working_dir,
status_ptr, signo_ptr, status_ptr, signo_ptr,
command_output, timeout_sec); command_output, timeout_sec);
else else
return Error("unable to run a remote command without a platform"); return Error("unable to run a remote command without a platform");
} }
} }
Error PlatformNetBSD::ResolveExecutable(
const ModuleSpec &module_spec, lldb::ModuleSP &exe_module_sp,
const FileSpecList *module_search_paths_ptr) {
Error error;
// Nothing special to do here, just use the actual file and architecture
char exe_path[PATH_MAX];
ModuleSpec resolved_module_spec(module_spec);
if (IsHost()) {
// If we have "ls" as the module_spec's file, resolve the executable
// location based on
// the current path variables
if (!resolved_module_spec.GetFileSpec().Exists()) {
module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
resolved_module_spec.GetFileSpec().SetFile(exe_path, true);
}
if (!resolved_module_spec.GetFileSpec().Exists())
resolved_module_spec.GetFileSpec().ResolveExecutableLocation();
if (resolved_module_spec.GetFileSpec().Exists())
error.Clear();
else {
error.SetErrorStringWithFormat(
"unable to find executable for '%s'",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
} else {
if (m_remote_platform_sp) {
error =
GetCachedExecutable(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, *m_remote_platform_sp);
} else {
// We may connect to a process and use the provided executable (Don't use
// local $PATH).
// Resolve any executable within a bundle on MacOSX
Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
if (resolved_module_spec.GetFileSpec().Exists()) {
error.Clear();
} else {
error.SetErrorStringWithFormat(
"the platform is not currently connected, and '%s' doesn't exist "
"in the system root.",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
}
}
if (error.Success()) {
if (resolved_module_spec.GetArchitecture().IsValid()) {
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, NULL, NULL);
if (!exe_module_sp || exe_module_sp->GetObjectFile() == NULL) {
exe_module_sp.reset();
error.SetErrorStringWithFormat(
"'%s' doesn't contain the architecture %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
} else {
// No valid architecture was specified, ask the platform for
// the architectures that we should be using (in the correct order)
// and see if we can find a match that way
StreamString arch_names;
for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
idx, resolved_module_spec.GetArchitecture());
++idx) {
error =
ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, NULL, NULL);
// Did we find an executable using one of the
if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile())
break;
else
error.SetErrorToGenericError();
}
if (idx > 0)
arch_names.PutCString(", ");
arch_names.PutCString(
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetData());
} else {
error.SetErrorStringWithFormat(
"'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
}
}
}
return error;
}
// From PlatformMacOSX only // From PlatformMacOSX only
Error PlatformNetBSD::GetFileWithUUID(const FileSpec &platform_file, Error PlatformNetBSD::GetFileWithUUID(const FileSpec &platform_file,
const UUID *uuid_ptr, const UUID *uuid_ptr,
FileSpec &local_file) { FileSpec &local_file) {
if (IsRemote()) { if (IsRemote()) {
if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr, return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
local_file); local_file);
▲ Show 20 Lines • Show All 307 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.h

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 Lines lldb_private::Error RunShellCommand(
int *status_ptr, // Pass nullptr if you don't want the process exit status int *status_ptr, // Pass nullptr if you don't want the process exit status
int *signo_ptr, // Pass nullptr if you don't want the signal that caused int *signo_ptr, // Pass nullptr if you don't want the signal that caused
// the process to exit // the process to exit
std::string std::string
*command_output, // Pass nullptr if you don't want the command output *command_output, // Pass nullptr if you don't want the command output
uint32_t timeout_sec) uint32_t timeout_sec)
override; // Timeout in seconds to wait for shell program to finish override; // Timeout in seconds to wait for shell program to finish
lldb_private::Error ResolveExecutable(const lldb_private::ModuleSpec &module_spec,
lldb::ModuleSP &module_sp,
const lldb_private::FileSpecList *module_search_paths_ptr) override;
lldb_private::Error MakeDirectory(const lldb_private::FileSpec &file_spec, lldb_private::Error MakeDirectory(const lldb_private::FileSpec &file_spec,
uint32_t mode) override; uint32_t mode) override;
lldb_private::Error lldb_private::Error
GetFilePermissions(const lldb_private::FileSpec &file_spec, GetFilePermissions(const lldb_private::FileSpec &file_spec,
uint32_t &file_permissions) override; uint32_t &file_permissions) override;
lldb_private::Error lldb_private::Error
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

Show All 12 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/StreamString.h" #include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Host/FileCache.h" #include "lldb/Host/FileCache.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h"
#include "lldb/Target/DynamicLoader.h" #include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines if (m_remote_platform_sp)
return m_remote_platform_sp->RunShellCommand(command, working_dir, return m_remote_platform_sp->RunShellCommand(command, working_dir,
status_ptr, signo_ptr, status_ptr, signo_ptr,
command_output, timeout_sec); command_output, timeout_sec);
else else
return Error("unable to run a remote command without a platform"); return Error("unable to run a remote command without a platform");
} }
} }
Error PlatformPOSIX::ResolveExecutable(const ModuleSpec &module_spec,
lldb::ModuleSP &exe_module_sp,
const FileSpecList *module_search_paths_ptr) {
Error error;
// Nothing special to do here, just use the actual file and architecture
char exe_path[PATH_MAX];
ModuleSpec resolved_module_spec(module_spec);
if (IsHost()) {
// If we have "ls" as the exe_file, resolve the executable location based on
// the current path variables
if (!resolved_module_spec.GetFileSpec().Exists()) {
resolved_module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
resolved_module_spec.GetFileSpec().SetFile(exe_path, true);
}
if (!resolved_module_spec.GetFileSpec().Exists())
resolved_module_spec.GetFileSpec().ResolveExecutableLocation();
// Resolve any executable within a bundle on MacOSX
Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
if (resolved_module_spec.GetFileSpec().Exists())
error.Clear();
else {
const uint32_t permissions =
resolved_module_spec.GetFileSpec().GetPermissions();
if (permissions && (permissions & eFilePermissionsEveryoneR) == 0)
error.SetErrorStringWithFormat(
"executable '%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str());
else
error.SetErrorStringWithFormat(
"unable to find executable for '%s'",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
} else {
if (m_remote_platform_sp) {
error =
GetCachedExecutable(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, *m_remote_platform_sp);
} else {
// We may connect to a process and use the provided executable (Don't use
// local $PATH).
// Resolve any executable within a bundle on MacOSX
Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
if (resolved_module_spec.GetFileSpec().Exists())
error.Clear();
else
error.SetErrorStringWithFormat("the platform is not currently "
"connected, and '%s' doesn't exist in "
"the system root.",
exe_path);
}
}
if (error.Success()) {
if (resolved_module_spec.GetArchitecture().IsValid()) {
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, nullptr, nullptr);
if (error.Fail()) {
// If we failed, it may be because the vendor and os aren't known. If
// that is the case, try setting them to the host architecture and give
// it another try.
llvm::Triple &module_triple =
resolved_module_spec.GetArchitecture().GetTriple();
bool is_vendor_specified =
(module_triple.getVendor() != llvm::Triple::UnknownVendor);
bool is_os_specified =
(module_triple.getOS() != llvm::Triple::UnknownOS);
if (!is_vendor_specified || !is_os_specified) {
const llvm::Triple &host_triple =
HostInfo::GetArchitecture(HostInfo::eArchKindDefault).GetTriple();
if (!is_vendor_specified)
module_triple.setVendorName(host_triple.getVendorName());
if (!is_os_specified)
module_triple.setOSName(host_triple.getOSName());
error = ModuleList::GetSharedModule(resolved_module_spec,
exe_module_sp, module_search_paths_ptr, nullptr, nullptr);
}
}
// TODO find out why exe_module_sp might be NULL
if (error.Fail() || !exe_module_sp || !exe_module_sp->GetObjectFile()) {
exe_module_sp.reset();
error.SetErrorStringWithFormat(
"'%s' doesn't contain the architecture %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
} else {
// No valid architecture was specified, ask the platform for
// the architectures that we should be using (in the correct order)
// and see if we can find a match that way
StreamString arch_names;
for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
idx, resolved_module_spec.GetArchitecture());
++idx) {
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
module_search_paths_ptr, nullptr, nullptr);
// Did we find an executable using one of the
if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile())
break;
else
error.SetErrorToGenericError();
}
if (idx > 0)
arch_names.PutCString(", ");
arch_names.PutCString(
resolved_module_spec.GetArchitecture().GetArchitectureName());
}
if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetData());
} else {
error.SetErrorStringWithFormat(
"'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str());
}
}
}
}
return error;
}
Error PlatformPOSIX::MakeDirectory(const FileSpec &file_spec, Error PlatformPOSIX::MakeDirectory(const FileSpec &file_spec,
uint32_t file_permissions) { uint32_t file_permissions) {
if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions); return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions);
else else
return Platform::MakeDirectory(file_spec, file_permissions); return Platform::MakeDirectory(file_spec, file_permissions);
} }
▲ Show 20 Lines • Show All 745 Lines • Show Last 20 Lines