ba51da820e
TestMultipleTargets is randomly failing on the bots. The reason for that is that the test is calling `SBDebugger::CreateTarget` from multiple threads. `TargetList::CreateTarget` is curiously missing the guard that all of its other member functions have, so all the threads in the test end up changing the internal TargetList state at the same time and end up corrupting it. Reviewed By: vsk, JDevlieghere Differential Revision: https://reviews.llvm.org/D103020
582 lines
22 KiB
C++
582 lines
22 KiB
C++
//===-- TargetList.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 "lldb/Target/TargetList.h"
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/ModuleSpec.h"
|
|
#include "lldb/Host/Host.h"
|
|
#include "lldb/Host/HostInfo.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
#include "lldb/Interpreter/OptionGroupPlatform.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Target/Platform.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Utility/Broadcaster.h"
|
|
#include "lldb/Utility/Event.h"
|
|
#include "lldb/Utility/State.h"
|
|
#include "lldb/Utility/TildeExpressionResolver.h"
|
|
#include "lldb/Utility/Timer.h"
|
|
|
|
#include "llvm/ADT/SmallString.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
ConstString &TargetList::GetStaticBroadcasterClass() {
|
|
static ConstString class_name("lldb.targetList");
|
|
return class_name;
|
|
}
|
|
|
|
// TargetList constructor
|
|
TargetList::TargetList(Debugger &debugger)
|
|
: Broadcaster(debugger.GetBroadcasterManager(),
|
|
TargetList::GetStaticBroadcasterClass().AsCString()),
|
|
m_target_list(), m_target_list_mutex(), m_selected_target_idx(0) {
|
|
CheckInWithManager();
|
|
}
|
|
|
|
Status TargetList::CreateTarget(Debugger &debugger,
|
|
llvm::StringRef user_exe_path,
|
|
llvm::StringRef triple_str,
|
|
LoadDependentFiles load_dependent_files,
|
|
const OptionGroupPlatform *platform_options,
|
|
TargetSP &target_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
auto result = TargetList::CreateTargetInternal(
|
|
debugger, user_exe_path, triple_str, load_dependent_files,
|
|
platform_options, target_sp);
|
|
|
|
if (target_sp && result.Success())
|
|
AddTargetInternal(target_sp, /*do_select*/ true);
|
|
return result;
|
|
}
|
|
|
|
Status TargetList::CreateTarget(Debugger &debugger,
|
|
llvm::StringRef user_exe_path,
|
|
const ArchSpec &specified_arch,
|
|
LoadDependentFiles load_dependent_files,
|
|
PlatformSP &platform_sp, TargetSP &target_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
auto result = TargetList::CreateTargetInternal(
|
|
debugger, user_exe_path, specified_arch, load_dependent_files,
|
|
platform_sp, target_sp);
|
|
|
|
if (target_sp && result.Success())
|
|
AddTargetInternal(target_sp, /*do_select*/ true);
|
|
return result;
|
|
}
|
|
|
|
Status TargetList::CreateTargetInternal(
|
|
Debugger &debugger, llvm::StringRef user_exe_path,
|
|
llvm::StringRef triple_str, LoadDependentFiles load_dependent_files,
|
|
const OptionGroupPlatform *platform_options, TargetSP &target_sp) {
|
|
Status error;
|
|
|
|
// Let's start by looking at the selected platform.
|
|
PlatformSP platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
|
|
|
|
// This variable corresponds to the architecture specified by the triple
|
|
// string. If that string was empty the currently selected platform will
|
|
// determine the architecture.
|
|
const ArchSpec arch(triple_str);
|
|
if (!triple_str.empty() && !arch.IsValid()) {
|
|
error.SetErrorStringWithFormat("invalid triple '%s'",
|
|
triple_str.str().c_str());
|
|
return error;
|
|
}
|
|
|
|
ArchSpec platform_arch(arch);
|
|
|
|
// Create a new platform if a platform was specified in the platform options
|
|
// and doesn't match the selected platform.
|
|
if (platform_options && platform_options->PlatformWasSpecified() &&
|
|
!platform_options->PlatformMatches(platform_sp)) {
|
|
const bool select_platform = true;
|
|
platform_sp = platform_options->CreatePlatformWithOptions(
|
|
debugger.GetCommandInterpreter(), arch, select_platform, error,
|
|
platform_arch);
|
|
if (!platform_sp)
|
|
return error;
|
|
}
|
|
|
|
bool prefer_platform_arch = false;
|
|
auto update_platform_arch = [&](const ArchSpec &module_arch) {
|
|
// If the OS or vendor weren't specified, then adopt the module's
|
|
// architecture so that the platform matching can be more accurate.
|
|
if (!platform_arch.TripleOSWasSpecified() ||
|
|
!platform_arch.TripleVendorWasSpecified()) {
|
|
prefer_platform_arch = true;
|
|
platform_arch = module_arch;
|
|
}
|
|
};
|
|
|
|
if (!user_exe_path.empty()) {
|
|
ModuleSpec module_spec(FileSpec(user_exe_path, FileSpec::Style::native));
|
|
FileSystem::Instance().Resolve(module_spec.GetFileSpec());
|
|
// Resolve the executable in case we are given a path to a application
|
|
// bundle like a .app bundle on MacOSX.
|
|
Host::ResolveExecutableInBundle(module_spec.GetFileSpec());
|
|
|
|
lldb::offset_t file_offset = 0;
|
|
lldb::offset_t file_size = 0;
|
|
ModuleSpecList module_specs;
|
|
const size_t num_specs = ObjectFile::GetModuleSpecifications(
|
|
module_spec.GetFileSpec(), file_offset, file_size, module_specs);
|
|
|
|
if (num_specs > 0) {
|
|
ModuleSpec matching_module_spec;
|
|
|
|
if (num_specs == 1) {
|
|
if (module_specs.GetModuleSpecAtIndex(0, matching_module_spec)) {
|
|
if (platform_arch.IsValid()) {
|
|
if (platform_arch.IsCompatibleMatch(
|
|
matching_module_spec.GetArchitecture())) {
|
|
// If the OS or vendor weren't specified, then adopt the module's
|
|
// architecture so that the platform matching can be more
|
|
// accurate.
|
|
update_platform_arch(matching_module_spec.GetArchitecture());
|
|
} else {
|
|
StreamString platform_arch_strm;
|
|
StreamString module_arch_strm;
|
|
|
|
platform_arch.DumpTriple(platform_arch_strm.AsRawOstream());
|
|
matching_module_spec.GetArchitecture().DumpTriple(
|
|
module_arch_strm.AsRawOstream());
|
|
error.SetErrorStringWithFormat(
|
|
"the specified architecture '%s' is not compatible with '%s' "
|
|
"in '%s'",
|
|
platform_arch_strm.GetData(), module_arch_strm.GetData(),
|
|
module_spec.GetFileSpec().GetPath().c_str());
|
|
return error;
|
|
}
|
|
} else {
|
|
// Only one arch and none was specified.
|
|
prefer_platform_arch = true;
|
|
platform_arch = matching_module_spec.GetArchitecture();
|
|
}
|
|
}
|
|
} else if (arch.IsValid()) {
|
|
// Fat binary. A (valid) architecture was specified.
|
|
module_spec.GetArchitecture() = arch;
|
|
if (module_specs.FindMatchingModuleSpec(module_spec,
|
|
matching_module_spec))
|
|
update_platform_arch(matching_module_spec.GetArchitecture());
|
|
} else {
|
|
// Fat binary. No architecture specified, check if there is
|
|
// only one platform for all of the architectures.
|
|
PlatformSP host_platform_sp = Platform::GetHostPlatform();
|
|
std::vector<PlatformSP> platforms;
|
|
for (size_t i = 0; i < num_specs; ++i) {
|
|
ModuleSpec module_spec;
|
|
if (module_specs.GetModuleSpecAtIndex(i, module_spec)) {
|
|
// First consider the platform specified by the user, if any, and
|
|
// the selected platform otherwise.
|
|
if (platform_sp) {
|
|
if (platform_sp->IsCompatibleArchitecture(
|
|
module_spec.GetArchitecture(), false, nullptr)) {
|
|
platforms.push_back(platform_sp);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Now consider the host platform if it is different from the
|
|
// specified/selected platform.
|
|
if (host_platform_sp &&
|
|
(!platform_sp ||
|
|
host_platform_sp->GetName() != platform_sp->GetName())) {
|
|
if (host_platform_sp->IsCompatibleArchitecture(
|
|
module_spec.GetArchitecture(), false, nullptr)) {
|
|
platforms.push_back(host_platform_sp);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Finally find a platform that matches the architecture in the
|
|
// executable file.
|
|
PlatformSP fallback_platform_sp(
|
|
Platform::GetPlatformForArchitecture(
|
|
module_spec.GetArchitecture(), nullptr));
|
|
if (fallback_platform_sp) {
|
|
platforms.push_back(fallback_platform_sp);
|
|
}
|
|
}
|
|
}
|
|
|
|
Platform *platform_ptr = nullptr;
|
|
bool more_than_one_platforms = false;
|
|
for (const auto &the_platform_sp : platforms) {
|
|
if (platform_ptr) {
|
|
if (platform_ptr->GetName() != the_platform_sp->GetName()) {
|
|
more_than_one_platforms = true;
|
|
platform_ptr = nullptr;
|
|
break;
|
|
}
|
|
} else {
|
|
platform_ptr = the_platform_sp.get();
|
|
}
|
|
}
|
|
|
|
if (platform_ptr) {
|
|
// All platforms for all modules in the executable match, so we can
|
|
// select this platform.
|
|
platform_sp = platforms.front();
|
|
} else if (!more_than_one_platforms) {
|
|
// No platforms claim to support this file.
|
|
error.SetErrorString("no matching platforms found for this file");
|
|
return error;
|
|
} else {
|
|
// More than one platform claims to support this file.
|
|
StreamString error_strm;
|
|
std::set<Platform *> platform_set;
|
|
error_strm.Printf(
|
|
"more than one platform supports this executable (");
|
|
for (const auto &the_platform_sp : platforms) {
|
|
if (platform_set.find(the_platform_sp.get()) ==
|
|
platform_set.end()) {
|
|
if (!platform_set.empty())
|
|
error_strm.PutCString(", ");
|
|
error_strm.PutCString(the_platform_sp->GetName().GetCString());
|
|
platform_set.insert(the_platform_sp.get());
|
|
}
|
|
}
|
|
error_strm.Printf("), specify an architecture to disambiguate");
|
|
error.SetErrorString(error_strm.GetString());
|
|
return error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we have a valid architecture, make sure the current platform is
|
|
// compatible with that architecture.
|
|
if (!prefer_platform_arch && arch.IsValid()) {
|
|
if (!platform_sp->IsCompatibleArchitecture(arch, false, nullptr)) {
|
|
platform_sp = Platform::GetPlatformForArchitecture(arch, &platform_arch);
|
|
if (platform_sp)
|
|
debugger.GetPlatformList().SetSelectedPlatform(platform_sp);
|
|
}
|
|
} else if (platform_arch.IsValid()) {
|
|
// If "arch" isn't valid, yet "platform_arch" is, it means we have an
|
|
// executable file with a single architecture which should be used.
|
|
ArchSpec fixed_platform_arch;
|
|
if (!platform_sp->IsCompatibleArchitecture(platform_arch, false, nullptr)) {
|
|
platform_sp = Platform::GetPlatformForArchitecture(platform_arch,
|
|
&fixed_platform_arch);
|
|
if (platform_sp)
|
|
debugger.GetPlatformList().SetSelectedPlatform(platform_sp);
|
|
}
|
|
}
|
|
|
|
if (!platform_arch.IsValid())
|
|
platform_arch = arch;
|
|
|
|
return TargetList::CreateTargetInternal(debugger, user_exe_path,
|
|
platform_arch, load_dependent_files,
|
|
platform_sp, target_sp);
|
|
}
|
|
|
|
Status TargetList::CreateTargetInternal(Debugger &debugger,
|
|
llvm::StringRef user_exe_path,
|
|
const ArchSpec &specified_arch,
|
|
LoadDependentFiles load_dependent_files,
|
|
lldb::PlatformSP &platform_sp,
|
|
lldb::TargetSP &target_sp) {
|
|
LLDB_SCOPED_TIMERF("TargetList::CreateTarget (file = '%s', arch = '%s')",
|
|
user_exe_path.str().c_str(),
|
|
specified_arch.GetArchitectureName());
|
|
Status error;
|
|
const bool is_dummy_target = false;
|
|
|
|
ArchSpec arch(specified_arch);
|
|
|
|
if (arch.IsValid()) {
|
|
if (!platform_sp ||
|
|
!platform_sp->IsCompatibleArchitecture(arch, false, nullptr))
|
|
platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch);
|
|
}
|
|
|
|
if (!platform_sp)
|
|
platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
|
|
|
|
if (!arch.IsValid())
|
|
arch = specified_arch;
|
|
|
|
FileSpec file(user_exe_path);
|
|
if (!FileSystem::Instance().Exists(file) && user_exe_path.startswith("~")) {
|
|
// we want to expand the tilde but we don't want to resolve any symbolic
|
|
// links so we can't use the FileSpec constructor's resolve flag
|
|
llvm::SmallString<64> unglobbed_path;
|
|
StandardTildeExpressionResolver Resolver;
|
|
Resolver.ResolveFullPath(user_exe_path, unglobbed_path);
|
|
|
|
if (unglobbed_path.empty())
|
|
file = FileSpec(user_exe_path);
|
|
else
|
|
file = FileSpec(unglobbed_path.c_str());
|
|
}
|
|
|
|
bool user_exe_path_is_bundle = false;
|
|
char resolved_bundle_exe_path[PATH_MAX];
|
|
resolved_bundle_exe_path[0] = '\0';
|
|
if (file) {
|
|
if (FileSystem::Instance().IsDirectory(file))
|
|
user_exe_path_is_bundle = true;
|
|
|
|
if (file.IsRelative() && !user_exe_path.empty()) {
|
|
llvm::SmallString<64> cwd;
|
|
if (! llvm::sys::fs::current_path(cwd)) {
|
|
FileSpec cwd_file(cwd.c_str());
|
|
cwd_file.AppendPathComponent(file);
|
|
if (FileSystem::Instance().Exists(cwd_file))
|
|
file = cwd_file;
|
|
}
|
|
}
|
|
|
|
ModuleSP exe_module_sp;
|
|
if (platform_sp) {
|
|
FileSpecList executable_search_paths(
|
|
Target::GetDefaultExecutableSearchPaths());
|
|
ModuleSpec module_spec(file, arch);
|
|
error = platform_sp->ResolveExecutable(module_spec, exe_module_sp,
|
|
executable_search_paths.GetSize()
|
|
? &executable_search_paths
|
|
: nullptr);
|
|
}
|
|
|
|
if (error.Success() && exe_module_sp) {
|
|
if (exe_module_sp->GetObjectFile() == nullptr) {
|
|
if (arch.IsValid()) {
|
|
error.SetErrorStringWithFormat(
|
|
"\"%s\" doesn't contain architecture %s", file.GetPath().c_str(),
|
|
arch.GetArchitectureName());
|
|
} else {
|
|
error.SetErrorStringWithFormat("unsupported file type \"%s\"",
|
|
file.GetPath().c_str());
|
|
}
|
|
return error;
|
|
}
|
|
target_sp.reset(new Target(debugger, arch, platform_sp, is_dummy_target));
|
|
target_sp->SetExecutableModule(exe_module_sp, load_dependent_files);
|
|
if (user_exe_path_is_bundle)
|
|
exe_module_sp->GetFileSpec().GetPath(resolved_bundle_exe_path,
|
|
sizeof(resolved_bundle_exe_path));
|
|
if (target_sp->GetPreloadSymbols())
|
|
exe_module_sp->PreloadSymbols();
|
|
}
|
|
} else {
|
|
// No file was specified, just create an empty target with any arch if a
|
|
// valid arch was specified
|
|
target_sp.reset(new Target(debugger, arch, platform_sp, is_dummy_target));
|
|
}
|
|
|
|
if (!target_sp)
|
|
return error;
|
|
|
|
// Set argv0 with what the user typed, unless the user specified a
|
|
// directory. If the user specified a directory, then it is probably a
|
|
// bundle that was resolved and we need to use the resolved bundle path
|
|
if (!user_exe_path.empty()) {
|
|
// Use exactly what the user typed as the first argument when we exec or
|
|
// posix_spawn
|
|
if (user_exe_path_is_bundle && resolved_bundle_exe_path[0]) {
|
|
target_sp->SetArg0(resolved_bundle_exe_path);
|
|
} else {
|
|
// Use resolved path
|
|
target_sp->SetArg0(file.GetPath().c_str());
|
|
}
|
|
}
|
|
if (file.GetDirectory()) {
|
|
FileSpec file_dir;
|
|
file_dir.GetDirectory() = file.GetDirectory();
|
|
target_sp->AppendExecutableSearchPaths(file_dir);
|
|
}
|
|
|
|
// Now prime this from the dummy target:
|
|
target_sp->PrimeFromDummyTarget(debugger.GetDummyTarget());
|
|
|
|
return error;
|
|
}
|
|
|
|
bool TargetList::DeleteTarget(TargetSP &target_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
auto it = std::find(m_target_list.begin(), m_target_list.end(), target_sp);
|
|
if (it == m_target_list.end())
|
|
return false;
|
|
|
|
m_target_list.erase(it);
|
|
return true;
|
|
}
|
|
|
|
TargetSP TargetList::FindTargetWithExecutableAndArchitecture(
|
|
const FileSpec &exe_file_spec, const ArchSpec *exe_arch_ptr) const {
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
auto it = std::find_if(m_target_list.begin(), m_target_list.end(),
|
|
[&exe_file_spec, exe_arch_ptr](const TargetSP &item) {
|
|
Module *exe_module = item->GetExecutableModulePointer();
|
|
if (!exe_module ||
|
|
!FileSpec::Match(exe_file_spec, exe_module->GetFileSpec()))
|
|
return false;
|
|
|
|
return !exe_arch_ptr ||
|
|
exe_arch_ptr->IsCompatibleMatch(exe_module->GetArchitecture());
|
|
});
|
|
|
|
if (it != m_target_list.end())
|
|
return *it;
|
|
|
|
return TargetSP();
|
|
}
|
|
|
|
TargetSP TargetList::FindTargetWithProcessID(lldb::pid_t pid) const {
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
auto it = std::find_if(m_target_list.begin(), m_target_list.end(),
|
|
[pid](const TargetSP &item) {
|
|
auto *process_ptr = item->GetProcessSP().get();
|
|
return process_ptr && (process_ptr->GetID() == pid);
|
|
});
|
|
|
|
if (it != m_target_list.end())
|
|
return *it;
|
|
|
|
return TargetSP();
|
|
}
|
|
|
|
TargetSP TargetList::FindTargetWithProcess(Process *process) const {
|
|
TargetSP target_sp;
|
|
if (!process)
|
|
return target_sp;
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
auto it = std::find_if(m_target_list.begin(), m_target_list.end(),
|
|
[process](const TargetSP &item) {
|
|
return item->GetProcessSP().get() == process;
|
|
});
|
|
|
|
if (it != m_target_list.end())
|
|
target_sp = *it;
|
|
|
|
return target_sp;
|
|
}
|
|
|
|
TargetSP TargetList::GetTargetSP(Target *target) const {
|
|
TargetSP target_sp;
|
|
if (!target)
|
|
return target_sp;
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
auto it = std::find_if(m_target_list.begin(), m_target_list.end(),
|
|
[target](const TargetSP &item) { return item.get() == target; });
|
|
if (it != m_target_list.end())
|
|
target_sp = *it;
|
|
|
|
return target_sp;
|
|
}
|
|
|
|
uint32_t TargetList::SendAsyncInterrupt(lldb::pid_t pid) {
|
|
uint32_t num_async_interrupts_sent = 0;
|
|
|
|
if (pid != LLDB_INVALID_PROCESS_ID) {
|
|
TargetSP target_sp(FindTargetWithProcessID(pid));
|
|
if (target_sp) {
|
|
Process *process = target_sp->GetProcessSP().get();
|
|
if (process) {
|
|
process->SendAsyncInterrupt();
|
|
++num_async_interrupts_sent;
|
|
}
|
|
}
|
|
} else {
|
|
// We don't have a valid pid to broadcast to, so broadcast to the target
|
|
// list's async broadcaster...
|
|
BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr);
|
|
}
|
|
|
|
return num_async_interrupts_sent;
|
|
}
|
|
|
|
uint32_t TargetList::SignalIfRunning(lldb::pid_t pid, int signo) {
|
|
uint32_t num_signals_sent = 0;
|
|
Process *process = nullptr;
|
|
if (pid == LLDB_INVALID_PROCESS_ID) {
|
|
// Signal all processes with signal
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
for (const auto &target_sp : m_target_list) {
|
|
process = target_sp->GetProcessSP().get();
|
|
if (process && process->IsAlive()) {
|
|
++num_signals_sent;
|
|
process->Signal(signo);
|
|
}
|
|
}
|
|
} else {
|
|
// Signal a specific process with signal
|
|
TargetSP target_sp(FindTargetWithProcessID(pid));
|
|
if (target_sp) {
|
|
process = target_sp->GetProcessSP().get();
|
|
if (process && process->IsAlive()) {
|
|
++num_signals_sent;
|
|
process->Signal(signo);
|
|
}
|
|
}
|
|
}
|
|
return num_signals_sent;
|
|
}
|
|
|
|
int TargetList::GetNumTargets() const {
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
return m_target_list.size();
|
|
}
|
|
|
|
lldb::TargetSP TargetList::GetTargetAtIndex(uint32_t idx) const {
|
|
TargetSP target_sp;
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
if (idx < m_target_list.size())
|
|
target_sp = m_target_list[idx];
|
|
return target_sp;
|
|
}
|
|
|
|
uint32_t TargetList::GetIndexOfTarget(lldb::TargetSP target_sp) const {
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
auto it = std::find(m_target_list.begin(), m_target_list.end(), target_sp);
|
|
if (it != m_target_list.end())
|
|
return std::distance(m_target_list.begin(), it);
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
void TargetList::AddTargetInternal(TargetSP target_sp, bool do_select) {
|
|
lldbassert(std::find(m_target_list.begin(), m_target_list.end(), target_sp) ==
|
|
m_target_list.end() &&
|
|
"target already exists it the list");
|
|
m_target_list.push_back(std::move(target_sp));
|
|
if (do_select)
|
|
SetSelectedTargetInternal(m_target_list.size() - 1);
|
|
}
|
|
|
|
void TargetList::SetSelectedTargetInternal(uint32_t index) {
|
|
lldbassert(!m_target_list.empty());
|
|
m_selected_target_idx = index < m_target_list.size() ? index : 0;
|
|
}
|
|
|
|
void TargetList::SetSelectedTarget(uint32_t index) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
SetSelectedTargetInternal(index);
|
|
}
|
|
|
|
void TargetList::SetSelectedTarget(const TargetSP &target_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
auto it = std::find(m_target_list.begin(), m_target_list.end(), target_sp);
|
|
SetSelectedTargetInternal(std::distance(m_target_list.begin(), it));
|
|
}
|
|
|
|
lldb::TargetSP TargetList::GetSelectedTarget() {
|
|
std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
|
|
if (m_selected_target_idx >= m_target_list.size())
|
|
m_selected_target_idx = 0;
|
|
return GetTargetAtIndex(m_selected_target_idx);
|
|
}
|