655 lines
25 KiB
C++
655 lines
25 KiB
C++
//===-- PlatformRemoteDarwinDevice.cpp -----------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "PlatformRemoteDarwinDevice.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Breakpoint/BreakpointLocation.h"
|
|
#include "lldb/Core/ArchSpec.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/ModuleList.h"
|
|
#include "lldb/Core/ModuleSpec.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Host/Host.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Utility/FileSpec.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/Utility/Status.h"
|
|
#include "lldb/Utility/StreamString.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
PlatformRemoteDarwinDevice::SDKDirectoryInfo::SDKDirectoryInfo(
|
|
const lldb_private::FileSpec &sdk_dir)
|
|
: directory(sdk_dir), build(), version_major(0), version_minor(0),
|
|
version_update(0), user_cached(false) {
|
|
llvm::StringRef dirname_str = sdk_dir.GetFilename().GetStringRef();
|
|
llvm::StringRef build_str;
|
|
std::tie(version_major, version_minor, version_update, build_str) =
|
|
ParseVersionBuildDir(dirname_str);
|
|
build.SetString(build_str);
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
/// Default Constructor
|
|
//------------------------------------------------------------------
|
|
PlatformRemoteDarwinDevice::PlatformRemoteDarwinDevice()
|
|
: PlatformDarwin(false), // This is a remote platform
|
|
m_sdk_directory_infos(), m_device_support_directory(),
|
|
m_device_support_directory_for_os_version(), m_build_update(),
|
|
m_last_module_sdk_idx(UINT32_MAX),
|
|
m_connected_module_sdk_idx(UINT32_MAX) {}
|
|
|
|
//------------------------------------------------------------------
|
|
/// Destructor.
|
|
///
|
|
/// The destructor is virtual since this class is designed to be
|
|
/// inherited from by the plug-in instance.
|
|
//------------------------------------------------------------------
|
|
PlatformRemoteDarwinDevice::~PlatformRemoteDarwinDevice() {}
|
|
|
|
void PlatformRemoteDarwinDevice::GetStatus(Stream &strm) {
|
|
Platform::GetStatus(strm);
|
|
const char *sdk_directory = GetDeviceSupportDirectoryForOSVersion();
|
|
if (sdk_directory)
|
|
strm.Printf(" SDK Path: \"%s\"\n", sdk_directory);
|
|
else
|
|
strm.PutCString(" SDK Path: error: unable to locate SDK\n");
|
|
|
|
const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
|
|
for (uint32_t i = 0; i < num_sdk_infos; ++i) {
|
|
const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[i];
|
|
strm.Printf(" SDK Roots: [%2u] \"%s\"\n", i,
|
|
sdk_dir_info.directory.GetPath().c_str());
|
|
}
|
|
}
|
|
|
|
Status PlatformRemoteDarwinDevice::ResolveExecutable(
|
|
const ModuleSpec &ms, lldb::ModuleSP &exe_module_sp,
|
|
const FileSpecList *module_search_paths_ptr) {
|
|
Status error;
|
|
// Nothing special to do here, just use the actual file and architecture
|
|
|
|
ModuleSpec resolved_module_spec(ms);
|
|
|
|
// Resolve any executable within a bundle on MacOSX
|
|
// TODO: verify that this handles shallow bundles, if not then implement one
|
|
// ourselves
|
|
Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
|
|
|
|
if (resolved_module_spec.GetFileSpec().Exists()) {
|
|
if (resolved_module_spec.GetArchitecture().IsValid() ||
|
|
resolved_module_spec.GetUUID().IsValid()) {
|
|
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
|
|
NULL, NULL, NULL);
|
|
|
|
if (exe_module_sp && exe_module_sp->GetObjectFile())
|
|
return error;
|
|
exe_module_sp.reset();
|
|
}
|
|
// No valid architecture was specified or the exact ARM slice wasn't
|
|
// found so 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());
|
|
}
|
|
}
|
|
} else {
|
|
error.SetErrorStringWithFormat(
|
|
"'%s' does not exist",
|
|
resolved_module_spec.GetFileSpec().GetPath().c_str());
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
FileSpec::EnumerateDirectoryResult
|
|
PlatformRemoteDarwinDevice::GetContainedFilesIntoVectorOfStringsCallback(
|
|
void *baton, llvm::sys::fs::file_type ft, const FileSpec &file_spec) {
|
|
((PlatformRemoteDarwinDevice::SDKDirectoryInfoCollection *)baton)
|
|
->push_back(PlatformRemoteDarwinDevice::SDKDirectoryInfo(file_spec));
|
|
return FileSpec::eEnumerateDirectoryResultNext;
|
|
}
|
|
|
|
bool PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded() {
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_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(), true);
|
|
const SDKDirectoryInfo sdk_sysroot_directory_info(sdk_sysroot_fspec);
|
|
m_sdk_directory_infos.push_back(sdk_sysroot_directory_info);
|
|
if (log) {
|
|
log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded added "
|
|
"--sysroot SDK directory %s",
|
|
m_sdk_sysroot.GetCString());
|
|
}
|
|
return true;
|
|
}
|
|
const char *device_support_dir = GetDeviceSupportDirectory();
|
|
if (log) {
|
|
log->Printf("PlatformRemoteDarwinDevice::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;
|
|
FileSpec::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 (sdk_symbols_symlink_fspec.Exists()) {
|
|
m_sdk_directory_infos.push_back(sdk_directory_info);
|
|
if (log) {
|
|
log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
|
|
"added builtin SDK directory %s",
|
|
sdk_symbols_symlink_fspec.GetPath().c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<std::string> device_support_dirnames;
|
|
GetDeviceSupportDirectoryNames (device_support_dirnames);
|
|
|
|
for (std::string &dirname : device_support_dirnames)
|
|
{
|
|
const uint32_t num_installed = m_sdk_directory_infos.size();
|
|
std::string local_sdk_cache_str = "~/Library/Developer/Xcode/";
|
|
local_sdk_cache_str += dirname;
|
|
FileSpec local_sdk_cache(local_sdk_cache_str.c_str(), true);
|
|
if (local_sdk_cache.Exists()) {
|
|
if (log) {
|
|
log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
|
|
"searching %s for additional SDKs",
|
|
local_sdk_cache.GetPath().c_str());
|
|
}
|
|
char path[PATH_MAX];
|
|
if (local_sdk_cache.GetPath(path, sizeof(path))) {
|
|
FileSpec::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) {
|
|
log->Printf("PlatformRemoteDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
|
|
"user SDK directory %s",
|
|
m_sdk_directory_infos[i].directory.GetPath().c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return !m_sdk_directory_infos.empty();
|
|
}
|
|
|
|
const PlatformRemoteDarwinDevice::SDKDirectoryInfo *
|
|
PlatformRemoteDarwinDevice::GetSDKDirectoryForCurrentOSVersion() {
|
|
uint32_t i;
|
|
if (UpdateSDKDirectoryInfosIfNeeded()) {
|
|
const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
|
|
|
|
// Check to see if the user specified a build string. If they did, then
|
|
// be sure to match it.
|
|
std::vector<bool> check_sdk_info(num_sdk_infos, true);
|
|
ConstString build(m_sdk_build);
|
|
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
|
|
uint32_t major, minor, update;
|
|
if (GetOSVersion(major, minor, update)) {
|
|
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_major == major &&
|
|
m_sdk_directory_infos[i].version_minor == minor &&
|
|
m_sdk_directory_infos[i].version_update == update) {
|
|
return &m_sdk_directory_infos[i];
|
|
}
|
|
}
|
|
}
|
|
// First 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_major == major &&
|
|
m_sdk_directory_infos[i].version_minor == minor) {
|
|
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_major == major) {
|
|
return &m_sdk_directory_infos[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (build) {
|
|
// No version, just a build number, search for 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 NULL;
|
|
}
|
|
|
|
const PlatformRemoteDarwinDevice::SDKDirectoryInfo *
|
|
PlatformRemoteDarwinDevice::GetSDKDirectoryForLatestOSVersion() {
|
|
const PlatformRemoteDarwinDevice::SDKDirectoryInfo *result = NULL;
|
|
if (UpdateSDKDirectoryInfosIfNeeded()) {
|
|
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 = 0; i < num_sdk_infos; ++i) {
|
|
const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[i];
|
|
if (sdk_dir_info.version_major != UINT32_MAX) {
|
|
if (result == NULL ||
|
|
sdk_dir_info.version_major > result->version_major) {
|
|
result = &sdk_dir_info;
|
|
} else if (sdk_dir_info.version_major == result->version_major) {
|
|
if (sdk_dir_info.version_minor > result->version_minor) {
|
|
result = &sdk_dir_info;
|
|
} else if (sdk_dir_info.version_minor == result->version_minor) {
|
|
if (sdk_dir_info.version_update > result->version_update) {
|
|
result = &sdk_dir_info;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const char *PlatformRemoteDarwinDevice::GetDeviceSupportDirectory() {
|
|
std::string platform_dir = "/Platforms/" + GetPlatformName() + "/DeviceSupport";
|
|
if (m_device_support_directory.empty()) {
|
|
const char *device_support_dir = GetDeveloperDirectory();
|
|
if (device_support_dir) {
|
|
m_device_support_directory.assign(device_support_dir);
|
|
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 NULL;
|
|
}
|
|
|
|
const char *PlatformRemoteDarwinDevice::GetDeviceSupportDirectoryForOSVersion() {
|
|
if (m_sdk_sysroot)
|
|
return m_sdk_sysroot.GetCString();
|
|
|
|
if (m_device_support_directory_for_os_version.empty()) {
|
|
const PlatformRemoteDarwinDevice::SDKDirectoryInfo *sdk_dir_info =
|
|
GetSDKDirectoryForCurrentOSVersion();
|
|
if (sdk_dir_info == NULL)
|
|
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 NULL;
|
|
}
|
|
|
|
uint32_t PlatformRemoteDarwinDevice::FindFileInAllSDKs(const char *platform_file_path,
|
|
FileSpecList &file_list) {
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
|
|
if (platform_file_path && platform_file_path[0] &&
|
|
UpdateSDKDirectoryInfosIfNeeded()) {
|
|
const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
|
|
lldb_private::FileSpec local_file;
|
|
// First try for an exact match of major, minor and update
|
|
for (uint32_t sdk_idx = 0; sdk_idx < num_sdk_infos; ++sdk_idx) {
|
|
LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file_path,
|
|
m_sdk_directory_infos[sdk_idx].directory);
|
|
if (GetFileInSDK(platform_file_path, sdk_idx, local_file)) {
|
|
file_list.Append(local_file);
|
|
}
|
|
}
|
|
}
|
|
return file_list.GetSize();
|
|
}
|
|
|
|
bool PlatformRemoteDarwinDevice::GetFileInSDK(const char *platform_file_path,
|
|
uint32_t sdk_idx,
|
|
lldb_private::FileSpec &local_file) {
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
|
|
if (sdk_idx < m_sdk_directory_infos.size()) {
|
|
std::string sdkroot_path =
|
|
m_sdk_directory_infos[sdk_idx].directory.GetPath();
|
|
local_file.Clear();
|
|
|
|
if (!sdkroot_path.empty() && platform_file_path && platform_file_path[0]) {
|
|
// We may need to interpose "/Symbols/" or "/Symbols.Internal/" between
|
|
// the
|
|
// SDK root directory and the file path.
|
|
|
|
const char *paths_to_try[] = {"Symbols", "", "Symbols.Internal", nullptr};
|
|
for (size_t i = 0; paths_to_try[i] != nullptr; i++) {
|
|
local_file.SetFile(sdkroot_path, false);
|
|
if (paths_to_try[i][0] != '\0')
|
|
local_file.AppendPathComponent(paths_to_try[i]);
|
|
local_file.AppendPathComponent(platform_file_path);
|
|
local_file.ResolvePath();
|
|
if (local_file.Exists()) {
|
|
if (log)
|
|
log->Printf("Found a copy of %s in the SDK dir %s/%s",
|
|
platform_file_path, sdkroot_path.c_str(),
|
|
paths_to_try[i]);
|
|
return true;
|
|
}
|
|
local_file.Clear();
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Status PlatformRemoteDarwinDevice::GetSymbolFile(const FileSpec &platform_file,
|
|
const UUID *uuid_ptr,
|
|
FileSpec &local_file) {
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
|
|
Status error;
|
|
char platform_file_path[PATH_MAX];
|
|
if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
|
|
char resolved_path[PATH_MAX];
|
|
|
|
const char *os_version_dir = GetDeviceSupportDirectoryForOSVersion();
|
|
if (os_version_dir) {
|
|
::snprintf(resolved_path, sizeof(resolved_path), "%s/%s", os_version_dir,
|
|
platform_file_path);
|
|
|
|
local_file.SetFile(resolved_path, true);
|
|
if (local_file.Exists()) {
|
|
if (log) {
|
|
log->Printf("Found a copy of %s in the DeviceSupport dir %s",
|
|
platform_file_path, os_version_dir);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
::snprintf(resolved_path, sizeof(resolved_path), "%s/Symbols.Internal/%s",
|
|
os_version_dir, platform_file_path);
|
|
|
|
local_file.SetFile(resolved_path, true);
|
|
if (local_file.Exists()) {
|
|
if (log) {
|
|
log->Printf(
|
|
"Found a copy of %s in the DeviceSupport dir %s/Symbols.Internal",
|
|
platform_file_path, os_version_dir);
|
|
}
|
|
return error;
|
|
}
|
|
::snprintf(resolved_path, sizeof(resolved_path), "%s/Symbols/%s",
|
|
os_version_dir, platform_file_path);
|
|
|
|
local_file.SetFile(resolved_path, true);
|
|
if (local_file.Exists()) {
|
|
if (log) {
|
|
log->Printf("Found a copy of %s in the DeviceSupport dir %s/Symbols",
|
|
platform_file_path, os_version_dir);
|
|
}
|
|
return error;
|
|
}
|
|
}
|
|
local_file = platform_file;
|
|
if (local_file.Exists())
|
|
return error;
|
|
|
|
error.SetErrorStringWithFormat(
|
|
"unable to locate a platform file for '%s' in platform '%s'",
|
|
platform_file_path, GetPluginName().GetCString());
|
|
} else {
|
|
error.SetErrorString("invalid platform file argument");
|
|
}
|
|
return error;
|
|
}
|
|
|
|
Status PlatformRemoteDarwinDevice::GetSharedModule(
|
|
const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
|
|
const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr,
|
|
bool *did_create_ptr) {
|
|
// For iOS, the SDK files are all cached locally on the host
|
|
// system. So first we ask for the file in the cached SDK,
|
|
// then we attempt to get a shared module for the right architecture
|
|
// with the right UUID.
|
|
const FileSpec &platform_file = module_spec.GetFileSpec();
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
|
|
|
|
Status error;
|
|
char platform_file_path[PATH_MAX];
|
|
|
|
if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
|
|
ModuleSpec platform_module_spec(module_spec);
|
|
|
|
UpdateSDKDirectoryInfosIfNeeded();
|
|
|
|
const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
|
|
|
|
// If we are connected we migth be able to correctly deduce the SDK
|
|
// directory
|
|
// using the OS build.
|
|
const uint32_t connected_sdk_idx = GetConnectedSDKIndex();
|
|
if (connected_sdk_idx < num_sdk_infos) {
|
|
LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
|
|
m_sdk_directory_infos[connected_sdk_idx].directory);
|
|
if (GetFileInSDK(platform_file_path, connected_sdk_idx,
|
|
platform_module_spec.GetFileSpec())) {
|
|
module_sp.reset();
|
|
error = ResolveExecutable(platform_module_spec, module_sp, NULL);
|
|
if (module_sp) {
|
|
m_last_module_sdk_idx = connected_sdk_idx;
|
|
error.Clear();
|
|
return error;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Try the last SDK index if it is set as most files from an SDK
|
|
// will tend to be valid in that same SDK.
|
|
if (m_last_module_sdk_idx < num_sdk_infos) {
|
|
LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
|
|
m_sdk_directory_infos[m_last_module_sdk_idx].directory);
|
|
if (GetFileInSDK(platform_file_path, m_last_module_sdk_idx,
|
|
platform_module_spec.GetFileSpec())) {
|
|
module_sp.reset();
|
|
error = ResolveExecutable(platform_module_spec, module_sp, NULL);
|
|
if (module_sp) {
|
|
error.Clear();
|
|
return error;
|
|
}
|
|
}
|
|
}
|
|
|
|
// First try for an exact match of major, minor and update:
|
|
// If a particalar SDK version was specified via --version or --build, look
|
|
// for a match on disk.
|
|
const SDKDirectoryInfo *current_sdk_info =
|
|
GetSDKDirectoryForCurrentOSVersion();
|
|
const uint32_t current_sdk_idx =
|
|
GetSDKIndexBySDKDirectoryInfo(current_sdk_info);
|
|
if (current_sdk_idx < num_sdk_infos &&
|
|
current_sdk_idx != m_last_module_sdk_idx) {
|
|
LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
|
|
m_sdk_directory_infos[current_sdk_idx].directory);
|
|
if (GetFileInSDK(platform_file_path, current_sdk_idx,
|
|
platform_module_spec.GetFileSpec())) {
|
|
module_sp.reset();
|
|
error = ResolveExecutable(platform_module_spec, module_sp, NULL);
|
|
if (module_sp) {
|
|
m_last_module_sdk_idx = current_sdk_idx;
|
|
error.Clear();
|
|
return error;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Second try all SDKs that were found.
|
|
for (uint32_t sdk_idx = 0; sdk_idx < num_sdk_infos; ++sdk_idx) {
|
|
if (m_last_module_sdk_idx == sdk_idx) {
|
|
// Skip the last module SDK index if we already searched
|
|
// it above
|
|
continue;
|
|
}
|
|
LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
|
|
m_sdk_directory_infos[sdk_idx].directory);
|
|
if (GetFileInSDK(platform_file_path, sdk_idx,
|
|
platform_module_spec.GetFileSpec())) {
|
|
// printf ("sdk[%u]: '%s'\n", sdk_idx, local_file.GetPath().c_str());
|
|
|
|
error = ResolveExecutable(platform_module_spec, module_sp, NULL);
|
|
if (module_sp) {
|
|
// Remember the index of the last SDK that we found a file
|
|
// in in case the wrong SDK was selected.
|
|
m_last_module_sdk_idx = sdk_idx;
|
|
error.Clear();
|
|
return error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Not the module we are looking for... Nothing to see here...
|
|
module_sp.reset();
|
|
|
|
// This may not be an SDK-related module. Try whether we can bring in the
|
|
// thing to our local cache.
|
|
error = GetSharedModuleWithLocalCache(module_spec, module_sp,
|
|
module_search_paths_ptr,
|
|
old_module_sp_ptr, did_create_ptr);
|
|
if (error.Success())
|
|
return error;
|
|
|
|
// See if the file is present in any of the module_search_paths_ptr
|
|
// directories.
|
|
if (!module_sp)
|
|
error = PlatformDarwin::FindBundleBinaryInExecSearchPaths (module_spec, process, module_sp,
|
|
module_search_paths_ptr, old_module_sp_ptr, did_create_ptr);
|
|
|
|
if (error.Success())
|
|
return error;
|
|
|
|
const bool always_create = false;
|
|
error = ModuleList::GetSharedModule(
|
|
module_spec, module_sp, module_search_paths_ptr, old_module_sp_ptr,
|
|
did_create_ptr, always_create);
|
|
|
|
if (module_sp)
|
|
module_sp->SetPlatformFileSpec(platform_file);
|
|
|
|
return error;
|
|
}
|
|
|
|
uint32_t PlatformRemoteDarwinDevice::GetConnectedSDKIndex() {
|
|
if (IsConnected()) {
|
|
if (m_connected_module_sdk_idx == UINT32_MAX) {
|
|
std::string build;
|
|
if (GetRemoteOSBuildString(build)) {
|
|
const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
|
|
for (uint32_t i = 0; i < num_sdk_infos; ++i) {
|
|
const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[i];
|
|
if (strstr(sdk_dir_info.directory.GetFilename().AsCString(""),
|
|
build.c_str())) {
|
|
m_connected_module_sdk_idx = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
m_connected_module_sdk_idx = UINT32_MAX;
|
|
}
|
|
return m_connected_module_sdk_idx;
|
|
}
|
|
|
|
uint32_t PlatformRemoteDarwinDevice::GetSDKIndexBySDKDirectoryInfo(
|
|
const SDKDirectoryInfo *sdk_info) {
|
|
if (sdk_info == NULL) {
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
return sdk_info - &m_sdk_directory_infos[0];
|
|
}
|