80b2e3cc53
The PluginManager contains a lot of duplicate code. I already removed a bunch of it by introducing the templated PluginInstance class, and this is the next step. The PluginInstances class combines the mutex and the vector and implements the common operations. To accommodate plugin instances with additional members it is possible to access the underlying vector and mutex. The methods to query these fields make use of that. Differential revision: https://reviews.llvm.org/D74816
1514 lines
54 KiB
C++
1514 lines
54 KiB
C++
//===-- PluginManager.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/Core/PluginManager.h"
|
|
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Host/FileSystem.h"
|
|
#include "lldb/Host/HostInfo.h"
|
|
#include "lldb/Interpreter/OptionValueProperties.h"
|
|
#include "lldb/Utility/ConstString.h"
|
|
#include "lldb/Utility/FileSpec.h"
|
|
#include "lldb/Utility/Status.h"
|
|
#include "lldb/Utility/StringList.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Support/DynamicLibrary.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <assert.h>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
#if defined(_WIN32)
|
|
#include "lldb/Host/windows/PosixApi.h"
|
|
#endif
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
typedef bool (*PluginInitCallback)();
|
|
typedef void (*PluginTermCallback)();
|
|
|
|
struct PluginInfo {
|
|
PluginInfo() : plugin_init_callback(nullptr), plugin_term_callback(nullptr) {}
|
|
|
|
llvm::sys::DynamicLibrary library;
|
|
PluginInitCallback plugin_init_callback;
|
|
PluginTermCallback plugin_term_callback;
|
|
};
|
|
|
|
typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;
|
|
|
|
static std::recursive_mutex &GetPluginMapMutex() {
|
|
static std::recursive_mutex g_plugin_map_mutex;
|
|
return g_plugin_map_mutex;
|
|
}
|
|
|
|
static PluginTerminateMap &GetPluginMap() {
|
|
static PluginTerminateMap g_plugin_map;
|
|
return g_plugin_map;
|
|
}
|
|
|
|
static bool PluginIsLoaded(const FileSpec &plugin_file_spec) {
|
|
std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
|
|
PluginTerminateMap &plugin_map = GetPluginMap();
|
|
return plugin_map.find(plugin_file_spec) != plugin_map.end();
|
|
}
|
|
|
|
static void SetPluginInfo(const FileSpec &plugin_file_spec,
|
|
const PluginInfo &plugin_info) {
|
|
std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
|
|
PluginTerminateMap &plugin_map = GetPluginMap();
|
|
assert(plugin_map.find(plugin_file_spec) == plugin_map.end());
|
|
plugin_map[plugin_file_spec] = plugin_info;
|
|
}
|
|
|
|
template <typename FPtrTy> static FPtrTy CastToFPtr(void *VPtr) {
|
|
return reinterpret_cast<FPtrTy>(VPtr);
|
|
}
|
|
|
|
static FileSystem::EnumerateDirectoryResult
|
|
LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
|
|
llvm::StringRef path) {
|
|
Status error;
|
|
|
|
namespace fs = llvm::sys::fs;
|
|
// If we have a regular file, a symbolic link or unknown file type, try and
|
|
// process the file. We must handle unknown as sometimes the directory
|
|
// enumeration might be enumerating a file system that doesn't have correct
|
|
// file type information.
|
|
if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
|
|
ft == fs::file_type::type_unknown) {
|
|
FileSpec plugin_file_spec(path);
|
|
FileSystem::Instance().Resolve(plugin_file_spec);
|
|
|
|
if (PluginIsLoaded(plugin_file_spec))
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
else {
|
|
PluginInfo plugin_info;
|
|
|
|
std::string pluginLoadError;
|
|
plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(
|
|
plugin_file_spec.GetPath().c_str(), &pluginLoadError);
|
|
if (plugin_info.library.isValid()) {
|
|
bool success = false;
|
|
plugin_info.plugin_init_callback = CastToFPtr<PluginInitCallback>(
|
|
plugin_info.library.getAddressOfSymbol("LLDBPluginInitialize"));
|
|
if (plugin_info.plugin_init_callback) {
|
|
// Call the plug-in "bool LLDBPluginInitialize(void)" function
|
|
success = plugin_info.plugin_init_callback();
|
|
}
|
|
|
|
if (success) {
|
|
// It is ok for the "LLDBPluginTerminate" symbol to be nullptr
|
|
plugin_info.plugin_term_callback = CastToFPtr<PluginTermCallback>(
|
|
plugin_info.library.getAddressOfSymbol("LLDBPluginTerminate"));
|
|
} else {
|
|
// The initialize function returned FALSE which means the plug-in
|
|
// might not be compatible, or might be too new or too old, or might
|
|
// not want to run on this machine. Set it to a default-constructed
|
|
// instance to invalidate it.
|
|
plugin_info = PluginInfo();
|
|
}
|
|
|
|
// Regardless of success or failure, cache the plug-in load in our
|
|
// plug-in info so we don't try to load it again and again.
|
|
SetPluginInfo(plugin_file_spec, plugin_info);
|
|
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ft == fs::file_type::directory_file ||
|
|
ft == fs::file_type::symlink_file || ft == fs::file_type::type_unknown) {
|
|
// Try and recurse into anything that a directory or symbolic link. We must
|
|
// also do this for unknown as sometimes the directory enumeration might be
|
|
// enumerating a file system that doesn't have correct file type
|
|
// information.
|
|
return FileSystem::eEnumerateDirectoryResultEnter;
|
|
}
|
|
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
}
|
|
|
|
void PluginManager::Initialize() {
|
|
const bool find_directories = true;
|
|
const bool find_files = true;
|
|
const bool find_other = true;
|
|
char dir_path[PATH_MAX];
|
|
if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
|
|
if (FileSystem::Instance().Exists(dir_spec) &&
|
|
dir_spec.GetPath(dir_path, sizeof(dir_path))) {
|
|
FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
|
|
find_files, find_other,
|
|
LoadPluginCallback, nullptr);
|
|
}
|
|
}
|
|
|
|
if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
|
|
if (FileSystem::Instance().Exists(dir_spec) &&
|
|
dir_spec.GetPath(dir_path, sizeof(dir_path))) {
|
|
FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
|
|
find_files, find_other,
|
|
LoadPluginCallback, nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
void PluginManager::Terminate() {
|
|
std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
|
|
PluginTerminateMap &plugin_map = GetPluginMap();
|
|
|
|
PluginTerminateMap::const_iterator pos, end = plugin_map.end();
|
|
for (pos = plugin_map.begin(); pos != end; ++pos) {
|
|
// Call the plug-in "void LLDBPluginTerminate (void)" function if there is
|
|
// one (if the symbol was not nullptr).
|
|
if (pos->second.library.isValid()) {
|
|
if (pos->second.plugin_term_callback)
|
|
pos->second.plugin_term_callback();
|
|
}
|
|
}
|
|
plugin_map.clear();
|
|
}
|
|
|
|
template <typename Callback> struct PluginInstance {
|
|
typedef Callback CallbackType;
|
|
|
|
PluginInstance() = default;
|
|
PluginInstance(ConstString name, std::string description,
|
|
Callback create_callback = nullptr,
|
|
DebuggerInitializeCallback debugger_init_callback = nullptr)
|
|
: name(name), description(std::move(description)),
|
|
create_callback(create_callback),
|
|
debugger_init_callback(debugger_init_callback) {}
|
|
|
|
ConstString name;
|
|
std::string description;
|
|
Callback create_callback;
|
|
DebuggerInitializeCallback debugger_init_callback;
|
|
};
|
|
|
|
template <typename Instance> class PluginInstances {
|
|
public:
|
|
template <typename... Args>
|
|
bool RegisterPlugin(ConstString name, const char *description,
|
|
typename Instance::CallbackType callback,
|
|
Args &&... args) {
|
|
if (!callback)
|
|
return false;
|
|
|
|
assert((bool)name);
|
|
Instance instance =
|
|
Instance(name, description, callback, std::forward<Args>(args)...);
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
m_instances.push_back(instance);
|
|
return false;
|
|
}
|
|
|
|
bool UnregisterPlugin(typename Instance::CallbackType callback) {
|
|
if (!callback)
|
|
return false;
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
auto pos = m_instances.begin();
|
|
auto end = m_instances.end();
|
|
for (; pos != end; ++pos) {
|
|
if (pos->create_callback == callback) {
|
|
m_instances.erase(pos);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
typename Instance::CallbackType GetCallbackAtIndex(uint32_t idx) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (Instance *instance = GetInstanceAtIndex(idx))
|
|
return instance->create_callback;
|
|
return nullptr;
|
|
}
|
|
|
|
const char *GetDescriptionAtIndex(uint32_t idx) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (Instance *instance = GetInstanceAtIndex(idx))
|
|
return instance->description.c_str();
|
|
return nullptr;
|
|
}
|
|
|
|
const char *GetNameAtIndex(uint32_t idx) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (Instance *instance = GetInstanceAtIndex(idx))
|
|
return instance->name.GetCString();
|
|
return nullptr;
|
|
}
|
|
|
|
typename Instance::CallbackType GetCallbackForName(ConstString name) {
|
|
if (!name)
|
|
return nullptr;
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
for (auto &instance : m_instances) {
|
|
if (name == instance.name)
|
|
return instance.create_callback;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void PerformDebuggerCallback(Debugger &debugger) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
for (auto &instance : m_instances) {
|
|
if (instance.debugger_init_callback)
|
|
instance.debugger_init_callback(debugger);
|
|
}
|
|
}
|
|
|
|
std::recursive_mutex &GetMutex() { return m_mutex; }
|
|
const std::vector<Instance> &GetInstances() const { return m_instances; }
|
|
std::vector<Instance> &GetInstances() { return m_instances; }
|
|
|
|
private:
|
|
Instance *GetInstanceAtIndex(uint32_t idx) {
|
|
// Caller locks.
|
|
if (idx < m_instances.size())
|
|
return &m_instances[idx];
|
|
return nullptr;
|
|
}
|
|
std::recursive_mutex m_mutex;
|
|
std::vector<Instance> m_instances;
|
|
};
|
|
|
|
#pragma mark ABI
|
|
|
|
typedef PluginInstance<ABICreateInstance> ABIInstance;
|
|
typedef PluginInstances<ABIInstance> ABIInstances;
|
|
|
|
static ABIInstances &GetABIInstances() {
|
|
static ABIInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(ConstString name, const char *description,
|
|
ABICreateInstance create_callback) {
|
|
return GetABIInstances().RegisterPlugin(name, description, create_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(ABICreateInstance create_callback) {
|
|
return GetABIInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
ABICreateInstance PluginManager::GetABICreateCallbackAtIndex(uint32_t idx) {
|
|
return GetABIInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
#pragma mark Architecture
|
|
|
|
typedef PluginInstance<ArchitectureCreateInstance> ArchitectureInstance;
|
|
typedef std::vector<ArchitectureInstance> ArchitectureInstances;
|
|
|
|
static std::mutex &GetArchitectureMutex() {
|
|
static std::mutex g_architecture_mutex;
|
|
return g_architecture_mutex;
|
|
}
|
|
|
|
static ArchitectureInstances &GetArchitectureInstances() {
|
|
static ArchitectureInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
void PluginManager::RegisterPlugin(ConstString name,
|
|
llvm::StringRef description,
|
|
ArchitectureCreateInstance create_callback) {
|
|
std::lock_guard<std::mutex> guard(GetArchitectureMutex());
|
|
GetArchitectureInstances().push_back(
|
|
{name, std::string(description), create_callback});
|
|
}
|
|
|
|
void PluginManager::UnregisterPlugin(
|
|
ArchitectureCreateInstance create_callback) {
|
|
std::lock_guard<std::mutex> guard(GetArchitectureMutex());
|
|
auto &instances = GetArchitectureInstances();
|
|
|
|
for (auto pos = instances.begin(), end = instances.end(); pos != end; ++pos) {
|
|
if (pos->create_callback == create_callback) {
|
|
instances.erase(pos);
|
|
return;
|
|
}
|
|
}
|
|
llvm_unreachable("Plugin not found");
|
|
}
|
|
|
|
std::unique_ptr<Architecture>
|
|
PluginManager::CreateArchitectureInstance(const ArchSpec &arch) {
|
|
std::lock_guard<std::mutex> guard(GetArchitectureMutex());
|
|
for (const auto &instances : GetArchitectureInstances()) {
|
|
if (auto plugin_up = instances.create_callback(arch))
|
|
return plugin_up;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
#pragma mark Disassembler
|
|
|
|
typedef PluginInstance<DisassemblerCreateInstance> DisassemblerInstance;
|
|
typedef PluginInstances<DisassemblerInstance> DisassemblerInstances;
|
|
|
|
static DisassemblerInstances &GetDisassemblerInstances() {
|
|
static DisassemblerInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(ConstString name, const char *description,
|
|
DisassemblerCreateInstance create_callback) {
|
|
return GetDisassemblerInstances().RegisterPlugin(name, description,
|
|
create_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
DisassemblerCreateInstance create_callback) {
|
|
return GetDisassemblerInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
DisassemblerCreateInstance
|
|
PluginManager::GetDisassemblerCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetDisassemblerInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
DisassemblerCreateInstance
|
|
PluginManager::GetDisassemblerCreateCallbackForPluginName(ConstString name) {
|
|
return GetDisassemblerInstances().GetCallbackForName(name);
|
|
}
|
|
|
|
#pragma mark DynamicLoader
|
|
|
|
typedef PluginInstance<DynamicLoaderCreateInstance> DynamicLoaderInstance;
|
|
typedef PluginInstances<DynamicLoaderInstance> DynamicLoaderInstances;
|
|
|
|
static DynamicLoaderInstances &GetDynamicLoaderInstances() {
|
|
static DynamicLoaderInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
DynamicLoaderCreateInstance create_callback,
|
|
DebuggerInitializeCallback debugger_init_callback) {
|
|
return GetDynamicLoaderInstances().RegisterPlugin(
|
|
name, description, create_callback, debugger_init_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
DynamicLoaderCreateInstance create_callback) {
|
|
return GetDynamicLoaderInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
DynamicLoaderCreateInstance
|
|
PluginManager::GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetDynamicLoaderInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
DynamicLoaderCreateInstance
|
|
PluginManager::GetDynamicLoaderCreateCallbackForPluginName(ConstString name) {
|
|
return GetDynamicLoaderInstances().GetCallbackForName(name);
|
|
}
|
|
|
|
#pragma mark JITLoader
|
|
|
|
typedef PluginInstance<JITLoaderCreateInstance> JITLoaderInstance;
|
|
typedef PluginInstances<JITLoaderInstance> JITLoaderInstances;
|
|
|
|
static JITLoaderInstances &GetJITLoaderInstances() {
|
|
static JITLoaderInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
JITLoaderCreateInstance create_callback,
|
|
DebuggerInitializeCallback debugger_init_callback) {
|
|
return GetJITLoaderInstances().RegisterPlugin(
|
|
name, description, create_callback, debugger_init_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(JITLoaderCreateInstance create_callback) {
|
|
return GetJITLoaderInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
JITLoaderCreateInstance
|
|
PluginManager::GetJITLoaderCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetJITLoaderInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
#pragma mark EmulateInstruction
|
|
|
|
typedef PluginInstance<EmulateInstructionCreateInstance>
|
|
EmulateInstructionInstance;
|
|
typedef PluginInstances<EmulateInstructionInstance> EmulateInstructionInstances;
|
|
|
|
static EmulateInstructionInstances &GetEmulateInstructionInstances() {
|
|
static EmulateInstructionInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
EmulateInstructionCreateInstance create_callback) {
|
|
return GetEmulateInstructionInstances().RegisterPlugin(name, description,
|
|
create_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
EmulateInstructionCreateInstance create_callback) {
|
|
return GetEmulateInstructionInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
EmulateInstructionCreateInstance
|
|
PluginManager::GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetEmulateInstructionInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
EmulateInstructionCreateInstance
|
|
PluginManager::GetEmulateInstructionCreateCallbackForPluginName(
|
|
ConstString name) {
|
|
return GetEmulateInstructionInstances().GetCallbackForName(name);
|
|
}
|
|
|
|
#pragma mark OperatingSystem
|
|
|
|
typedef PluginInstance<OperatingSystemCreateInstance> OperatingSystemInstance;
|
|
typedef PluginInstances<OperatingSystemInstance> OperatingSystemInstances;
|
|
|
|
static OperatingSystemInstances &GetOperatingSystemInstances() {
|
|
static OperatingSystemInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
OperatingSystemCreateInstance create_callback,
|
|
DebuggerInitializeCallback debugger_init_callback) {
|
|
return GetOperatingSystemInstances().RegisterPlugin(
|
|
name, description, create_callback, debugger_init_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
OperatingSystemCreateInstance create_callback) {
|
|
return GetOperatingSystemInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
OperatingSystemCreateInstance
|
|
PluginManager::GetOperatingSystemCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetOperatingSystemInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
OperatingSystemCreateInstance
|
|
PluginManager::GetOperatingSystemCreateCallbackForPluginName(ConstString name) {
|
|
return GetOperatingSystemInstances().GetCallbackForName(name);
|
|
}
|
|
|
|
#pragma mark Language
|
|
|
|
typedef PluginInstance<LanguageCreateInstance> LanguageInstance;
|
|
typedef PluginInstances<LanguageInstance> LanguageInstances;
|
|
|
|
static LanguageInstances &GetLanguageInstances() {
|
|
static LanguageInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(ConstString name, const char *description,
|
|
LanguageCreateInstance create_callback) {
|
|
return GetLanguageInstances().RegisterPlugin(name, description,
|
|
create_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(LanguageCreateInstance create_callback) {
|
|
return GetLanguageInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
LanguageCreateInstance
|
|
PluginManager::GetLanguageCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetLanguageInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
#pragma mark LanguageRuntime
|
|
|
|
struct LanguageRuntimeInstance
|
|
: public PluginInstance<LanguageRuntimeCreateInstance> {
|
|
LanguageRuntimeInstance(
|
|
ConstString name, std::string description, CallbackType create_callback,
|
|
DebuggerInitializeCallback debugger_init_callback,
|
|
LanguageRuntimeGetCommandObject command_callback,
|
|
LanguageRuntimeGetExceptionPrecondition precondition_callback)
|
|
: PluginInstance<LanguageRuntimeCreateInstance>(
|
|
name, std::move(description), create_callback,
|
|
debugger_init_callback),
|
|
command_callback(command_callback),
|
|
precondition_callback(precondition_callback) {}
|
|
|
|
LanguageRuntimeGetCommandObject command_callback;
|
|
LanguageRuntimeGetExceptionPrecondition precondition_callback;
|
|
};
|
|
|
|
typedef PluginInstances<LanguageRuntimeInstance> LanguageRuntimeInstances;
|
|
|
|
static LanguageRuntimeInstances &GetLanguageRuntimeInstances() {
|
|
static LanguageRuntimeInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
LanguageRuntimeCreateInstance create_callback,
|
|
LanguageRuntimeGetCommandObject command_callback,
|
|
LanguageRuntimeGetExceptionPrecondition precondition_callback) {
|
|
return GetLanguageRuntimeInstances().RegisterPlugin(
|
|
name, description, create_callback, nullptr, command_callback,
|
|
precondition_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
LanguageRuntimeCreateInstance create_callback) {
|
|
return GetLanguageRuntimeInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
LanguageRuntimeCreateInstance
|
|
PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetLanguageRuntimeInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
LanguageRuntimeGetCommandObject
|
|
PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetLanguageRuntimeInstances().GetMutex());
|
|
const auto &instances = GetLanguageRuntimeInstances().GetInstances();
|
|
if (idx < instances.size())
|
|
return instances[idx].command_callback;
|
|
return nullptr;
|
|
}
|
|
|
|
LanguageRuntimeGetExceptionPrecondition
|
|
PluginManager::GetLanguageRuntimeGetExceptionPreconditionAtIndex(uint32_t idx) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetLanguageRuntimeInstances().GetMutex());
|
|
const auto &instances = GetLanguageRuntimeInstances().GetInstances();
|
|
if (idx < instances.size())
|
|
return instances[idx].precondition_callback;
|
|
return nullptr;
|
|
}
|
|
|
|
#pragma mark SystemRuntime
|
|
|
|
typedef PluginInstance<SystemRuntimeCreateInstance> SystemRuntimeInstance;
|
|
typedef PluginInstances<SystemRuntimeInstance> SystemRuntimeInstances;
|
|
|
|
static SystemRuntimeInstances &GetSystemRuntimeInstances() {
|
|
static SystemRuntimeInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
SystemRuntimeCreateInstance create_callback) {
|
|
return GetSystemRuntimeInstances().RegisterPlugin(name, description,
|
|
create_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
SystemRuntimeCreateInstance create_callback) {
|
|
return GetSystemRuntimeInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
SystemRuntimeCreateInstance
|
|
PluginManager::GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetSystemRuntimeInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
#pragma mark ObjectFile
|
|
|
|
struct ObjectFileInstance : public PluginInstance<ObjectFileCreateInstance> {
|
|
ObjectFileInstance(
|
|
ConstString name, std::string description, CallbackType create_callback,
|
|
ObjectFileCreateMemoryInstance create_memory_callback,
|
|
ObjectFileGetModuleSpecifications get_module_specifications,
|
|
ObjectFileSaveCore save_core)
|
|
: PluginInstance<ObjectFileCreateInstance>(name, std::move(description),
|
|
create_callback),
|
|
create_memory_callback(create_memory_callback),
|
|
get_module_specifications(get_module_specifications),
|
|
save_core(save_core) {}
|
|
|
|
ObjectFileCreateMemoryInstance create_memory_callback;
|
|
ObjectFileGetModuleSpecifications get_module_specifications;
|
|
ObjectFileSaveCore save_core;
|
|
};
|
|
typedef PluginInstances<ObjectFileInstance> ObjectFileInstances;
|
|
|
|
static ObjectFileInstances &GetObjectFileInstances() {
|
|
static ObjectFileInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
ObjectFileCreateInstance create_callback,
|
|
ObjectFileCreateMemoryInstance create_memory_callback,
|
|
ObjectFileGetModuleSpecifications get_module_specifications,
|
|
ObjectFileSaveCore save_core) {
|
|
return GetObjectFileInstances().RegisterPlugin(
|
|
name, description, create_callback, create_memory_callback,
|
|
get_module_specifications, save_core);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(ObjectFileCreateInstance create_callback) {
|
|
return GetObjectFileInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
ObjectFileCreateInstance
|
|
PluginManager::GetObjectFileCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetObjectFileInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
ObjectFileCreateMemoryInstance
|
|
PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetObjectFileInstances().GetMutex());
|
|
const auto &instances = GetObjectFileInstances().GetInstances();
|
|
if (idx < instances.size())
|
|
return instances[idx].create_memory_callback;
|
|
return nullptr;
|
|
}
|
|
|
|
ObjectFileGetModuleSpecifications
|
|
PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(
|
|
uint32_t idx) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetObjectFileInstances().GetMutex());
|
|
const auto &instances = GetObjectFileInstances().GetInstances();
|
|
if (idx < instances.size())
|
|
return instances[idx].get_module_specifications;
|
|
return nullptr;
|
|
}
|
|
|
|
ObjectFileCreateMemoryInstance
|
|
PluginManager::GetObjectFileCreateMemoryCallbackForPluginName(
|
|
ConstString name) {
|
|
if (!name)
|
|
return nullptr;
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetObjectFileInstances().GetMutex());
|
|
const auto &instances = GetObjectFileInstances().GetInstances();
|
|
for (auto &instance : instances) {
|
|
if (instance.name == name)
|
|
return instance.create_memory_callback;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
Status PluginManager::SaveCore(const lldb::ProcessSP &process_sp,
|
|
const FileSpec &outfile) {
|
|
Status error;
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetObjectFileInstances().GetMutex());
|
|
auto &instances = GetObjectFileInstances().GetInstances();
|
|
for (auto &instance : instances) {
|
|
if (instance.save_core && instance.save_core(process_sp, outfile, error))
|
|
return error;
|
|
}
|
|
error.SetErrorString(
|
|
"no ObjectFile plugins were able to save a core for this process");
|
|
return error;
|
|
}
|
|
|
|
#pragma mark ObjectContainer
|
|
|
|
struct ObjectContainerInstance
|
|
: public PluginInstance<ObjectContainerCreateInstance> {
|
|
ObjectContainerInstance(
|
|
ConstString name, std::string description, CallbackType create_callback,
|
|
ObjectFileGetModuleSpecifications get_module_specifications)
|
|
: PluginInstance<ObjectContainerCreateInstance>(
|
|
name, std::move(description), create_callback),
|
|
get_module_specifications(get_module_specifications) {}
|
|
|
|
ObjectFileGetModuleSpecifications get_module_specifications;
|
|
};
|
|
typedef PluginInstances<ObjectContainerInstance> ObjectContainerInstances;
|
|
|
|
static ObjectContainerInstances &GetObjectContainerInstances() {
|
|
static ObjectContainerInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
ObjectContainerCreateInstance create_callback,
|
|
ObjectFileGetModuleSpecifications get_module_specifications) {
|
|
return GetObjectContainerInstances().RegisterPlugin(
|
|
name, description, create_callback, get_module_specifications);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
ObjectContainerCreateInstance create_callback) {
|
|
return GetObjectContainerInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
ObjectContainerCreateInstance
|
|
PluginManager::GetObjectContainerCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetObjectContainerInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
ObjectFileGetModuleSpecifications
|
|
PluginManager::GetObjectContainerGetModuleSpecificationsCallbackAtIndex(
|
|
uint32_t idx) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetObjectContainerInstances().GetMutex());
|
|
const auto &instances = GetObjectContainerInstances().GetInstances();
|
|
if (idx < instances.size())
|
|
return instances[idx].get_module_specifications;
|
|
return nullptr;
|
|
}
|
|
|
|
#pragma mark Platform
|
|
|
|
typedef PluginInstance<PlatformCreateInstance> PlatformInstance;
|
|
typedef PluginInstances<PlatformInstance> PlatformInstances;
|
|
|
|
static PlatformInstances &GetPlatformInstances() {
|
|
static PlatformInstances g_platform_instances;
|
|
return g_platform_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
PlatformCreateInstance create_callback,
|
|
DebuggerInitializeCallback debugger_init_callback) {
|
|
return GetPlatformInstances().RegisterPlugin(
|
|
name, description, create_callback, debugger_init_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(PlatformCreateInstance create_callback) {
|
|
return GetPlatformInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
const char *PluginManager::GetPlatformPluginNameAtIndex(uint32_t idx) {
|
|
return GetPlatformInstances().GetNameAtIndex(idx);
|
|
}
|
|
|
|
const char *PluginManager::GetPlatformPluginDescriptionAtIndex(uint32_t idx) {
|
|
return GetPlatformInstances().GetDescriptionAtIndex(idx);
|
|
}
|
|
|
|
PlatformCreateInstance
|
|
PluginManager::GetPlatformCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetPlatformInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
PlatformCreateInstance
|
|
PluginManager::GetPlatformCreateCallbackForPluginName(ConstString name) {
|
|
return GetPlatformInstances().GetCallbackForName(name);
|
|
}
|
|
|
|
void PluginManager::AutoCompletePlatformName(llvm::StringRef name,
|
|
CompletionRequest &request) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetPlatformInstances().GetMutex());
|
|
for (const auto &instance : GetPlatformInstances().GetInstances()) {
|
|
if (instance.name.GetStringRef().startswith(name))
|
|
request.AddCompletion(instance.name.GetCString());
|
|
}
|
|
}
|
|
|
|
#pragma mark Process
|
|
|
|
typedef PluginInstance<ProcessCreateInstance> ProcessInstance;
|
|
typedef PluginInstances<ProcessInstance> ProcessInstances;
|
|
|
|
static ProcessInstances &GetProcessInstances() {
|
|
static ProcessInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
ProcessCreateInstance create_callback,
|
|
DebuggerInitializeCallback debugger_init_callback) {
|
|
return GetProcessInstances().RegisterPlugin(
|
|
name, description, create_callback, debugger_init_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(ProcessCreateInstance create_callback) {
|
|
return GetProcessInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
const char *PluginManager::GetProcessPluginNameAtIndex(uint32_t idx) {
|
|
return GetProcessInstances().GetNameAtIndex(idx);
|
|
}
|
|
|
|
const char *PluginManager::GetProcessPluginDescriptionAtIndex(uint32_t idx) {
|
|
return GetProcessInstances().GetDescriptionAtIndex(idx);
|
|
}
|
|
|
|
ProcessCreateInstance
|
|
PluginManager::GetProcessCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetProcessInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
ProcessCreateInstance
|
|
PluginManager::GetProcessCreateCallbackForPluginName(ConstString name) {
|
|
return GetProcessInstances().GetCallbackForName(name);
|
|
}
|
|
|
|
#pragma mark ScriptInterpreter
|
|
|
|
struct ScriptInterpreterInstance
|
|
: public PluginInstance<ScriptInterpreterCreateInstance> {
|
|
ScriptInterpreterInstance(ConstString name, std::string description,
|
|
CallbackType create_callback,
|
|
lldb::ScriptLanguage language)
|
|
: PluginInstance<ScriptInterpreterCreateInstance>(
|
|
name, std::move(description), create_callback),
|
|
language(language) {}
|
|
|
|
lldb::ScriptLanguage language = lldb::eScriptLanguageNone;
|
|
};
|
|
|
|
typedef PluginInstances<ScriptInterpreterInstance> ScriptInterpreterInstances;
|
|
|
|
static ScriptInterpreterInstances &GetScriptInterpreterInstances() {
|
|
static ScriptInterpreterInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
lldb::ScriptLanguage script_language,
|
|
ScriptInterpreterCreateInstance create_callback) {
|
|
return GetScriptInterpreterInstances().RegisterPlugin(
|
|
name, description, create_callback, script_language);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
ScriptInterpreterCreateInstance create_callback) {
|
|
return GetScriptInterpreterInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
ScriptInterpreterCreateInstance
|
|
PluginManager::GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetScriptInterpreterInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
lldb::ScriptInterpreterSP
|
|
PluginManager::GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang,
|
|
Debugger &debugger) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetScriptInterpreterInstances().GetMutex());
|
|
const auto &instances = GetScriptInterpreterInstances().GetInstances();
|
|
ScriptInterpreterCreateInstance none_instance = nullptr;
|
|
for (const auto &instance : instances) {
|
|
if (instance.language == lldb::eScriptLanguageNone)
|
|
none_instance = instance.create_callback;
|
|
|
|
if (script_lang == instance.language)
|
|
return instance.create_callback(debugger);
|
|
}
|
|
|
|
// If we didn't find one, return the ScriptInterpreter for the null language.
|
|
assert(none_instance != nullptr);
|
|
return none_instance(debugger);
|
|
}
|
|
|
|
#pragma mark StructuredDataPlugin
|
|
|
|
struct StructuredDataPluginInstance
|
|
: public PluginInstance<StructuredDataPluginCreateInstance> {
|
|
StructuredDataPluginInstance(
|
|
ConstString name, std::string description, CallbackType create_callback,
|
|
DebuggerInitializeCallback debugger_init_callback,
|
|
StructuredDataFilterLaunchInfo filter_callback)
|
|
: PluginInstance<StructuredDataPluginCreateInstance>(
|
|
name, std::move(description), create_callback,
|
|
debugger_init_callback),
|
|
filter_callback(filter_callback) {}
|
|
|
|
StructuredDataFilterLaunchInfo filter_callback = nullptr;
|
|
};
|
|
|
|
typedef PluginInstances<StructuredDataPluginInstance>
|
|
StructuredDataPluginInstances;
|
|
|
|
static StructuredDataPluginInstances &GetStructuredDataPluginInstances() {
|
|
static StructuredDataPluginInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
StructuredDataPluginCreateInstance create_callback,
|
|
DebuggerInitializeCallback debugger_init_callback,
|
|
StructuredDataFilterLaunchInfo filter_callback) {
|
|
return GetStructuredDataPluginInstances().RegisterPlugin(
|
|
name, description, create_callback, debugger_init_callback,
|
|
filter_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
StructuredDataPluginCreateInstance create_callback) {
|
|
return GetStructuredDataPluginInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
StructuredDataPluginCreateInstance
|
|
PluginManager::GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetStructuredDataPluginInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
StructuredDataFilterLaunchInfo
|
|
PluginManager::GetStructuredDataFilterCallbackAtIndex(
|
|
uint32_t idx, bool &iteration_complete) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetStructuredDataPluginInstances().GetMutex());
|
|
const auto &instances = GetStructuredDataPluginInstances().GetInstances();
|
|
if (idx < instances.size()) {
|
|
iteration_complete = false;
|
|
return instances[idx].filter_callback;
|
|
} else {
|
|
iteration_complete = true;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
#pragma mark SymbolFile
|
|
|
|
typedef PluginInstance<SymbolFileCreateInstance> SymbolFileInstance;
|
|
typedef PluginInstances<SymbolFileInstance> SymbolFileInstances;
|
|
|
|
static SymbolFileInstances &GetSymbolFileInstances() {
|
|
static SymbolFileInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
SymbolFileCreateInstance create_callback,
|
|
DebuggerInitializeCallback debugger_init_callback) {
|
|
return GetSymbolFileInstances().RegisterPlugin(
|
|
name, description, create_callback, debugger_init_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(SymbolFileCreateInstance create_callback) {
|
|
return GetSymbolFileInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
SymbolFileCreateInstance
|
|
PluginManager::GetSymbolFileCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetSymbolFileInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
#pragma mark SymbolVendor
|
|
|
|
typedef PluginInstance<SymbolVendorCreateInstance> SymbolVendorInstance;
|
|
typedef PluginInstances<SymbolVendorInstance> SymbolVendorInstances;
|
|
|
|
static SymbolVendorInstances &GetSymbolVendorInstances() {
|
|
static SymbolVendorInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(ConstString name, const char *description,
|
|
SymbolVendorCreateInstance create_callback) {
|
|
return GetSymbolVendorInstances().RegisterPlugin(name, description,
|
|
create_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
SymbolVendorCreateInstance create_callback) {
|
|
return GetSymbolVendorInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
SymbolVendorCreateInstance
|
|
PluginManager::GetSymbolVendorCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetSymbolVendorInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
#pragma mark UnwindAssembly
|
|
|
|
typedef PluginInstance<UnwindAssemblyCreateInstance> UnwindAssemblyInstance;
|
|
typedef PluginInstances<UnwindAssemblyInstance> UnwindAssemblyInstances;
|
|
|
|
static UnwindAssemblyInstances &GetUnwindAssemblyInstances() {
|
|
static UnwindAssemblyInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
UnwindAssemblyCreateInstance create_callback) {
|
|
return GetUnwindAssemblyInstances().RegisterPlugin(name, description,
|
|
create_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
UnwindAssemblyCreateInstance create_callback) {
|
|
return GetUnwindAssemblyInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
UnwindAssemblyCreateInstance
|
|
PluginManager::GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetUnwindAssemblyInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
#pragma mark MemoryHistory
|
|
|
|
typedef PluginInstance<MemoryHistoryCreateInstance> MemoryHistoryInstance;
|
|
typedef PluginInstances<MemoryHistoryInstance> MemoryHistoryInstances;
|
|
|
|
static MemoryHistoryInstances &GetMemoryHistoryInstances() {
|
|
static MemoryHistoryInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
MemoryHistoryCreateInstance create_callback) {
|
|
return GetMemoryHistoryInstances().RegisterPlugin(name, description,
|
|
create_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
MemoryHistoryCreateInstance create_callback) {
|
|
return GetMemoryHistoryInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
MemoryHistoryCreateInstance
|
|
PluginManager::GetMemoryHistoryCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetMemoryHistoryInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
#pragma mark InstrumentationRuntime
|
|
|
|
struct InstrumentationRuntimeInstance
|
|
: public PluginInstance<InstrumentationRuntimeCreateInstance> {
|
|
InstrumentationRuntimeInstance(
|
|
ConstString name, std::string description, CallbackType create_callback,
|
|
InstrumentationRuntimeGetType get_type_callback)
|
|
: PluginInstance<InstrumentationRuntimeCreateInstance>(
|
|
name, std::move(description), create_callback),
|
|
get_type_callback(get_type_callback) {}
|
|
|
|
InstrumentationRuntimeGetType get_type_callback = nullptr;
|
|
};
|
|
|
|
typedef PluginInstances<InstrumentationRuntimeInstance>
|
|
InstrumentationRuntimeInstances;
|
|
|
|
static InstrumentationRuntimeInstances &GetInstrumentationRuntimeInstances() {
|
|
static InstrumentationRuntimeInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
InstrumentationRuntimeCreateInstance create_callback,
|
|
InstrumentationRuntimeGetType get_type_callback) {
|
|
return GetInstrumentationRuntimeInstances().RegisterPlugin(
|
|
name, description, create_callback, get_type_callback);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(
|
|
InstrumentationRuntimeCreateInstance create_callback) {
|
|
return GetInstrumentationRuntimeInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
InstrumentationRuntimeGetType
|
|
PluginManager::GetInstrumentationRuntimeGetTypeCallbackAtIndex(uint32_t idx) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetInstrumentationRuntimeInstances().GetMutex());
|
|
const auto &instances = GetInstrumentationRuntimeInstances().GetInstances();
|
|
if (idx < instances.size())
|
|
return instances[idx].get_type_callback;
|
|
return nullptr;
|
|
}
|
|
|
|
InstrumentationRuntimeCreateInstance
|
|
PluginManager::GetInstrumentationRuntimeCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetInstrumentationRuntimeInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
#pragma mark TypeSystem
|
|
|
|
struct TypeSystemInstance : public PluginInstance<TypeSystemCreateInstance> {
|
|
TypeSystemInstance(ConstString name, std::string description,
|
|
CallbackType create_callback,
|
|
LanguageSet supported_languages_for_types,
|
|
LanguageSet supported_languages_for_expressions)
|
|
: PluginInstance<TypeSystemCreateInstance>(name, std::move(description),
|
|
create_callback),
|
|
supported_languages_for_types(supported_languages_for_types),
|
|
supported_languages_for_expressions(
|
|
supported_languages_for_expressions) {}
|
|
|
|
LanguageSet supported_languages_for_types;
|
|
LanguageSet supported_languages_for_expressions;
|
|
};
|
|
|
|
typedef PluginInstances<TypeSystemInstance> TypeSystemInstances;
|
|
|
|
static TypeSystemInstances &GetTypeSystemInstances() {
|
|
static TypeSystemInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(
|
|
ConstString name, const char *description,
|
|
TypeSystemCreateInstance create_callback,
|
|
LanguageSet supported_languages_for_types,
|
|
LanguageSet supported_languages_for_expressions) {
|
|
return GetTypeSystemInstances().RegisterPlugin(
|
|
name, description, create_callback, supported_languages_for_types,
|
|
supported_languages_for_expressions);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(TypeSystemCreateInstance create_callback) {
|
|
return GetTypeSystemInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
TypeSystemCreateInstance
|
|
PluginManager::GetTypeSystemCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetTypeSystemInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
LanguageSet PluginManager::GetAllTypeSystemSupportedLanguagesForTypes() {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetTypeSystemInstances().GetMutex());
|
|
const auto &instances = GetTypeSystemInstances().GetInstances();
|
|
LanguageSet all;
|
|
for (unsigned i = 0; i < instances.size(); ++i)
|
|
all.bitvector |= instances[i].supported_languages_for_types.bitvector;
|
|
return all;
|
|
}
|
|
|
|
LanguageSet PluginManager::GetAllTypeSystemSupportedLanguagesForExpressions() {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
GetTypeSystemInstances().GetMutex());
|
|
const auto &instances = GetTypeSystemInstances().GetInstances();
|
|
LanguageSet all;
|
|
for (unsigned i = 0; i < instances.size(); ++i)
|
|
all.bitvector |= instances[i].supported_languages_for_expressions.bitvector;
|
|
return all;
|
|
}
|
|
|
|
#pragma mark REPL
|
|
|
|
struct REPLInstance : public PluginInstance<REPLCreateInstance> {
|
|
REPLInstance(ConstString name, std::string description,
|
|
CallbackType create_callback, LanguageSet supported_languages)
|
|
: PluginInstance<REPLCreateInstance>(name, std::move(description),
|
|
create_callback),
|
|
supported_languages(supported_languages) {}
|
|
|
|
LanguageSet supported_languages;
|
|
};
|
|
|
|
typedef PluginInstances<REPLInstance> REPLInstances;
|
|
|
|
static REPLInstances &GetREPLInstances() {
|
|
static REPLInstances g_instances;
|
|
return g_instances;
|
|
}
|
|
|
|
bool PluginManager::RegisterPlugin(ConstString name, const char *description,
|
|
REPLCreateInstance create_callback,
|
|
LanguageSet supported_languages) {
|
|
return GetREPLInstances().RegisterPlugin(name, description, create_callback,
|
|
supported_languages);
|
|
}
|
|
|
|
bool PluginManager::UnregisterPlugin(REPLCreateInstance create_callback) {
|
|
return GetREPLInstances().UnregisterPlugin(create_callback);
|
|
}
|
|
|
|
REPLCreateInstance PluginManager::GetREPLCreateCallbackAtIndex(uint32_t idx) {
|
|
return GetREPLInstances().GetCallbackAtIndex(idx);
|
|
}
|
|
|
|
LanguageSet PluginManager::GetREPLAllTypeSystemSupportedLanguages() {
|
|
std::lock_guard<std::recursive_mutex> guard(GetREPLInstances().GetMutex());
|
|
const auto &instances = GetREPLInstances().GetInstances();
|
|
LanguageSet all;
|
|
for (unsigned i = 0; i < instances.size(); ++i)
|
|
all.bitvector |= instances[i].supported_languages.bitvector;
|
|
return all;
|
|
}
|
|
|
|
#pragma mark PluginManager
|
|
|
|
void PluginManager::DebuggerInitialize(Debugger &debugger) {
|
|
GetDynamicLoaderInstances().PerformDebuggerCallback(debugger);
|
|
GetJITLoaderInstances().PerformDebuggerCallback(debugger);
|
|
GetPlatformInstances().PerformDebuggerCallback(debugger);
|
|
GetProcessInstances().PerformDebuggerCallback(debugger);
|
|
GetSymbolFileInstances().PerformDebuggerCallback(debugger);
|
|
GetOperatingSystemInstances().PerformDebuggerCallback(debugger);
|
|
GetStructuredDataPluginInstances().PerformDebuggerCallback(debugger);
|
|
}
|
|
|
|
// This is the preferred new way to register plugin specific settings. e.g.
|
|
// This will put a plugin's settings under e.g.
|
|
// "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".
|
|
static lldb::OptionValuePropertiesSP
|
|
GetDebuggerPropertyForPlugins(Debugger &debugger, ConstString plugin_type_name,
|
|
ConstString plugin_type_desc, bool can_create) {
|
|
lldb::OptionValuePropertiesSP parent_properties_sp(
|
|
debugger.GetValueProperties());
|
|
if (parent_properties_sp) {
|
|
static ConstString g_property_name("plugin");
|
|
|
|
OptionValuePropertiesSP plugin_properties_sp =
|
|
parent_properties_sp->GetSubProperty(nullptr, g_property_name);
|
|
if (!plugin_properties_sp && can_create) {
|
|
plugin_properties_sp =
|
|
std::make_shared<OptionValueProperties>(g_property_name);
|
|
parent_properties_sp->AppendProperty(
|
|
g_property_name, ConstString("Settings specify to plugins."), true,
|
|
plugin_properties_sp);
|
|
}
|
|
|
|
if (plugin_properties_sp) {
|
|
lldb::OptionValuePropertiesSP plugin_type_properties_sp =
|
|
plugin_properties_sp->GetSubProperty(nullptr, plugin_type_name);
|
|
if (!plugin_type_properties_sp && can_create) {
|
|
plugin_type_properties_sp =
|
|
std::make_shared<OptionValueProperties>(plugin_type_name);
|
|
plugin_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
|
|
true, plugin_type_properties_sp);
|
|
}
|
|
return plugin_type_properties_sp;
|
|
}
|
|
}
|
|
return lldb::OptionValuePropertiesSP();
|
|
}
|
|
|
|
// This is deprecated way to register plugin specific settings. e.g.
|
|
// "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME" and Platform
|
|
// generic settings would be under "platform.SETTINGNAME".
|
|
static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle(
|
|
Debugger &debugger, ConstString plugin_type_name,
|
|
ConstString plugin_type_desc, bool can_create) {
|
|
static ConstString g_property_name("plugin");
|
|
lldb::OptionValuePropertiesSP parent_properties_sp(
|
|
debugger.GetValueProperties());
|
|
if (parent_properties_sp) {
|
|
OptionValuePropertiesSP plugin_properties_sp =
|
|
parent_properties_sp->GetSubProperty(nullptr, plugin_type_name);
|
|
if (!plugin_properties_sp && can_create) {
|
|
plugin_properties_sp =
|
|
std::make_shared<OptionValueProperties>(plugin_type_name);
|
|
parent_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
|
|
true, plugin_properties_sp);
|
|
}
|
|
|
|
if (plugin_properties_sp) {
|
|
lldb::OptionValuePropertiesSP plugin_type_properties_sp =
|
|
plugin_properties_sp->GetSubProperty(nullptr, g_property_name);
|
|
if (!plugin_type_properties_sp && can_create) {
|
|
plugin_type_properties_sp =
|
|
std::make_shared<OptionValueProperties>(g_property_name);
|
|
plugin_properties_sp->AppendProperty(
|
|
g_property_name, ConstString("Settings specific to plugins"), true,
|
|
plugin_type_properties_sp);
|
|
}
|
|
return plugin_type_properties_sp;
|
|
}
|
|
}
|
|
return lldb::OptionValuePropertiesSP();
|
|
}
|
|
|
|
namespace {
|
|
|
|
typedef lldb::OptionValuePropertiesSP
|
|
GetDebuggerPropertyForPluginsPtr(Debugger &, ConstString, ConstString,
|
|
bool can_create);
|
|
|
|
lldb::OptionValuePropertiesSP
|
|
GetSettingForPlugin(Debugger &debugger, ConstString setting_name,
|
|
ConstString plugin_type_name,
|
|
GetDebuggerPropertyForPluginsPtr get_debugger_property =
|
|
GetDebuggerPropertyForPlugins) {
|
|
lldb::OptionValuePropertiesSP properties_sp;
|
|
lldb::OptionValuePropertiesSP plugin_type_properties_sp(get_debugger_property(
|
|
debugger, plugin_type_name,
|
|
ConstString(), // not creating to so we don't need the description
|
|
false));
|
|
if (plugin_type_properties_sp)
|
|
properties_sp =
|
|
plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
|
|
return properties_sp;
|
|
}
|
|
|
|
bool CreateSettingForPlugin(
|
|
Debugger &debugger, ConstString plugin_type_name,
|
|
ConstString plugin_type_desc,
|
|
const lldb::OptionValuePropertiesSP &properties_sp, ConstString description,
|
|
bool is_global_property,
|
|
GetDebuggerPropertyForPluginsPtr get_debugger_property =
|
|
GetDebuggerPropertyForPlugins) {
|
|
if (properties_sp) {
|
|
lldb::OptionValuePropertiesSP plugin_type_properties_sp(
|
|
get_debugger_property(debugger, plugin_type_name, plugin_type_desc,
|
|
true));
|
|
if (plugin_type_properties_sp) {
|
|
plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
|
|
description, is_global_property,
|
|
properties_sp);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const char *kDynamicLoaderPluginName("dynamic-loader");
|
|
const char *kPlatformPluginName("platform");
|
|
const char *kProcessPluginName("process");
|
|
const char *kSymbolFilePluginName("symbol-file");
|
|
const char *kJITLoaderPluginName("jit-loader");
|
|
const char *kStructuredDataPluginName("structured-data");
|
|
|
|
} // anonymous namespace
|
|
|
|
lldb::OptionValuePropertiesSP
|
|
PluginManager::GetSettingForDynamicLoaderPlugin(Debugger &debugger,
|
|
ConstString setting_name) {
|
|
return GetSettingForPlugin(debugger, setting_name,
|
|
ConstString(kDynamicLoaderPluginName));
|
|
}
|
|
|
|
bool PluginManager::CreateSettingForDynamicLoaderPlugin(
|
|
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
|
|
ConstString description, bool is_global_property) {
|
|
return CreateSettingForPlugin(
|
|
debugger, ConstString(kDynamicLoaderPluginName),
|
|
ConstString("Settings for dynamic loader plug-ins"), properties_sp,
|
|
description, is_global_property);
|
|
}
|
|
|
|
lldb::OptionValuePropertiesSP
|
|
PluginManager::GetSettingForPlatformPlugin(Debugger &debugger,
|
|
ConstString setting_name) {
|
|
return GetSettingForPlugin(debugger, setting_name,
|
|
ConstString(kPlatformPluginName),
|
|
GetDebuggerPropertyForPluginsOldStyle);
|
|
}
|
|
|
|
bool PluginManager::CreateSettingForPlatformPlugin(
|
|
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
|
|
ConstString description, bool is_global_property) {
|
|
return CreateSettingForPlugin(debugger, ConstString(kPlatformPluginName),
|
|
ConstString("Settings for platform plug-ins"),
|
|
properties_sp, description, is_global_property,
|
|
GetDebuggerPropertyForPluginsOldStyle);
|
|
}
|
|
|
|
lldb::OptionValuePropertiesSP
|
|
PluginManager::GetSettingForProcessPlugin(Debugger &debugger,
|
|
ConstString setting_name) {
|
|
return GetSettingForPlugin(debugger, setting_name,
|
|
ConstString(kProcessPluginName));
|
|
}
|
|
|
|
bool PluginManager::CreateSettingForProcessPlugin(
|
|
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
|
|
ConstString description, bool is_global_property) {
|
|
return CreateSettingForPlugin(debugger, ConstString(kProcessPluginName),
|
|
ConstString("Settings for process plug-ins"),
|
|
properties_sp, description, is_global_property);
|
|
}
|
|
|
|
lldb::OptionValuePropertiesSP
|
|
PluginManager::GetSettingForSymbolFilePlugin(Debugger &debugger,
|
|
ConstString setting_name) {
|
|
return GetSettingForPlugin(debugger, setting_name,
|
|
ConstString(kSymbolFilePluginName));
|
|
}
|
|
|
|
bool PluginManager::CreateSettingForSymbolFilePlugin(
|
|
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
|
|
ConstString description, bool is_global_property) {
|
|
return CreateSettingForPlugin(
|
|
debugger, ConstString(kSymbolFilePluginName),
|
|
ConstString("Settings for symbol file plug-ins"), properties_sp,
|
|
description, is_global_property);
|
|
}
|
|
|
|
lldb::OptionValuePropertiesSP
|
|
PluginManager::GetSettingForJITLoaderPlugin(Debugger &debugger,
|
|
ConstString setting_name) {
|
|
return GetSettingForPlugin(debugger, setting_name,
|
|
ConstString(kJITLoaderPluginName));
|
|
}
|
|
|
|
bool PluginManager::CreateSettingForJITLoaderPlugin(
|
|
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
|
|
ConstString description, bool is_global_property) {
|
|
return CreateSettingForPlugin(debugger, ConstString(kJITLoaderPluginName),
|
|
ConstString("Settings for JIT loader plug-ins"),
|
|
properties_sp, description, is_global_property);
|
|
}
|
|
|
|
static const char *kOperatingSystemPluginName("os");
|
|
|
|
lldb::OptionValuePropertiesSP
|
|
PluginManager::GetSettingForOperatingSystemPlugin(Debugger &debugger,
|
|
ConstString setting_name) {
|
|
lldb::OptionValuePropertiesSP properties_sp;
|
|
lldb::OptionValuePropertiesSP plugin_type_properties_sp(
|
|
GetDebuggerPropertyForPlugins(
|
|
debugger, ConstString(kOperatingSystemPluginName),
|
|
ConstString(), // not creating to so we don't need the description
|
|
false));
|
|
if (plugin_type_properties_sp)
|
|
properties_sp =
|
|
plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
|
|
return properties_sp;
|
|
}
|
|
|
|
bool PluginManager::CreateSettingForOperatingSystemPlugin(
|
|
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
|
|
ConstString description, bool is_global_property) {
|
|
if (properties_sp) {
|
|
lldb::OptionValuePropertiesSP plugin_type_properties_sp(
|
|
GetDebuggerPropertyForPlugins(
|
|
debugger, ConstString(kOperatingSystemPluginName),
|
|
ConstString("Settings for operating system plug-ins"), true));
|
|
if (plugin_type_properties_sp) {
|
|
plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
|
|
description, is_global_property,
|
|
properties_sp);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
lldb::OptionValuePropertiesSP
|
|
PluginManager::GetSettingForStructuredDataPlugin(Debugger &debugger,
|
|
ConstString setting_name) {
|
|
return GetSettingForPlugin(debugger, setting_name,
|
|
ConstString(kStructuredDataPluginName));
|
|
}
|
|
|
|
bool PluginManager::CreateSettingForStructuredDataPlugin(
|
|
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
|
|
ConstString description, bool is_global_property) {
|
|
return CreateSettingForPlugin(
|
|
debugger, ConstString(kStructuredDataPluginName),
|
|
ConstString("Settings for structured data plug-ins"), properties_sp,
|
|
description, is_global_property);
|
|
}
|