466 lines
19 KiB
C++
466 lines
19 KiB
C++
//===-- PlatformDarwinDevice.cpp ------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "PlatformDarwinDevice.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/ModuleList.h"
|
|
#include "lldb/Core/ModuleSpec.h"
|
|
#include "lldb/Host/HostInfo.h"
|
|
#include "lldb/Utility/FileSpec.h"
|
|
#include "lldb/Utility/LLDBLog.h"
|
|
#include "lldb/Utility/Log.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
PlatformDarwinDevice::~PlatformDarwinDevice() = default;
|
|
|
|
FileSystem::EnumerateDirectoryResult
|
|
PlatformDarwinDevice::GetContainedFilesIntoVectorOfStringsCallback(
|
|
void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path) {
|
|
((PlatformDarwinDevice::SDKDirectoryInfoCollection *)baton)
|
|
->push_back(PlatformDarwinDevice::SDKDirectoryInfo(FileSpec(path)));
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
}
|
|
|
|
bool PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded() {
|
|
Log *log = GetLog(LLDBLog::Host);
|
|
std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
|
|
if (m_sdk_directory_infos.empty()) {
|
|
// A --sysroot option was supplied - add it to our list of SDKs to check
|
|
if (m_sdk_sysroot) {
|
|
FileSpec sdk_sysroot_fspec(m_sdk_sysroot.GetCString());
|
|
FileSystem::Instance().Resolve(sdk_sysroot_fspec);
|
|
const SDKDirectoryInfo sdk_sysroot_directory_info(sdk_sysroot_fspec);
|
|
m_sdk_directory_infos.push_back(sdk_sysroot_directory_info);
|
|
if (log) {
|
|
LLDB_LOGF(log,
|
|
"PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded added "
|
|
"--sysroot SDK directory %s",
|
|
m_sdk_sysroot.GetCString());
|
|
}
|
|
return true;
|
|
}
|
|
const char *device_support_dir = GetDeviceSupportDirectory();
|
|
if (log) {
|
|
LLDB_LOGF(log,
|
|
"PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded Got "
|
|
"DeviceSupport directory %s",
|
|
device_support_dir);
|
|
}
|
|
if (device_support_dir) {
|
|
const bool find_directories = true;
|
|
const bool find_files = false;
|
|
const bool find_other = false;
|
|
|
|
SDKDirectoryInfoCollection builtin_sdk_directory_infos;
|
|
FileSystem::Instance().EnumerateDirectory(
|
|
m_device_support_directory, find_directories, find_files, find_other,
|
|
GetContainedFilesIntoVectorOfStringsCallback,
|
|
&builtin_sdk_directory_infos);
|
|
|
|
// Only add SDK directories that have symbols in them, some SDKs only
|
|
// contain developer disk images and no symbols, so they aren't useful to
|
|
// us.
|
|
FileSpec sdk_symbols_symlink_fspec;
|
|
for (const auto &sdk_directory_info : builtin_sdk_directory_infos) {
|
|
sdk_symbols_symlink_fspec = sdk_directory_info.directory;
|
|
sdk_symbols_symlink_fspec.AppendPathComponent("Symbols");
|
|
if (FileSystem::Instance().Exists(sdk_symbols_symlink_fspec)) {
|
|
m_sdk_directory_infos.push_back(sdk_directory_info);
|
|
if (log) {
|
|
LLDB_LOGF(log,
|
|
"PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
|
|
"added builtin SDK directory %s",
|
|
sdk_symbols_symlink_fspec.GetPath().c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
const uint32_t num_installed = m_sdk_directory_infos.size();
|
|
llvm::StringRef dirname = GetDeviceSupportDirectoryName();
|
|
std::string local_sdk_cache_str = "~/Library/Developer/Xcode/";
|
|
local_sdk_cache_str += std::string(dirname);
|
|
FileSpec local_sdk_cache(local_sdk_cache_str.c_str());
|
|
FileSystem::Instance().Resolve(local_sdk_cache);
|
|
if (FileSystem::Instance().Exists(local_sdk_cache)) {
|
|
if (log) {
|
|
LLDB_LOGF(log,
|
|
"PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
|
|
"searching %s for additional SDKs",
|
|
local_sdk_cache.GetPath().c_str());
|
|
}
|
|
char path[PATH_MAX];
|
|
if (local_sdk_cache.GetPath(path, sizeof(path))) {
|
|
FileSystem::Instance().EnumerateDirectory(
|
|
path, find_directories, find_files, find_other,
|
|
GetContainedFilesIntoVectorOfStringsCallback,
|
|
&m_sdk_directory_infos);
|
|
const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
|
|
// First try for an exact match of major, minor and update
|
|
for (uint32_t i = num_installed; i < num_sdk_infos; ++i) {
|
|
m_sdk_directory_infos[i].user_cached = true;
|
|
if (log) {
|
|
LLDB_LOGF(log,
|
|
"PlatformDarwinDevice::"
|
|
"UpdateSDKDirectoryInfosIfNeeded "
|
|
"user SDK directory %s",
|
|
m_sdk_directory_infos[i].directory.GetPath().c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const char *addtional_platform_dirs = getenv("PLATFORM_SDK_DIRECTORY");
|
|
if (addtional_platform_dirs) {
|
|
SDKDirectoryInfoCollection env_var_sdk_directory_infos;
|
|
FileSystem::Instance().EnumerateDirectory(
|
|
addtional_platform_dirs, find_directories, find_files, find_other,
|
|
GetContainedFilesIntoVectorOfStringsCallback,
|
|
&env_var_sdk_directory_infos);
|
|
FileSpec sdk_symbols_symlink_fspec;
|
|
for (const auto &sdk_directory_info : env_var_sdk_directory_infos) {
|
|
sdk_symbols_symlink_fspec = sdk_directory_info.directory;
|
|
sdk_symbols_symlink_fspec.AppendPathComponent("Symbols");
|
|
if (FileSystem::Instance().Exists(sdk_symbols_symlink_fspec)) {
|
|
m_sdk_directory_infos.push_back(sdk_directory_info);
|
|
if (log) {
|
|
LLDB_LOGF(log,
|
|
"PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
|
|
"added env var SDK directory %s",
|
|
sdk_symbols_symlink_fspec.GetPath().c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return !m_sdk_directory_infos.empty();
|
|
}
|
|
|
|
const PlatformDarwinDevice::SDKDirectoryInfo *
|
|
PlatformDarwinDevice::GetSDKDirectoryForCurrentOSVersion() {
|
|
uint32_t i;
|
|
if (UpdateSDKDirectoryInfosIfNeeded()) {
|
|
const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
|
|
std::vector<bool> check_sdk_info(num_sdk_infos, true);
|
|
|
|
// Prefer the user SDK build string.
|
|
ConstString build = GetSDKBuild();
|
|
|
|
// Fall back to the platform's build string.
|
|
if (!build) {
|
|
if (llvm::Optional<std::string> os_build_str = GetOSBuildString()) {
|
|
build = ConstString(*os_build_str);
|
|
}
|
|
}
|
|
|
|
// If we have a build string, only check platforms for which the build
|
|
// string matches.
|
|
if (build) {
|
|
for (i = 0; i < num_sdk_infos; ++i)
|
|
check_sdk_info[i] = m_sdk_directory_infos[i].build == build;
|
|
}
|
|
|
|
// If we are connected we can find the version of the OS the platform us
|
|
// running on and select the right SDK
|
|
llvm::VersionTuple version = GetOSVersion();
|
|
if (!version.empty()) {
|
|
if (UpdateSDKDirectoryInfosIfNeeded()) {
|
|
// First try for an exact match of major, minor and update.
|
|
for (i = 0; i < num_sdk_infos; ++i) {
|
|
if (check_sdk_info[i]) {
|
|
if (m_sdk_directory_infos[i].version == version)
|
|
return &m_sdk_directory_infos[i];
|
|
}
|
|
}
|
|
// Try for an exact match of major and minor.
|
|
for (i = 0; i < num_sdk_infos; ++i) {
|
|
if (check_sdk_info[i]) {
|
|
if (m_sdk_directory_infos[i].version.getMajor() ==
|
|
version.getMajor() &&
|
|
m_sdk_directory_infos[i].version.getMinor() ==
|
|
version.getMinor()) {
|
|
return &m_sdk_directory_infos[i];
|
|
}
|
|
}
|
|
}
|
|
// Lastly try to match of major version only.
|
|
for (i = 0; i < num_sdk_infos; ++i) {
|
|
if (check_sdk_info[i]) {
|
|
if (m_sdk_directory_infos[i].version.getMajor() ==
|
|
version.getMajor()) {
|
|
return &m_sdk_directory_infos[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (build) {
|
|
// No version, just a build number, return the first one that matches.
|
|
for (i = 0; i < num_sdk_infos; ++i)
|
|
if (check_sdk_info[i])
|
|
return &m_sdk_directory_infos[i];
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const PlatformDarwinDevice::SDKDirectoryInfo *
|
|
PlatformDarwinDevice::GetSDKDirectoryForLatestOSVersion() {
|
|
const PlatformDarwinDevice::SDKDirectoryInfo *result = nullptr;
|
|
if (UpdateSDKDirectoryInfosIfNeeded()) {
|
|
auto max = std::max_element(
|
|
m_sdk_directory_infos.begin(), m_sdk_directory_infos.end(),
|
|
[](const SDKDirectoryInfo &a, const SDKDirectoryInfo &b) {
|
|
return a.version < b.version;
|
|
});
|
|
if (max != m_sdk_directory_infos.end())
|
|
result = &*max;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const char *PlatformDarwinDevice::GetDeviceSupportDirectory() {
|
|
std::string platform_dir =
|
|
("/Platforms/" + GetPlatformName() + "/DeviceSupport").str();
|
|
if (m_device_support_directory.empty()) {
|
|
if (FileSpec fspec = HostInfo::GetXcodeDeveloperDirectory()) {
|
|
m_device_support_directory = fspec.GetPath();
|
|
m_device_support_directory.append(platform_dir.c_str());
|
|
} else {
|
|
// Assign a single NULL character so we know we tried to find the device
|
|
// support directory and we don't keep trying to find it over and over.
|
|
m_device_support_directory.assign(1, '\0');
|
|
}
|
|
}
|
|
// We should have put a single NULL character into m_device_support_directory
|
|
// or it should have a valid path if the code gets here
|
|
assert(m_device_support_directory.empty() == false);
|
|
if (m_device_support_directory[0])
|
|
return m_device_support_directory.c_str();
|
|
return nullptr;
|
|
}
|
|
|
|
const char *PlatformDarwinDevice::GetDeviceSupportDirectoryForOSVersion() {
|
|
if (m_sdk_sysroot)
|
|
return m_sdk_sysroot.GetCString();
|
|
|
|
if (m_device_support_directory_for_os_version.empty()) {
|
|
const PlatformDarwinDevice::SDKDirectoryInfo *sdk_dir_info =
|
|
GetSDKDirectoryForCurrentOSVersion();
|
|
if (sdk_dir_info == nullptr)
|
|
sdk_dir_info = GetSDKDirectoryForLatestOSVersion();
|
|
if (sdk_dir_info) {
|
|
char path[PATH_MAX];
|
|
if (sdk_dir_info->directory.GetPath(path, sizeof(path))) {
|
|
m_device_support_directory_for_os_version = path;
|
|
return m_device_support_directory_for_os_version.c_str();
|
|
}
|
|
} else {
|
|
// Assign a single NULL character so we know we tried to find the device
|
|
// support directory and we don't keep trying to find it over and over.
|
|
m_device_support_directory_for_os_version.assign(1, '\0');
|
|
}
|
|
}
|
|
// We should have put a single NULL character into
|
|
// m_device_support_directory_for_os_version or it should have a valid path
|
|
// if the code gets here
|
|
assert(m_device_support_directory_for_os_version.empty() == false);
|
|
if (m_device_support_directory_for_os_version[0])
|
|
return m_device_support_directory_for_os_version.c_str();
|
|
return nullptr;
|
|
}
|
|
|
|
static lldb_private::Status
|
|
MakeCacheFolderForFile(const FileSpec &module_cache_spec) {
|
|
FileSpec module_cache_folder =
|
|
module_cache_spec.CopyByRemovingLastPathComponent();
|
|
return llvm::sys::fs::create_directory(module_cache_folder.GetPath());
|
|
}
|
|
|
|
static lldb_private::Status
|
|
BringInRemoteFile(Platform *platform,
|
|
const lldb_private::ModuleSpec &module_spec,
|
|
const FileSpec &module_cache_spec) {
|
|
MakeCacheFolderForFile(module_cache_spec);
|
|
Status err = platform->GetFile(module_spec.GetFileSpec(), module_cache_spec);
|
|
return err;
|
|
}
|
|
|
|
lldb_private::Status PlatformDarwinDevice::GetSharedModuleWithLocalCache(
|
|
const lldb_private::ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
|
|
const lldb_private::FileSpecList *module_search_paths_ptr,
|
|
llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules, bool *did_create_ptr) {
|
|
|
|
Log *log = GetLog(LLDBLog::Platform);
|
|
LLDB_LOGF(log,
|
|
"[%s] Trying to find module %s/%s - platform path %s/%s symbol "
|
|
"path %s/%s",
|
|
(IsHost() ? "host" : "remote"),
|
|
module_spec.GetFileSpec().GetDirectory().AsCString(),
|
|
module_spec.GetFileSpec().GetFilename().AsCString(),
|
|
module_spec.GetPlatformFileSpec().GetDirectory().AsCString(),
|
|
module_spec.GetPlatformFileSpec().GetFilename().AsCString(),
|
|
module_spec.GetSymbolFileSpec().GetDirectory().AsCString(),
|
|
module_spec.GetSymbolFileSpec().GetFilename().AsCString());
|
|
|
|
Status err;
|
|
|
|
if (CheckLocalSharedCache()) {
|
|
// When debugging on the host, we are most likely using the same shared
|
|
// cache as our inferior. The dylibs from the shared cache might not
|
|
// exist on the filesystem, so let's use the images in our own memory
|
|
// to create the modules.
|
|
|
|
// Check if the requested image is in our shared cache.
|
|
SharedCacheImageInfo image_info =
|
|
HostInfo::GetSharedCacheImageInfo(module_spec.GetFileSpec().GetPath());
|
|
|
|
// If we found it and it has the correct UUID, let's proceed with
|
|
// creating a module from the memory contents.
|
|
if (image_info.uuid &&
|
|
(!module_spec.GetUUID() || module_spec.GetUUID() == image_info.uuid)) {
|
|
ModuleSpec shared_cache_spec(module_spec.GetFileSpec(), image_info.uuid,
|
|
image_info.data_sp);
|
|
err = ModuleList::GetSharedModule(shared_cache_spec, module_sp,
|
|
module_search_paths_ptr, old_modules,
|
|
did_create_ptr);
|
|
if (module_sp) {
|
|
LLDB_LOGF(log, "[%s] module %s was found in the in-memory shared cache",
|
|
(IsHost() ? "host" : "remote"),
|
|
module_spec.GetFileSpec().GetPath().c_str());
|
|
return err;
|
|
}
|
|
}
|
|
|
|
// We failed to find the module in our shared cache. Let's see if we have a
|
|
// copy in our device support directory.
|
|
FileSpec device_support_spec(GetDeviceSupportDirectoryForOSVersion());
|
|
device_support_spec.AppendPathComponent("Symbols");
|
|
device_support_spec.AppendPathComponent(
|
|
module_spec.GetFileSpec().GetPath());
|
|
FileSystem::Instance().Resolve(device_support_spec);
|
|
if (FileSystem::Instance().Exists(device_support_spec)) {
|
|
ModuleSpec local_spec(device_support_spec, module_spec.GetUUID());
|
|
err = ModuleList::GetSharedModule(local_spec, module_sp,
|
|
module_search_paths_ptr, old_modules,
|
|
did_create_ptr);
|
|
if (module_sp) {
|
|
LLDB_LOGF(log,
|
|
"[%s] module %s was found in Device Support "
|
|
"directory: %s",
|
|
(IsHost() ? "host" : "remote"),
|
|
module_spec.GetFileSpec().GetPath().c_str(),
|
|
local_spec.GetFileSpec().GetPath().c_str());
|
|
return err;
|
|
}
|
|
}
|
|
}
|
|
|
|
err = ModuleList::GetSharedModule(module_spec, module_sp,
|
|
module_search_paths_ptr, old_modules,
|
|
did_create_ptr);
|
|
if (module_sp)
|
|
return err;
|
|
|
|
if (!IsHost()) {
|
|
std::string cache_path(GetLocalCacheDirectory());
|
|
// Only search for a locally cached file if we have a valid cache path
|
|
if (!cache_path.empty()) {
|
|
std::string module_path(module_spec.GetFileSpec().GetPath());
|
|
cache_path.append(module_path);
|
|
FileSpec module_cache_spec(cache_path);
|
|
|
|
// if rsync is supported, always bring in the file - rsync will be very
|
|
// efficient when files are the same on the local and remote end of the
|
|
// connection
|
|
if (this->GetSupportsRSync()) {
|
|
err = BringInRemoteFile(this, module_spec, module_cache_spec);
|
|
if (err.Fail())
|
|
return err;
|
|
if (FileSystem::Instance().Exists(module_cache_spec)) {
|
|
Log *log = GetLog(LLDBLog::Platform);
|
|
LLDB_LOGF(log, "[%s] module %s/%s was rsynced and is now there",
|
|
(IsHost() ? "host" : "remote"),
|
|
module_spec.GetFileSpec().GetDirectory().AsCString(),
|
|
module_spec.GetFileSpec().GetFilename().AsCString());
|
|
ModuleSpec local_spec(module_cache_spec,
|
|
module_spec.GetArchitecture());
|
|
module_sp = std::make_shared<Module>(local_spec);
|
|
module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
|
|
return Status();
|
|
}
|
|
}
|
|
|
|
// try to find the module in the cache
|
|
if (FileSystem::Instance().Exists(module_cache_spec)) {
|
|
// get the local and remote MD5 and compare
|
|
if (m_remote_platform_sp) {
|
|
// when going over the *slow* GDB remote transfer mechanism we first
|
|
// check the hashes of the files - and only do the actual transfer if
|
|
// they differ
|
|
uint64_t high_local, high_remote, low_local, low_remote;
|
|
auto MD5 = llvm::sys::fs::md5_contents(module_cache_spec.GetPath());
|
|
if (!MD5)
|
|
return Status(MD5.getError());
|
|
std::tie(high_local, low_local) = MD5->words();
|
|
|
|
m_remote_platform_sp->CalculateMD5(module_spec.GetFileSpec(),
|
|
low_remote, high_remote);
|
|
if (low_local != low_remote || high_local != high_remote) {
|
|
// bring in the remote file
|
|
Log *log = GetLog(LLDBLog::Platform);
|
|
LLDB_LOGF(log,
|
|
"[%s] module %s/%s needs to be replaced from remote copy",
|
|
(IsHost() ? "host" : "remote"),
|
|
module_spec.GetFileSpec().GetDirectory().AsCString(),
|
|
module_spec.GetFileSpec().GetFilename().AsCString());
|
|
Status err =
|
|
BringInRemoteFile(this, module_spec, module_cache_spec);
|
|
if (err.Fail())
|
|
return err;
|
|
}
|
|
}
|
|
|
|
ModuleSpec local_spec(module_cache_spec, module_spec.GetArchitecture());
|
|
module_sp = std::make_shared<Module>(local_spec);
|
|
module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
|
|
Log *log = GetLog(LLDBLog::Platform);
|
|
LLDB_LOGF(log, "[%s] module %s/%s was found in the cache",
|
|
(IsHost() ? "host" : "remote"),
|
|
module_spec.GetFileSpec().GetDirectory().AsCString(),
|
|
module_spec.GetFileSpec().GetFilename().AsCString());
|
|
return Status();
|
|
}
|
|
|
|
// bring in the remote module file
|
|
LLDB_LOGF(log, "[%s] module %s/%s needs to come in remotely",
|
|
(IsHost() ? "host" : "remote"),
|
|
module_spec.GetFileSpec().GetDirectory().AsCString(),
|
|
module_spec.GetFileSpec().GetFilename().AsCString());
|
|
Status err = BringInRemoteFile(this, module_spec, module_cache_spec);
|
|
if (err.Fail())
|
|
return err;
|
|
if (FileSystem::Instance().Exists(module_cache_spec)) {
|
|
Log *log = GetLog(LLDBLog::Platform);
|
|
LLDB_LOGF(log, "[%s] module %s/%s is now cached and fine",
|
|
(IsHost() ? "host" : "remote"),
|
|
module_spec.GetFileSpec().GetDirectory().AsCString(),
|
|
module_spec.GetFileSpec().GetFilename().AsCString());
|
|
ModuleSpec local_spec(module_cache_spec, module_spec.GetArchitecture());
|
|
module_sp = std::make_shared<Module>(local_spec);
|
|
module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
|
|
return Status();
|
|
} else
|
|
return Status("unable to obtain valid module file");
|
|
} else
|
|
return Status("no cache path");
|
|
} else
|
|
return Status("unable to resolve module");
|
|
}
|