brintos / llvm-project-archived public Read only

1//===-- PluginManager.cpp -------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "lldb/Core/PluginManager.h"10 11#include "lldb/Core/Debugger.h"12#include "lldb/Host/FileSystem.h"13#include "lldb/Host/HostInfo.h"14#include "lldb/Interpreter/OptionValueProperties.h"15#include "lldb/Symbol/SaveCoreOptions.h"16#include "lldb/Target/Process.h"17#include "lldb/Utility/FileSpec.h"18#include "lldb/Utility/Status.h"19#include "lldb/Utility/StringList.h"20#include "llvm/ADT/StringRef.h"21#include "llvm/ADT/Twine.h"22#include "llvm/Support/DynamicLibrary.h"23#include "llvm/Support/FileSystem.h"24#include "llvm/Support/raw_ostream.h"25#include <cassert>26#include <map>27#include <memory>28#include <mutex>29#include <string>30#include <utility>31#include <vector>32#if defined(_WIN32)33#include "lldb/Host/windows/PosixApi.h"34#endif35 36using namespace lldb;37using namespace lldb_private;38 39typedef bool (*PluginInitCallback)();40typedef void (*PluginTermCallback)();41 42struct PluginInfo {43  PluginInfo() = default;44 45  llvm::sys::DynamicLibrary library;46  PluginInitCallback plugin_init_callback = nullptr;47  PluginTermCallback plugin_term_callback = nullptr;48};49 50typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;51 52static std::recursive_mutex &GetPluginMapMutex() {53  static std::recursive_mutex g_plugin_map_mutex;54  return g_plugin_map_mutex;55}56 57static PluginTerminateMap &GetPluginMap() {58  static PluginTerminateMap g_plugin_map;59  return g_plugin_map;60}61 62static bool PluginIsLoaded(const FileSpec &plugin_file_spec) {63  std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());64  PluginTerminateMap &plugin_map = GetPluginMap();65  return plugin_map.find(plugin_file_spec) != plugin_map.end();66}67 68static void SetPluginInfo(const FileSpec &plugin_file_spec,69                          const PluginInfo &plugin_info) {70  std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());71  PluginTerminateMap &plugin_map = GetPluginMap();72  assert(plugin_map.find(plugin_file_spec) == plugin_map.end());73  plugin_map[plugin_file_spec] = plugin_info;74}75 76template <typename FPtrTy> static FPtrTy CastToFPtr(void *VPtr) {77  return reinterpret_cast<FPtrTy>(VPtr);78}79 80static FileSystem::EnumerateDirectoryResult81LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,82                   llvm::StringRef path) {83  Status error;84 85  namespace fs = llvm::sys::fs;86  // If we have a regular file, a symbolic link or unknown file type, try and87  // process the file. We must handle unknown as sometimes the directory88  // enumeration might be enumerating a file system that doesn't have correct89  // file type information.90  if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||91      ft == fs::file_type::type_unknown) {92    FileSpec plugin_file_spec(path);93    FileSystem::Instance().Resolve(plugin_file_spec);94 95    if (PluginIsLoaded(plugin_file_spec))96      return FileSystem::eEnumerateDirectoryResultNext;97    else {98      PluginInfo plugin_info;99 100      std::string pluginLoadError;101      plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(102          plugin_file_spec.GetPath().c_str(), &pluginLoadError);103      if (plugin_info.library.isValid()) {104        bool success = false;105        plugin_info.plugin_init_callback = CastToFPtr<PluginInitCallback>(106            plugin_info.library.getAddressOfSymbol("LLDBPluginInitialize"));107        if (plugin_info.plugin_init_callback) {108          // Call the plug-in "bool LLDBPluginInitialize(void)" function109          success = plugin_info.plugin_init_callback();110        }111 112        if (success) {113          // It is ok for the "LLDBPluginTerminate" symbol to be nullptr114          plugin_info.plugin_term_callback = CastToFPtr<PluginTermCallback>(115              plugin_info.library.getAddressOfSymbol("LLDBPluginTerminate"));116        } else {117          // The initialize function returned FALSE which means the plug-in118          // might not be compatible, or might be too new or too old, or might119          // not want to run on this machine.  Set it to a default-constructed120          // instance to invalidate it.121          plugin_info = PluginInfo();122        }123 124        // Regardless of success or failure, cache the plug-in load in our125        // plug-in info so we don't try to load it again and again.126        SetPluginInfo(plugin_file_spec, plugin_info);127 128        return FileSystem::eEnumerateDirectoryResultNext;129      }130    }131  }132 133  if (ft == fs::file_type::directory_file ||134      ft == fs::file_type::symlink_file || ft == fs::file_type::type_unknown) {135    // Try and recurse into anything that a directory or symbolic link. We must136    // also do this for unknown as sometimes the directory enumeration might be137    // enumerating a file system that doesn't have correct file type138    // information.139    return FileSystem::eEnumerateDirectoryResultEnter;140  }141 142  return FileSystem::eEnumerateDirectoryResultNext;143}144 145void PluginManager::Initialize() {146  const bool find_directories = true;147  const bool find_files = true;148  const bool find_other = true;149  char dir_path[PATH_MAX];150  if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {151    if (FileSystem::Instance().Exists(dir_spec) &&152        dir_spec.GetPath(dir_path, sizeof(dir_path))) {153      FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,154                                                find_files, find_other,155                                                LoadPluginCallback, nullptr);156    }157  }158 159  if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {160    if (FileSystem::Instance().Exists(dir_spec) &&161        dir_spec.GetPath(dir_path, sizeof(dir_path))) {162      FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,163                                                find_files, find_other,164                                                LoadPluginCallback, nullptr);165    }166  }167}168 169void PluginManager::Terminate() {170  std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());171  PluginTerminateMap &plugin_map = GetPluginMap();172 173  PluginTerminateMap::const_iterator pos, end = plugin_map.end();174  for (pos = plugin_map.begin(); pos != end; ++pos) {175    // Call the plug-in "void LLDBPluginTerminate (void)" function if there is176    // one (if the symbol was not nullptr).177    if (pos->second.library.isValid()) {178      if (pos->second.plugin_term_callback)179        pos->second.plugin_term_callback();180    }181  }182  plugin_map.clear();183}184 185llvm::ArrayRef<PluginNamespace> PluginManager::GetPluginNamespaces() {186  static PluginNamespace PluginNamespaces[] = {187 188      {189          "abi",190          PluginManager::GetABIPluginInfo,191          PluginManager::SetABIPluginEnabled,192      },193 194      {195          "architecture",196          PluginManager::GetArchitecturePluginInfo,197          PluginManager::SetArchitecturePluginEnabled,198      },199 200      {201          "disassembler",202          PluginManager::GetDisassemblerPluginInfo,203          PluginManager::SetDisassemblerPluginEnabled,204      },205 206      {207          "dynamic-loader",208          PluginManager::GetDynamicLoaderPluginInfo,209          PluginManager::SetDynamicLoaderPluginEnabled,210      },211 212      {213          "emulate-instruction",214          PluginManager::GetEmulateInstructionPluginInfo,215          PluginManager::SetEmulateInstructionPluginEnabled,216      },217 218      {219          "instrumentation-runtime",220          PluginManager::GetInstrumentationRuntimePluginInfo,221          PluginManager::SetInstrumentationRuntimePluginEnabled,222      },223 224      {225          "jit-loader",226          PluginManager::GetJITLoaderPluginInfo,227          PluginManager::SetJITLoaderPluginEnabled,228      },229 230      {231          "language",232          PluginManager::GetLanguagePluginInfo,233          PluginManager::SetLanguagePluginEnabled,234      },235 236      {237          "language-runtime",238          PluginManager::GetLanguageRuntimePluginInfo,239          PluginManager::SetLanguageRuntimePluginEnabled,240      },241 242      {243          "memory-history",244          PluginManager::GetMemoryHistoryPluginInfo,245          PluginManager::SetMemoryHistoryPluginEnabled,246      },247 248      {249          "object-container",250          PluginManager::GetObjectContainerPluginInfo,251          PluginManager::SetObjectContainerPluginEnabled,252      },253 254      {255          "object-file",256          PluginManager::GetObjectFilePluginInfo,257          PluginManager::SetObjectFilePluginEnabled,258      },259 260      {261          "operating-system",262          PluginManager::GetOperatingSystemPluginInfo,263          PluginManager::SetOperatingSystemPluginEnabled,264      },265 266      {267          "platform",268          PluginManager::GetPlatformPluginInfo,269          PluginManager::SetPlatformPluginEnabled,270      },271 272      {273          "process",274          PluginManager::GetProcessPluginInfo,275          PluginManager::SetProcessPluginEnabled,276      },277 278      {279          "repl",280          PluginManager::GetREPLPluginInfo,281          PluginManager::SetREPLPluginEnabled,282      },283 284      {285          "register-type-builder",286          PluginManager::GetRegisterTypeBuilderPluginInfo,287          PluginManager::SetRegisterTypeBuilderPluginEnabled,288      },289 290      {291          "script-interpreter",292          PluginManager::GetScriptInterpreterPluginInfo,293          PluginManager::SetScriptInterpreterPluginEnabled,294      },295 296      {297          "scripted-interface",298          PluginManager::GetScriptedInterfacePluginInfo,299          PluginManager::SetScriptedInterfacePluginEnabled,300      },301 302      {303          "structured-data",304          PluginManager::GetStructuredDataPluginInfo,305          PluginManager::SetStructuredDataPluginEnabled,306      },307 308      {309          "symbol-file",310          PluginManager::GetSymbolFilePluginInfo,311          PluginManager::SetSymbolFilePluginEnabled,312      },313 314      {315          "symbol-locator",316          PluginManager::GetSymbolLocatorPluginInfo,317          PluginManager::SetSymbolLocatorPluginEnabled,318      },319 320      {321          "symbol-vendor",322          PluginManager::GetSymbolVendorPluginInfo,323          PluginManager::SetSymbolVendorPluginEnabled,324      },325 326      {327          "system-runtime",328          PluginManager::GetSystemRuntimePluginInfo,329          PluginManager::SetSystemRuntimePluginEnabled,330      },331 332      {333          "trace",334          PluginManager::GetTracePluginInfo,335          PluginManager::SetTracePluginEnabled,336      },337 338      {339          "trace-exporter",340          PluginManager::GetTraceExporterPluginInfo,341          PluginManager::SetTraceExporterPluginEnabled,342      },343 344      {345          "type-system",346          PluginManager::GetTypeSystemPluginInfo,347          PluginManager::SetTypeSystemPluginEnabled,348      },349 350      {351          "unwind-assembly",352          PluginManager::GetUnwindAssemblyPluginInfo,353          PluginManager::SetUnwindAssemblyPluginEnabled,354      },355  };356 357  return PluginNamespaces;358}359 360llvm::json::Object PluginManager::GetJSON(llvm::StringRef pattern) {361  llvm::json::Object plugin_stats;362 363  for (const PluginNamespace &plugin_ns : GetPluginNamespaces()) {364    llvm::json::Array namespace_stats;365 366    for (const RegisteredPluginInfo &plugin : plugin_ns.get_info()) {367      if (MatchPluginName(pattern, plugin_ns, plugin)) {368        llvm::json::Object plugin_json;369        plugin_json.try_emplace("name", plugin.name);370        plugin_json.try_emplace("enabled", plugin.enabled);371        namespace_stats.emplace_back(std::move(plugin_json));372      }373    }374    if (!namespace_stats.empty())375      plugin_stats.try_emplace(plugin_ns.name, std::move(namespace_stats));376  }377 378  return plugin_stats;379}380 381bool PluginManager::MatchPluginName(llvm::StringRef pattern,382                                    const PluginNamespace &plugin_ns,383                                    const RegisteredPluginInfo &plugin_info) {384  // The empty pattern matches all plugins.385  if (pattern.empty())386    return true;387 388  // Check if the pattern matches the namespace.389  if (pattern == plugin_ns.name)390    return true;391 392  // Check if the pattern matches the qualified name.393  std::string qualified_name = (plugin_ns.name + "." + plugin_info.name).str();394  return pattern == qualified_name;395}396 397template <typename Callback> struct PluginInstance {398  typedef Callback CallbackType;399 400  PluginInstance() = default;401  PluginInstance(llvm::StringRef name, llvm::StringRef description,402                 Callback create_callback,403                 DebuggerInitializeCallback debugger_init_callback = nullptr)404      : name(name), description(description), enabled(true),405        create_callback(create_callback),406        debugger_init_callback(debugger_init_callback) {}407 408  llvm::StringRef name;409  llvm::StringRef description;410  bool enabled;411  Callback create_callback;412  DebuggerInitializeCallback debugger_init_callback;413};414 415template <typename Instance> class PluginInstances {416public:417  template <typename... Args>418  bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description,419                      typename Instance::CallbackType callback,420                      Args &&...args) {421    if (!callback)422      return false;423    assert(!name.empty());424    m_instances.emplace_back(name, description, callback,425                             std::forward<Args>(args)...);426    return true;427  }428 429  bool UnregisterPlugin(typename Instance::CallbackType callback) {430    if (!callback)431      return false;432    auto pos = m_instances.begin();433    auto end = m_instances.end();434    for (; pos != end; ++pos) {435      if (pos->create_callback == callback) {436        m_instances.erase(pos);437        return true;438      }439    }440    return false;441  }442 443  typename Instance::CallbackType GetCallbackAtIndex(uint32_t idx) {444    if (const Instance *instance = GetInstanceAtIndex(idx))445      return instance->create_callback;446    return nullptr;447  }448 449  llvm::StringRef GetDescriptionAtIndex(uint32_t idx) {450    if (const Instance *instance = GetInstanceAtIndex(idx))451      return instance->description;452    return "";453  }454 455  llvm::StringRef GetNameAtIndex(uint32_t idx) {456    if (const Instance *instance = GetInstanceAtIndex(idx))457      return instance->name;458    return "";459  }460 461  typename Instance::CallbackType GetCallbackForName(llvm::StringRef name) {462    if (const Instance *instance = GetInstanceForName(name))463      return instance->create_callback;464    return nullptr;465  }466 467  void PerformDebuggerCallback(Debugger &debugger) {468    for (const auto &instance : m_instances) {469      if (!instance.enabled)470        continue;471      if (instance.debugger_init_callback)472        instance.debugger_init_callback(debugger);473    }474  }475 476  // Return a copy of all the enabled instances.477  // Note that this is a copy of the internal state so modifications478  // to the returned instances will not be reflected back to instances479  // stored by the PluginInstances object.480  std::vector<Instance> GetSnapshot() {481    std::vector<Instance> enabled_instances;482    for (const auto &instance : m_instances) {483      if (instance.enabled)484        enabled_instances.push_back(instance);485    }486    return enabled_instances;487  }488 489  const Instance *GetInstanceAtIndex(uint32_t idx) {490    uint32_t count = 0;491 492    return FindEnabledInstance(493        [&](const Instance &instance) { return count++ == idx; });494  }495 496  const Instance *GetInstanceForName(llvm::StringRef name) {497    if (name.empty())498      return nullptr;499 500    return FindEnabledInstance(501        [&](const Instance &instance) { return instance.name == name; });502  }503 504  const Instance *505  FindEnabledInstance(std::function<bool(const Instance &)> predicate) const {506    for (const auto &instance : m_instances) {507      if (!instance.enabled)508        continue;509      if (predicate(instance))510        return &instance;511    }512    return nullptr;513  }514 515  // Return a list of all the registered plugin instances. This includes both516  // enabled and disabled instances. The instances are listed in the order they517  // were registered which is the order they would be queried if they were all518  // enabled.519  std::vector<RegisteredPluginInfo> GetPluginInfoForAllInstances() {520    // Lookup the plugin info for each instance in the sorted order.521    std::vector<RegisteredPluginInfo> plugin_infos;522    plugin_infos.reserve(m_instances.size());523    for (const Instance &instance : m_instances)524      plugin_infos.push_back(525          {instance.name, instance.description, instance.enabled});526 527    return plugin_infos;528  }529 530  bool SetInstanceEnabled(llvm::StringRef name, bool enable) {531    auto it = llvm::find_if(m_instances, [&](const Instance &instance) {532      return instance.name == name;533    });534 535    if (it == m_instances.end())536      return false;537 538    it->enabled = enable;539    return true;540  }541 542private:543  std::vector<Instance> m_instances;544};545 546#pragma mark ABI547 548typedef PluginInstance<ABICreateInstance> ABIInstance;549typedef PluginInstances<ABIInstance> ABIInstances;550 551static ABIInstances &GetABIInstances() {552  static ABIInstances g_instances;553  return g_instances;554}555 556bool PluginManager::RegisterPlugin(llvm::StringRef name,557                                   llvm::StringRef description,558                                   ABICreateInstance create_callback) {559  return GetABIInstances().RegisterPlugin(name, description, create_callback);560}561 562bool PluginManager::UnregisterPlugin(ABICreateInstance create_callback) {563  return GetABIInstances().UnregisterPlugin(create_callback);564}565 566ABICreateInstance PluginManager::GetABICreateCallbackAtIndex(uint32_t idx) {567  return GetABIInstances().GetCallbackAtIndex(idx);568}569 570#pragma mark Architecture571 572typedef PluginInstance<ArchitectureCreateInstance> ArchitectureInstance;573typedef PluginInstances<ArchitectureInstance> ArchitectureInstances;574 575static ArchitectureInstances &GetArchitectureInstances() {576  static ArchitectureInstances g_instances;577  return g_instances;578}579 580void PluginManager::RegisterPlugin(llvm::StringRef name,581                                   llvm::StringRef description,582                                   ArchitectureCreateInstance create_callback) {583  GetArchitectureInstances().RegisterPlugin(name, description, create_callback);584}585 586void PluginManager::UnregisterPlugin(587    ArchitectureCreateInstance create_callback) {588  auto &instances = GetArchitectureInstances();589  instances.UnregisterPlugin(create_callback);590}591 592std::unique_ptr<Architecture>593PluginManager::CreateArchitectureInstance(const ArchSpec &arch) {594  for (const auto &instances : GetArchitectureInstances().GetSnapshot()) {595    if (auto plugin_up = instances.create_callback(arch))596      return plugin_up;597  }598  return nullptr;599}600 601#pragma mark Disassembler602 603typedef PluginInstance<DisassemblerCreateInstance> DisassemblerInstance;604typedef PluginInstances<DisassemblerInstance> DisassemblerInstances;605 606static DisassemblerInstances &GetDisassemblerInstances() {607  static DisassemblerInstances g_instances;608  return g_instances;609}610 611bool PluginManager::RegisterPlugin(llvm::StringRef name,612                                   llvm::StringRef description,613                                   DisassemblerCreateInstance create_callback) {614  return GetDisassemblerInstances().RegisterPlugin(name, description,615                                                   create_callback);616}617 618bool PluginManager::UnregisterPlugin(619    DisassemblerCreateInstance create_callback) {620  return GetDisassemblerInstances().UnregisterPlugin(create_callback);621}622 623DisassemblerCreateInstance624PluginManager::GetDisassemblerCreateCallbackAtIndex(uint32_t idx) {625  return GetDisassemblerInstances().GetCallbackAtIndex(idx);626}627 628DisassemblerCreateInstance629PluginManager::GetDisassemblerCreateCallbackForPluginName(630    llvm::StringRef name) {631  return GetDisassemblerInstances().GetCallbackForName(name);632}633 634#pragma mark DynamicLoader635 636typedef PluginInstance<DynamicLoaderCreateInstance> DynamicLoaderInstance;637typedef PluginInstances<DynamicLoaderInstance> DynamicLoaderInstances;638 639static DynamicLoaderInstances &GetDynamicLoaderInstances() {640  static DynamicLoaderInstances g_instances;641  return g_instances;642}643 644bool PluginManager::RegisterPlugin(645    llvm::StringRef name, llvm::StringRef description,646    DynamicLoaderCreateInstance create_callback,647    DebuggerInitializeCallback debugger_init_callback) {648  return GetDynamicLoaderInstances().RegisterPlugin(649      name, description, create_callback, debugger_init_callback);650}651 652bool PluginManager::UnregisterPlugin(653    DynamicLoaderCreateInstance create_callback) {654  return GetDynamicLoaderInstances().UnregisterPlugin(create_callback);655}656 657DynamicLoaderCreateInstance658PluginManager::GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx) {659  return GetDynamicLoaderInstances().GetCallbackAtIndex(idx);660}661 662DynamicLoaderCreateInstance663PluginManager::GetDynamicLoaderCreateCallbackForPluginName(664    llvm::StringRef name) {665  return GetDynamicLoaderInstances().GetCallbackForName(name);666}667 668#pragma mark JITLoader669 670typedef PluginInstance<JITLoaderCreateInstance> JITLoaderInstance;671typedef PluginInstances<JITLoaderInstance> JITLoaderInstances;672 673static JITLoaderInstances &GetJITLoaderInstances() {674  static JITLoaderInstances g_instances;675  return g_instances;676}677 678bool PluginManager::RegisterPlugin(679    llvm::StringRef name, llvm::StringRef description,680    JITLoaderCreateInstance create_callback,681    DebuggerInitializeCallback debugger_init_callback) {682  return GetJITLoaderInstances().RegisterPlugin(683      name, description, create_callback, debugger_init_callback);684}685 686bool PluginManager::UnregisterPlugin(JITLoaderCreateInstance create_callback) {687  return GetJITLoaderInstances().UnregisterPlugin(create_callback);688}689 690JITLoaderCreateInstance691PluginManager::GetJITLoaderCreateCallbackAtIndex(uint32_t idx) {692  return GetJITLoaderInstances().GetCallbackAtIndex(idx);693}694 695#pragma mark EmulateInstruction696 697typedef PluginInstance<EmulateInstructionCreateInstance>698    EmulateInstructionInstance;699typedef PluginInstances<EmulateInstructionInstance> EmulateInstructionInstances;700 701static EmulateInstructionInstances &GetEmulateInstructionInstances() {702  static EmulateInstructionInstances g_instances;703  return g_instances;704}705 706bool PluginManager::RegisterPlugin(707    llvm::StringRef name, llvm::StringRef description,708    EmulateInstructionCreateInstance create_callback) {709  return GetEmulateInstructionInstances().RegisterPlugin(name, description,710                                                         create_callback);711}712 713bool PluginManager::UnregisterPlugin(714    EmulateInstructionCreateInstance create_callback) {715  return GetEmulateInstructionInstances().UnregisterPlugin(create_callback);716}717 718EmulateInstructionCreateInstance719PluginManager::GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx) {720  return GetEmulateInstructionInstances().GetCallbackAtIndex(idx);721}722 723EmulateInstructionCreateInstance724PluginManager::GetEmulateInstructionCreateCallbackForPluginName(725    llvm::StringRef name) {726  return GetEmulateInstructionInstances().GetCallbackForName(name);727}728 729#pragma mark OperatingSystem730 731typedef PluginInstance<OperatingSystemCreateInstance> OperatingSystemInstance;732typedef PluginInstances<OperatingSystemInstance> OperatingSystemInstances;733 734static OperatingSystemInstances &GetOperatingSystemInstances() {735  static OperatingSystemInstances g_instances;736  return g_instances;737}738 739bool PluginManager::RegisterPlugin(740    llvm::StringRef name, llvm::StringRef description,741    OperatingSystemCreateInstance create_callback,742    DebuggerInitializeCallback debugger_init_callback) {743  return GetOperatingSystemInstances().RegisterPlugin(744      name, description, create_callback, debugger_init_callback);745}746 747bool PluginManager::UnregisterPlugin(748    OperatingSystemCreateInstance create_callback) {749  return GetOperatingSystemInstances().UnregisterPlugin(create_callback);750}751 752OperatingSystemCreateInstance753PluginManager::GetOperatingSystemCreateCallbackAtIndex(uint32_t idx) {754  return GetOperatingSystemInstances().GetCallbackAtIndex(idx);755}756 757OperatingSystemCreateInstance758PluginManager::GetOperatingSystemCreateCallbackForPluginName(759    llvm::StringRef name) {760  return GetOperatingSystemInstances().GetCallbackForName(name);761}762 763#pragma mark Language764 765typedef PluginInstance<LanguageCreateInstance> LanguageInstance;766typedef PluginInstances<LanguageInstance> LanguageInstances;767 768static LanguageInstances &GetLanguageInstances() {769  static LanguageInstances g_instances;770  return g_instances;771}772 773bool PluginManager::RegisterPlugin(774    llvm::StringRef name, llvm::StringRef description,775    LanguageCreateInstance create_callback,776    DebuggerInitializeCallback debugger_init_callback) {777  return GetLanguageInstances().RegisterPlugin(778      name, description, create_callback, debugger_init_callback);779}780 781bool PluginManager::UnregisterPlugin(LanguageCreateInstance create_callback) {782  return GetLanguageInstances().UnregisterPlugin(create_callback);783}784 785LanguageCreateInstance786PluginManager::GetLanguageCreateCallbackAtIndex(uint32_t idx) {787  return GetLanguageInstances().GetCallbackAtIndex(idx);788}789 790#pragma mark LanguageRuntime791 792struct LanguageRuntimeInstance793    : public PluginInstance<LanguageRuntimeCreateInstance> {794  LanguageRuntimeInstance(795      llvm::StringRef name, llvm::StringRef description,796      CallbackType create_callback,797      DebuggerInitializeCallback debugger_init_callback,798      LanguageRuntimeGetCommandObject command_callback,799      LanguageRuntimeGetExceptionPrecondition precondition_callback)800      : PluginInstance<LanguageRuntimeCreateInstance>(801            name, description, create_callback, debugger_init_callback),802        command_callback(command_callback),803        precondition_callback(precondition_callback) {}804 805  LanguageRuntimeGetCommandObject command_callback;806  LanguageRuntimeGetExceptionPrecondition precondition_callback;807};808 809typedef PluginInstances<LanguageRuntimeInstance> LanguageRuntimeInstances;810 811static LanguageRuntimeInstances &GetLanguageRuntimeInstances() {812  static LanguageRuntimeInstances g_instances;813  return g_instances;814}815 816bool PluginManager::RegisterPlugin(817    llvm::StringRef name, llvm::StringRef description,818    LanguageRuntimeCreateInstance create_callback,819    LanguageRuntimeGetCommandObject command_callback,820    LanguageRuntimeGetExceptionPrecondition precondition_callback) {821  return GetLanguageRuntimeInstances().RegisterPlugin(822      name, description, create_callback, nullptr, command_callback,823      precondition_callback);824}825 826bool PluginManager::UnregisterPlugin(827    LanguageRuntimeCreateInstance create_callback) {828  return GetLanguageRuntimeInstances().UnregisterPlugin(create_callback);829}830 831LanguageRuntimeCreateInstance832PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(uint32_t idx) {833  return GetLanguageRuntimeInstances().GetCallbackAtIndex(idx);834}835 836LanguageRuntimeGetCommandObject837PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx) {838  if (auto instance = GetLanguageRuntimeInstances().GetInstanceAtIndex(idx))839    return instance->command_callback;840  return nullptr;841}842 843LanguageRuntimeGetExceptionPrecondition844PluginManager::GetLanguageRuntimeGetExceptionPreconditionAtIndex(uint32_t idx) {845  if (auto instance = GetLanguageRuntimeInstances().GetInstanceAtIndex(idx))846    return instance->precondition_callback;847  return nullptr;848}849 850#pragma mark SystemRuntime851 852typedef PluginInstance<SystemRuntimeCreateInstance> SystemRuntimeInstance;853typedef PluginInstances<SystemRuntimeInstance> SystemRuntimeInstances;854 855static SystemRuntimeInstances &GetSystemRuntimeInstances() {856  static SystemRuntimeInstances g_instances;857  return g_instances;858}859 860bool PluginManager::RegisterPlugin(861    llvm::StringRef name, llvm::StringRef description,862    SystemRuntimeCreateInstance create_callback) {863  return GetSystemRuntimeInstances().RegisterPlugin(name, description,864                                                    create_callback);865}866 867bool PluginManager::UnregisterPlugin(868    SystemRuntimeCreateInstance create_callback) {869  return GetSystemRuntimeInstances().UnregisterPlugin(create_callback);870}871 872SystemRuntimeCreateInstance873PluginManager::GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx) {874  return GetSystemRuntimeInstances().GetCallbackAtIndex(idx);875}876 877#pragma mark ObjectFile878 879struct ObjectFileInstance : public PluginInstance<ObjectFileCreateInstance> {880  ObjectFileInstance(881      llvm::StringRef name, llvm::StringRef description,882      CallbackType create_callback,883      ObjectFileCreateMemoryInstance create_memory_callback,884      ObjectFileGetModuleSpecifications get_module_specifications,885      ObjectFileSaveCore save_core,886      DebuggerInitializeCallback debugger_init_callback)887      : PluginInstance<ObjectFileCreateInstance>(888            name, description, create_callback, debugger_init_callback),889        create_memory_callback(create_memory_callback),890        get_module_specifications(get_module_specifications),891        save_core(save_core) {}892 893  ObjectFileCreateMemoryInstance create_memory_callback;894  ObjectFileGetModuleSpecifications get_module_specifications;895  ObjectFileSaveCore save_core;896};897typedef PluginInstances<ObjectFileInstance> ObjectFileInstances;898 899static ObjectFileInstances &GetObjectFileInstances() {900  static ObjectFileInstances g_instances;901  return g_instances;902}903 904bool PluginManager::IsRegisteredObjectFilePluginName(llvm::StringRef name) {905  if (name.empty())906    return false;907 908  return GetObjectFileInstances().GetInstanceForName(name) != nullptr;909}910 911bool PluginManager::RegisterPlugin(912    llvm::StringRef name, llvm::StringRef description,913    ObjectFileCreateInstance create_callback,914    ObjectFileCreateMemoryInstance create_memory_callback,915    ObjectFileGetModuleSpecifications get_module_specifications,916    ObjectFileSaveCore save_core,917    DebuggerInitializeCallback debugger_init_callback) {918  return GetObjectFileInstances().RegisterPlugin(919      name, description, create_callback, create_memory_callback,920      get_module_specifications, save_core, debugger_init_callback);921}922 923bool PluginManager::UnregisterPlugin(ObjectFileCreateInstance create_callback) {924  return GetObjectFileInstances().UnregisterPlugin(create_callback);925}926 927ObjectFileCreateInstance928PluginManager::GetObjectFileCreateCallbackAtIndex(uint32_t idx) {929  return GetObjectFileInstances().GetCallbackAtIndex(idx);930}931 932ObjectFileCreateMemoryInstance933PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx) {934  if (auto instance = GetObjectFileInstances().GetInstanceAtIndex(idx))935    return instance->create_memory_callback;936  return nullptr;937}938 939ObjectFileGetModuleSpecifications940PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(941    uint32_t idx) {942  if (auto instance = GetObjectFileInstances().GetInstanceAtIndex(idx))943    return instance->get_module_specifications;944  return nullptr;945}946 947ObjectFileCreateMemoryInstance948PluginManager::GetObjectFileCreateMemoryCallbackForPluginName(949    llvm::StringRef name) {950  if (auto instance = GetObjectFileInstances().GetInstanceForName(name))951    return instance->create_memory_callback;952  return nullptr;953}954 955Status PluginManager::SaveCore(lldb_private::SaveCoreOptions &options) {956  Status error;957  if (!options.GetOutputFile()) {958    error = Status::FromErrorString("No output file specified");959    return error;960  }961 962  if (!options.GetProcess()) {963    error = Status::FromErrorString("Invalid process");964    return error;965  }966 967  error = options.EnsureValidConfiguration();968  if (error.Fail())969    return error;970 971  if (!options.GetPluginName().has_value()) {972    // Try saving core directly from the process plugin first.973    llvm::Expected<bool> ret =974        options.GetProcess()->SaveCore(options.GetOutputFile()->GetPath());975    if (!ret)976      return Status::FromError(ret.takeError());977    if (ret.get())978      return Status();979  }980 981  // Fall back to object plugins.982  const auto &plugin_name = options.GetPluginName().value_or("");983  auto instances = GetObjectFileInstances().GetSnapshot();984  for (auto &instance : instances) {985    if (plugin_name.empty() || instance.name == plugin_name) {986      // TODO: Refactor the instance.save_core() to not require a process and987      // get it from options instead.988      if (instance.save_core &&989          instance.save_core(options.GetProcess(), options, error))990        return error;991    }992  }993 994  // Check to see if any of the object file plugins tried and failed to save.995  // if any failure, return the error message.996  if (error.Fail())997    return error;998 999  // Report only for the plugin that was specified.1000  if (!plugin_name.empty())1001    return Status::FromErrorStringWithFormatv(1002        "The \"{}\" plugin is not able to save a core for this process.",1003        plugin_name);1004 1005  return Status::FromErrorString(1006      "no ObjectFile plugins were able to save a core for this process");1007}1008 1009std::vector<llvm::StringRef> PluginManager::GetSaveCorePluginNames() {1010  std::vector<llvm::StringRef> plugin_names;1011  auto instances = GetObjectFileInstances().GetSnapshot();1012  for (auto &instance : instances) {1013    if (instance.save_core)1014      plugin_names.emplace_back(instance.name);1015  }1016  return plugin_names;1017}1018 1019#pragma mark ObjectContainer1020 1021struct ObjectContainerInstance1022    : public PluginInstance<ObjectContainerCreateInstance> {1023  ObjectContainerInstance(1024      llvm::StringRef name, llvm::StringRef description,1025      CallbackType create_callback,1026      ObjectContainerCreateMemoryInstance create_memory_callback,1027      ObjectFileGetModuleSpecifications get_module_specifications)1028      : PluginInstance<ObjectContainerCreateInstance>(name, description,1029                                                      create_callback),1030        create_memory_callback(create_memory_callback),1031        get_module_specifications(get_module_specifications) {}1032 1033  ObjectContainerCreateMemoryInstance create_memory_callback;1034  ObjectFileGetModuleSpecifications get_module_specifications;1035};1036typedef PluginInstances<ObjectContainerInstance> ObjectContainerInstances;1037 1038static ObjectContainerInstances &GetObjectContainerInstances() {1039  static ObjectContainerInstances g_instances;1040  return g_instances;1041}1042 1043bool PluginManager::RegisterPlugin(1044    llvm::StringRef name, llvm::StringRef description,1045    ObjectContainerCreateInstance create_callback,1046    ObjectFileGetModuleSpecifications get_module_specifications,1047    ObjectContainerCreateMemoryInstance create_memory_callback) {1048  return GetObjectContainerInstances().RegisterPlugin(1049      name, description, create_callback, create_memory_callback,1050      get_module_specifications);1051}1052 1053bool PluginManager::UnregisterPlugin(1054    ObjectContainerCreateInstance create_callback) {1055  return GetObjectContainerInstances().UnregisterPlugin(create_callback);1056}1057 1058ObjectContainerCreateInstance1059PluginManager::GetObjectContainerCreateCallbackAtIndex(uint32_t idx) {1060  return GetObjectContainerInstances().GetCallbackAtIndex(idx);1061}1062 1063ObjectContainerCreateMemoryInstance1064PluginManager::GetObjectContainerCreateMemoryCallbackAtIndex(uint32_t idx) {1065  if (auto instance = GetObjectContainerInstances().GetInstanceAtIndex(idx))1066    return instance->create_memory_callback;1067  return nullptr;1068}1069 1070ObjectFileGetModuleSpecifications1071PluginManager::GetObjectContainerGetModuleSpecificationsCallbackAtIndex(1072    uint32_t idx) {1073  if (auto instance = GetObjectContainerInstances().GetInstanceAtIndex(idx))1074    return instance->get_module_specifications;1075  return nullptr;1076}1077 1078#pragma mark Platform1079 1080typedef PluginInstance<PlatformCreateInstance> PlatformInstance;1081typedef PluginInstances<PlatformInstance> PlatformInstances;1082 1083static PlatformInstances &GetPlatformInstances() {1084  static PlatformInstances g_platform_instances;1085  return g_platform_instances;1086}1087 1088bool PluginManager::RegisterPlugin(1089    llvm::StringRef name, llvm::StringRef description,1090    PlatformCreateInstance create_callback,1091    DebuggerInitializeCallback debugger_init_callback) {1092  return GetPlatformInstances().RegisterPlugin(1093      name, description, create_callback, debugger_init_callback);1094}1095 1096bool PluginManager::UnregisterPlugin(PlatformCreateInstance create_callback) {1097  return GetPlatformInstances().UnregisterPlugin(create_callback);1098}1099 1100llvm::StringRef PluginManager::GetPlatformPluginNameAtIndex(uint32_t idx) {1101  return GetPlatformInstances().GetNameAtIndex(idx);1102}1103 1104llvm::StringRef1105PluginManager::GetPlatformPluginDescriptionAtIndex(uint32_t idx) {1106  return GetPlatformInstances().GetDescriptionAtIndex(idx);1107}1108 1109PlatformCreateInstance1110PluginManager::GetPlatformCreateCallbackAtIndex(uint32_t idx) {1111  return GetPlatformInstances().GetCallbackAtIndex(idx);1112}1113 1114PlatformCreateInstance1115PluginManager::GetPlatformCreateCallbackForPluginName(llvm::StringRef name) {1116  return GetPlatformInstances().GetCallbackForName(name);1117}1118 1119void PluginManager::AutoCompletePlatformName(llvm::StringRef name,1120                                             CompletionRequest &request) {1121  for (const auto &instance : GetPlatformInstances().GetSnapshot()) {1122    if (instance.name.starts_with(name))1123      request.AddCompletion(instance.name);1124  }1125}1126 1127#pragma mark Process1128 1129typedef PluginInstance<ProcessCreateInstance> ProcessInstance;1130typedef PluginInstances<ProcessInstance> ProcessInstances;1131 1132static ProcessInstances &GetProcessInstances() {1133  static ProcessInstances g_instances;1134  return g_instances;1135}1136 1137bool PluginManager::RegisterPlugin(1138    llvm::StringRef name, llvm::StringRef description,1139    ProcessCreateInstance create_callback,1140    DebuggerInitializeCallback debugger_init_callback) {1141  return GetProcessInstances().RegisterPlugin(1142      name, description, create_callback, debugger_init_callback);1143}1144 1145bool PluginManager::UnregisterPlugin(ProcessCreateInstance create_callback) {1146  return GetProcessInstances().UnregisterPlugin(create_callback);1147}1148 1149llvm::StringRef PluginManager::GetProcessPluginNameAtIndex(uint32_t idx) {1150  return GetProcessInstances().GetNameAtIndex(idx);1151}1152 1153llvm::StringRef PluginManager::GetProcessPluginDescriptionAtIndex(uint32_t idx) {1154  return GetProcessInstances().GetDescriptionAtIndex(idx);1155}1156 1157ProcessCreateInstance1158PluginManager::GetProcessCreateCallbackAtIndex(uint32_t idx) {1159  return GetProcessInstances().GetCallbackAtIndex(idx);1160}1161 1162ProcessCreateInstance1163PluginManager::GetProcessCreateCallbackForPluginName(llvm::StringRef name) {1164  return GetProcessInstances().GetCallbackForName(name);1165}1166 1167void PluginManager::AutoCompleteProcessName(llvm::StringRef name,1168                                            CompletionRequest &request) {1169  for (const auto &instance : GetProcessInstances().GetSnapshot()) {1170    if (instance.name.starts_with(name))1171      request.AddCompletion(instance.name, instance.description);1172  }1173}1174 1175#pragma mark ProtocolServer1176 1177typedef PluginInstance<ProtocolServerCreateInstance> ProtocolServerInstance;1178typedef PluginInstances<ProtocolServerInstance> ProtocolServerInstances;1179 1180static ProtocolServerInstances &GetProtocolServerInstances() {1181  static ProtocolServerInstances g_instances;1182  return g_instances;1183}1184 1185bool PluginManager::RegisterPlugin(1186    llvm::StringRef name, llvm::StringRef description,1187    ProtocolServerCreateInstance create_callback) {1188  return GetProtocolServerInstances().RegisterPlugin(name, description,1189                                                     create_callback);1190}1191 1192bool PluginManager::UnregisterPlugin(1193    ProtocolServerCreateInstance create_callback) {1194  return GetProtocolServerInstances().UnregisterPlugin(create_callback);1195}1196 1197llvm::StringRef1198PluginManager::GetProtocolServerPluginNameAtIndex(uint32_t idx) {1199  return GetProtocolServerInstances().GetNameAtIndex(idx);1200}1201 1202ProtocolServerCreateInstance1203PluginManager::GetProtocolCreateCallbackForPluginName(llvm::StringRef name) {1204  return GetProtocolServerInstances().GetCallbackForName(name);1205}1206 1207#pragma mark RegisterTypeBuilder1208 1209struct RegisterTypeBuilderInstance1210    : public PluginInstance<RegisterTypeBuilderCreateInstance> {1211  RegisterTypeBuilderInstance(llvm::StringRef name, llvm::StringRef description,1212                              CallbackType create_callback)1213      : PluginInstance<RegisterTypeBuilderCreateInstance>(name, description,1214                                                          create_callback) {}1215};1216 1217typedef PluginInstances<RegisterTypeBuilderInstance>1218    RegisterTypeBuilderInstances;1219 1220static RegisterTypeBuilderInstances &GetRegisterTypeBuilderInstances() {1221  static RegisterTypeBuilderInstances g_instances;1222  return g_instances;1223}1224 1225bool PluginManager::RegisterPlugin(1226    llvm::StringRef name, llvm::StringRef description,1227    RegisterTypeBuilderCreateInstance create_callback) {1228  return GetRegisterTypeBuilderInstances().RegisterPlugin(name, description,1229                                                          create_callback);1230}1231 1232bool PluginManager::UnregisterPlugin(1233    RegisterTypeBuilderCreateInstance create_callback) {1234  return GetRegisterTypeBuilderInstances().UnregisterPlugin(create_callback);1235}1236 1237lldb::RegisterTypeBuilderSP1238PluginManager::GetRegisterTypeBuilder(Target &target) {1239  // We assume that RegisterTypeBuilderClang is the only instance of this plugin1240  // type and is always present.1241  auto instance = GetRegisterTypeBuilderInstances().GetInstanceAtIndex(0);1242  assert(instance);1243  return instance->create_callback(target);1244}1245 1246#pragma mark ScriptInterpreter1247 1248struct ScriptInterpreterInstance1249    : public PluginInstance<ScriptInterpreterCreateInstance> {1250  ScriptInterpreterInstance(llvm::StringRef name, llvm::StringRef description,1251                            CallbackType create_callback,1252                            lldb::ScriptLanguage language)1253      : PluginInstance<ScriptInterpreterCreateInstance>(name, description,1254                                                        create_callback),1255        language(language) {}1256 1257  lldb::ScriptLanguage language = lldb::eScriptLanguageNone;1258};1259 1260typedef PluginInstances<ScriptInterpreterInstance> ScriptInterpreterInstances;1261 1262static ScriptInterpreterInstances &GetScriptInterpreterInstances() {1263  static ScriptInterpreterInstances g_instances;1264  return g_instances;1265}1266 1267bool PluginManager::RegisterPlugin(1268    llvm::StringRef name, llvm::StringRef description,1269    lldb::ScriptLanguage script_language,1270    ScriptInterpreterCreateInstance create_callback) {1271  return GetScriptInterpreterInstances().RegisterPlugin(1272      name, description, create_callback, script_language);1273}1274 1275bool PluginManager::UnregisterPlugin(1276    ScriptInterpreterCreateInstance create_callback) {1277  return GetScriptInterpreterInstances().UnregisterPlugin(create_callback);1278}1279 1280ScriptInterpreterCreateInstance1281PluginManager::GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx) {1282  return GetScriptInterpreterInstances().GetCallbackAtIndex(idx);1283}1284 1285lldb::ScriptInterpreterSP1286PluginManager::GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang,1287                                               Debugger &debugger) {1288  const auto instances = GetScriptInterpreterInstances().GetSnapshot();1289  ScriptInterpreterCreateInstance none_instance = nullptr;1290  for (const auto &instance : instances) {1291    if (instance.language == lldb::eScriptLanguageNone)1292      none_instance = instance.create_callback;1293 1294    if (script_lang == instance.language)1295      return instance.create_callback(debugger);1296  }1297 1298  // If we didn't find one, return the ScriptInterpreter for the null language.1299  assert(none_instance != nullptr);1300  return none_instance(debugger);1301}1302 1303#pragma mark SyntheticFrameProvider1304 1305typedef PluginInstance<SyntheticFrameProviderCreateInstance>1306    SyntheticFrameProviderInstance;1307typedef PluginInstance<ScriptedFrameProviderCreateInstance>1308    ScriptedFrameProviderInstance;1309typedef PluginInstances<SyntheticFrameProviderInstance>1310    SyntheticFrameProviderInstances;1311typedef PluginInstances<ScriptedFrameProviderInstance>1312    ScriptedFrameProviderInstances;1313 1314static SyntheticFrameProviderInstances &GetSyntheticFrameProviderInstances() {1315  static SyntheticFrameProviderInstances g_instances;1316  return g_instances;1317}1318 1319static ScriptedFrameProviderInstances &GetScriptedFrameProviderInstances() {1320  static ScriptedFrameProviderInstances g_instances;1321  return g_instances;1322}1323 1324bool PluginManager::RegisterPlugin(1325    llvm::StringRef name, llvm::StringRef description,1326    SyntheticFrameProviderCreateInstance create_native_callback,1327    ScriptedFrameProviderCreateInstance create_scripted_callback) {1328  if (create_native_callback)1329    return GetSyntheticFrameProviderInstances().RegisterPlugin(1330        name, description, create_native_callback);1331  else if (create_scripted_callback)1332    return GetScriptedFrameProviderInstances().RegisterPlugin(1333        name, description, create_scripted_callback);1334  return false;1335}1336 1337bool PluginManager::UnregisterPlugin(1338    SyntheticFrameProviderCreateInstance create_callback) {1339  return GetSyntheticFrameProviderInstances().UnregisterPlugin(create_callback);1340}1341 1342bool PluginManager::UnregisterPlugin(1343    ScriptedFrameProviderCreateInstance create_callback) {1344  return GetScriptedFrameProviderInstances().UnregisterPlugin(create_callback);1345}1346 1347SyntheticFrameProviderCreateInstance1348PluginManager::GetSyntheticFrameProviderCreateCallbackForPluginName(1349    llvm::StringRef name) {1350  return GetSyntheticFrameProviderInstances().GetCallbackForName(name);1351}1352 1353ScriptedFrameProviderCreateInstance1354PluginManager::GetScriptedFrameProviderCreateCallbackAtIndex(uint32_t idx) {1355  return GetScriptedFrameProviderInstances().GetCallbackAtIndex(idx);1356}1357 1358#pragma mark StructuredDataPlugin1359 1360struct StructuredDataPluginInstance1361    : public PluginInstance<StructuredDataPluginCreateInstance> {1362  StructuredDataPluginInstance(1363      llvm::StringRef name, llvm::StringRef description,1364      CallbackType create_callback,1365      DebuggerInitializeCallback debugger_init_callback,1366      StructuredDataFilterLaunchInfo filter_callback)1367      : PluginInstance<StructuredDataPluginCreateInstance>(1368            name, description, create_callback, debugger_init_callback),1369        filter_callback(filter_callback) {}1370 1371  StructuredDataFilterLaunchInfo filter_callback = nullptr;1372};1373 1374typedef PluginInstances<StructuredDataPluginInstance>1375    StructuredDataPluginInstances;1376 1377static StructuredDataPluginInstances &GetStructuredDataPluginInstances() {1378  static StructuredDataPluginInstances g_instances;1379  return g_instances;1380}1381 1382bool PluginManager::RegisterPlugin(1383    llvm::StringRef name, llvm::StringRef description,1384    StructuredDataPluginCreateInstance create_callback,1385    DebuggerInitializeCallback debugger_init_callback,1386    StructuredDataFilterLaunchInfo filter_callback) {1387  return GetStructuredDataPluginInstances().RegisterPlugin(1388      name, description, create_callback, debugger_init_callback,1389      filter_callback);1390}1391 1392bool PluginManager::UnregisterPlugin(1393    StructuredDataPluginCreateInstance create_callback) {1394  return GetStructuredDataPluginInstances().UnregisterPlugin(create_callback);1395}1396 1397StructuredDataPluginCreateInstance1398PluginManager::GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx) {1399  return GetStructuredDataPluginInstances().GetCallbackAtIndex(idx);1400}1401 1402StructuredDataFilterLaunchInfo1403PluginManager::GetStructuredDataFilterCallbackAtIndex(1404    uint32_t idx, bool &iteration_complete) {1405  if (auto instance =1406          GetStructuredDataPluginInstances().GetInstanceAtIndex(idx)) {1407    iteration_complete = false;1408    return instance->filter_callback;1409  }1410  iteration_complete = true;1411  return nullptr;1412}1413 1414#pragma mark SymbolFile1415 1416typedef PluginInstance<SymbolFileCreateInstance> SymbolFileInstance;1417typedef PluginInstances<SymbolFileInstance> SymbolFileInstances;1418 1419static SymbolFileInstances &GetSymbolFileInstances() {1420  static SymbolFileInstances g_instances;1421  return g_instances;1422}1423 1424bool PluginManager::RegisterPlugin(1425    llvm::StringRef name, llvm::StringRef description,1426    SymbolFileCreateInstance create_callback,1427    DebuggerInitializeCallback debugger_init_callback) {1428  return GetSymbolFileInstances().RegisterPlugin(1429      name, description, create_callback, debugger_init_callback);1430}1431 1432bool PluginManager::UnregisterPlugin(SymbolFileCreateInstance create_callback) {1433  return GetSymbolFileInstances().UnregisterPlugin(create_callback);1434}1435 1436SymbolFileCreateInstance1437PluginManager::GetSymbolFileCreateCallbackAtIndex(uint32_t idx) {1438  return GetSymbolFileInstances().GetCallbackAtIndex(idx);1439}1440 1441#pragma mark SymbolVendor1442 1443typedef PluginInstance<SymbolVendorCreateInstance> SymbolVendorInstance;1444typedef PluginInstances<SymbolVendorInstance> SymbolVendorInstances;1445 1446static SymbolVendorInstances &GetSymbolVendorInstances() {1447  static SymbolVendorInstances g_instances;1448  return g_instances;1449}1450 1451bool PluginManager::RegisterPlugin(llvm::StringRef name,1452                                   llvm::StringRef description,1453                                   SymbolVendorCreateInstance create_callback) {1454  return GetSymbolVendorInstances().RegisterPlugin(name, description,1455                                                   create_callback);1456}1457 1458bool PluginManager::UnregisterPlugin(1459    SymbolVendorCreateInstance create_callback) {1460  return GetSymbolVendorInstances().UnregisterPlugin(create_callback);1461}1462 1463SymbolVendorCreateInstance1464PluginManager::GetSymbolVendorCreateCallbackAtIndex(uint32_t idx) {1465  return GetSymbolVendorInstances().GetCallbackAtIndex(idx);1466}1467 1468#pragma mark SymbolLocator1469 1470struct SymbolLocatorInstance1471    : public PluginInstance<SymbolLocatorCreateInstance> {1472  SymbolLocatorInstance(1473      llvm::StringRef name, llvm::StringRef description,1474      CallbackType create_callback,1475      SymbolLocatorLocateExecutableObjectFile locate_executable_object_file,1476      SymbolLocatorLocateExecutableSymbolFile locate_executable_symbol_file,1477      SymbolLocatorDownloadObjectAndSymbolFile download_object_symbol_file,1478      SymbolLocatorFindSymbolFileInBundle find_symbol_file_in_bundle,1479      DebuggerInitializeCallback debugger_init_callback)1480      : PluginInstance<SymbolLocatorCreateInstance>(1481            name, description, create_callback, debugger_init_callback),1482        locate_executable_object_file(locate_executable_object_file),1483        locate_executable_symbol_file(locate_executable_symbol_file),1484        download_object_symbol_file(download_object_symbol_file),1485        find_symbol_file_in_bundle(find_symbol_file_in_bundle) {}1486 1487  SymbolLocatorLocateExecutableObjectFile locate_executable_object_file;1488  SymbolLocatorLocateExecutableSymbolFile locate_executable_symbol_file;1489  SymbolLocatorDownloadObjectAndSymbolFile download_object_symbol_file;1490  SymbolLocatorFindSymbolFileInBundle find_symbol_file_in_bundle;1491};1492typedef PluginInstances<SymbolLocatorInstance> SymbolLocatorInstances;1493 1494static SymbolLocatorInstances &GetSymbolLocatorInstances() {1495  static SymbolLocatorInstances g_instances;1496  return g_instances;1497}1498 1499bool PluginManager::RegisterPlugin(1500    llvm::StringRef name, llvm::StringRef description,1501    SymbolLocatorCreateInstance create_callback,1502    SymbolLocatorLocateExecutableObjectFile locate_executable_object_file,1503    SymbolLocatorLocateExecutableSymbolFile locate_executable_symbol_file,1504    SymbolLocatorDownloadObjectAndSymbolFile download_object_symbol_file,1505    SymbolLocatorFindSymbolFileInBundle find_symbol_file_in_bundle,1506    DebuggerInitializeCallback debugger_init_callback) {1507  return GetSymbolLocatorInstances().RegisterPlugin(1508      name, description, create_callback, locate_executable_object_file,1509      locate_executable_symbol_file, download_object_symbol_file,1510      find_symbol_file_in_bundle, debugger_init_callback);1511}1512 1513bool PluginManager::UnregisterPlugin(1514    SymbolLocatorCreateInstance create_callback) {1515  return GetSymbolLocatorInstances().UnregisterPlugin(create_callback);1516}1517 1518SymbolLocatorCreateInstance1519PluginManager::GetSymbolLocatorCreateCallbackAtIndex(uint32_t idx) {1520  return GetSymbolLocatorInstances().GetCallbackAtIndex(idx);1521}1522 1523ModuleSpec1524PluginManager::LocateExecutableObjectFile(const ModuleSpec &module_spec,1525                                          StatisticsMap &map) {1526  auto instances = GetSymbolLocatorInstances().GetSnapshot();1527  for (auto &instance : instances) {1528    if (instance.locate_executable_object_file) {1529      StatsDuration time;1530      std::optional<ModuleSpec> result;1531      {1532        ElapsedTime elapsed(time);1533        result = instance.locate_executable_object_file(module_spec);1534      }1535      map.add(instance.name, time.get().count());1536      if (result)1537        return *result;1538    }1539  }1540  return {};1541}1542 1543FileSpec PluginManager::LocateExecutableSymbolFile(1544    const ModuleSpec &module_spec, const FileSpecList &default_search_paths,1545    StatisticsMap &map) {1546  auto instances = GetSymbolLocatorInstances().GetSnapshot();1547  for (auto &instance : instances) {1548    if (instance.locate_executable_symbol_file) {1549      StatsDuration time;1550      std::optional<FileSpec> result;1551      {1552        ElapsedTime elapsed(time);1553        result = instance.locate_executable_symbol_file(module_spec,1554                                                        default_search_paths);1555      }1556      map.add(instance.name, time.get().count());1557      if (result)1558        return *result;1559    }1560  }1561  return {};1562}1563 1564bool PluginManager::DownloadObjectAndSymbolFile(ModuleSpec &module_spec,1565                                                Status &error,1566                                                bool force_lookup,1567                                                bool copy_executable) {1568  auto instances = GetSymbolLocatorInstances().GetSnapshot();1569  for (auto &instance : instances) {1570    if (instance.download_object_symbol_file) {1571      if (instance.download_object_symbol_file(module_spec, error, force_lookup,1572                                               copy_executable))1573        return true;1574    }1575  }1576  return false;1577}1578 1579FileSpec PluginManager::FindSymbolFileInBundle(const FileSpec &symfile_bundle,1580                                               const UUID *uuid,1581                                               const ArchSpec *arch) {1582  auto instances = GetSymbolLocatorInstances().GetSnapshot();1583  for (auto &instance : instances) {1584    if (instance.find_symbol_file_in_bundle) {1585      std::optional<FileSpec> result =1586          instance.find_symbol_file_in_bundle(symfile_bundle, uuid, arch);1587      if (result)1588        return *result;1589    }1590  }1591  return {};1592}1593 1594#pragma mark Trace1595 1596struct TraceInstance1597    : public PluginInstance<TraceCreateInstanceFromBundle> {1598  TraceInstance(1599      llvm::StringRef name, llvm::StringRef description,1600      CallbackType create_callback_from_bundle,1601      TraceCreateInstanceForLiveProcess create_callback_for_live_process,1602      llvm::StringRef schema, DebuggerInitializeCallback debugger_init_callback)1603      : PluginInstance<TraceCreateInstanceFromBundle>(1604            name, description, create_callback_from_bundle,1605            debugger_init_callback),1606        schema(schema),1607        create_callback_for_live_process(create_callback_for_live_process) {}1608 1609  llvm::StringRef schema;1610  TraceCreateInstanceForLiveProcess create_callback_for_live_process;1611};1612 1613typedef PluginInstances<TraceInstance> TraceInstances;1614 1615static TraceInstances &GetTracePluginInstances() {1616  static TraceInstances g_instances;1617  return g_instances;1618}1619 1620bool PluginManager::RegisterPlugin(1621    llvm::StringRef name, llvm::StringRef description,1622    TraceCreateInstanceFromBundle create_callback_from_bundle,1623    TraceCreateInstanceForLiveProcess create_callback_for_live_process,1624    llvm::StringRef schema, DebuggerInitializeCallback debugger_init_callback) {1625  return GetTracePluginInstances().RegisterPlugin(1626      name, description, create_callback_from_bundle,1627      create_callback_for_live_process, schema, debugger_init_callback);1628}1629 1630bool PluginManager::UnregisterPlugin(1631    TraceCreateInstanceFromBundle create_callback_from_bundle) {1632  return GetTracePluginInstances().UnregisterPlugin(1633      create_callback_from_bundle);1634}1635 1636TraceCreateInstanceFromBundle1637PluginManager::GetTraceCreateCallback(llvm::StringRef plugin_name) {1638  return GetTracePluginInstances().GetCallbackForName(plugin_name);1639}1640 1641TraceCreateInstanceForLiveProcess1642PluginManager::GetTraceCreateCallbackForLiveProcess(llvm::StringRef plugin_name) {1643  if (auto instance = GetTracePluginInstances().GetInstanceForName(plugin_name))1644    return instance->create_callback_for_live_process;1645 1646  return nullptr;1647}1648 1649llvm::StringRef PluginManager::GetTraceSchema(llvm::StringRef plugin_name) {1650  if (auto instance = GetTracePluginInstances().GetInstanceForName(plugin_name))1651    return instance->schema;1652  return llvm::StringRef();1653}1654 1655llvm::StringRef PluginManager::GetTraceSchema(size_t index) {1656  if (const TraceInstance *instance =1657          GetTracePluginInstances().GetInstanceAtIndex(index))1658    return instance->schema;1659  return llvm::StringRef();1660}1661 1662#pragma mark TraceExporter1663 1664struct TraceExporterInstance1665    : public PluginInstance<TraceExporterCreateInstance> {1666  TraceExporterInstance(1667      llvm::StringRef name, llvm::StringRef description,1668      TraceExporterCreateInstance create_instance,1669      ThreadTraceExportCommandCreator create_thread_trace_export_command)1670      : PluginInstance<TraceExporterCreateInstance>(name, description,1671                                                    create_instance),1672        create_thread_trace_export_command(create_thread_trace_export_command) {1673  }1674 1675  ThreadTraceExportCommandCreator create_thread_trace_export_command;1676};1677 1678typedef PluginInstances<TraceExporterInstance> TraceExporterInstances;1679 1680static TraceExporterInstances &GetTraceExporterInstances() {1681  static TraceExporterInstances g_instances;1682  return g_instances;1683}1684 1685bool PluginManager::RegisterPlugin(1686    llvm::StringRef name, llvm::StringRef description,1687    TraceExporterCreateInstance create_callback,1688    ThreadTraceExportCommandCreator create_thread_trace_export_command) {1689  return GetTraceExporterInstances().RegisterPlugin(1690      name, description, create_callback, create_thread_trace_export_command);1691}1692 1693TraceExporterCreateInstance1694PluginManager::GetTraceExporterCreateCallback(llvm::StringRef plugin_name) {1695  return GetTraceExporterInstances().GetCallbackForName(plugin_name);1696}1697 1698bool PluginManager::UnregisterPlugin(1699    TraceExporterCreateInstance create_callback) {1700  return GetTraceExporterInstances().UnregisterPlugin(create_callback);1701}1702 1703ThreadTraceExportCommandCreator1704PluginManager::GetThreadTraceExportCommandCreatorAtIndex(uint32_t index) {1705  if (const TraceExporterInstance *instance =1706          GetTraceExporterInstances().GetInstanceAtIndex(index))1707    return instance->create_thread_trace_export_command;1708  return nullptr;1709}1710 1711llvm::StringRef1712PluginManager::GetTraceExporterPluginNameAtIndex(uint32_t index) {1713  return GetTraceExporterInstances().GetNameAtIndex(index);1714}1715 1716#pragma mark UnwindAssembly1717 1718typedef PluginInstance<UnwindAssemblyCreateInstance> UnwindAssemblyInstance;1719typedef PluginInstances<UnwindAssemblyInstance> UnwindAssemblyInstances;1720 1721static UnwindAssemblyInstances &GetUnwindAssemblyInstances() {1722  static UnwindAssemblyInstances g_instances;1723  return g_instances;1724}1725 1726bool PluginManager::RegisterPlugin(1727    llvm::StringRef name, llvm::StringRef description,1728    UnwindAssemblyCreateInstance create_callback) {1729  return GetUnwindAssemblyInstances().RegisterPlugin(name, description,1730                                                     create_callback);1731}1732 1733bool PluginManager::UnregisterPlugin(1734    UnwindAssemblyCreateInstance create_callback) {1735  return GetUnwindAssemblyInstances().UnregisterPlugin(create_callback);1736}1737 1738UnwindAssemblyCreateInstance1739PluginManager::GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx) {1740  return GetUnwindAssemblyInstances().GetCallbackAtIndex(idx);1741}1742 1743#pragma mark MemoryHistory1744 1745typedef PluginInstance<MemoryHistoryCreateInstance> MemoryHistoryInstance;1746typedef PluginInstances<MemoryHistoryInstance> MemoryHistoryInstances;1747 1748static MemoryHistoryInstances &GetMemoryHistoryInstances() {1749  static MemoryHistoryInstances g_instances;1750  return g_instances;1751}1752 1753bool PluginManager::RegisterPlugin(1754    llvm::StringRef name, llvm::StringRef description,1755    MemoryHistoryCreateInstance create_callback) {1756  return GetMemoryHistoryInstances().RegisterPlugin(name, description,1757                                                    create_callback);1758}1759 1760bool PluginManager::UnregisterPlugin(1761    MemoryHistoryCreateInstance create_callback) {1762  return GetMemoryHistoryInstances().UnregisterPlugin(create_callback);1763}1764 1765MemoryHistoryCreateInstance1766PluginManager::GetMemoryHistoryCreateCallbackAtIndex(uint32_t idx) {1767  return GetMemoryHistoryInstances().GetCallbackAtIndex(idx);1768}1769 1770#pragma mark InstrumentationRuntime1771 1772struct InstrumentationRuntimeInstance1773    : public PluginInstance<InstrumentationRuntimeCreateInstance> {1774  InstrumentationRuntimeInstance(1775      llvm::StringRef name, llvm::StringRef description,1776      CallbackType create_callback,1777      InstrumentationRuntimeGetType get_type_callback)1778      : PluginInstance<InstrumentationRuntimeCreateInstance>(name, description,1779                                                             create_callback),1780        get_type_callback(get_type_callback) {}1781 1782  InstrumentationRuntimeGetType get_type_callback = nullptr;1783};1784 1785typedef PluginInstances<InstrumentationRuntimeInstance>1786    InstrumentationRuntimeInstances;1787 1788static InstrumentationRuntimeInstances &GetInstrumentationRuntimeInstances() {1789  static InstrumentationRuntimeInstances g_instances;1790  return g_instances;1791}1792 1793bool PluginManager::RegisterPlugin(1794    llvm::StringRef name, llvm::StringRef description,1795    InstrumentationRuntimeCreateInstance create_callback,1796    InstrumentationRuntimeGetType get_type_callback) {1797  return GetInstrumentationRuntimeInstances().RegisterPlugin(1798      name, description, create_callback, get_type_callback);1799}1800 1801bool PluginManager::UnregisterPlugin(1802    InstrumentationRuntimeCreateInstance create_callback) {1803  return GetInstrumentationRuntimeInstances().UnregisterPlugin(create_callback);1804}1805 1806InstrumentationRuntimeGetType1807PluginManager::GetInstrumentationRuntimeGetTypeCallbackAtIndex(uint32_t idx) {1808  if (auto instance =1809          GetInstrumentationRuntimeInstances().GetInstanceAtIndex(idx))1810    return instance->get_type_callback;1811  return nullptr;1812}1813 1814InstrumentationRuntimeCreateInstance1815PluginManager::GetInstrumentationRuntimeCreateCallbackAtIndex(uint32_t idx) {1816  return GetInstrumentationRuntimeInstances().GetCallbackAtIndex(idx);1817}1818 1819#pragma mark TypeSystem1820 1821struct TypeSystemInstance : public PluginInstance<TypeSystemCreateInstance> {1822  TypeSystemInstance(llvm::StringRef name, llvm::StringRef description,1823                     CallbackType create_callback,1824                     LanguageSet supported_languages_for_types,1825                     LanguageSet supported_languages_for_expressions)1826      : PluginInstance<TypeSystemCreateInstance>(name, description,1827                                                 create_callback),1828        supported_languages_for_types(supported_languages_for_types),1829        supported_languages_for_expressions(1830            supported_languages_for_expressions) {}1831 1832  LanguageSet supported_languages_for_types;1833  LanguageSet supported_languages_for_expressions;1834};1835 1836typedef PluginInstances<TypeSystemInstance> TypeSystemInstances;1837 1838static TypeSystemInstances &GetTypeSystemInstances() {1839  static TypeSystemInstances g_instances;1840  return g_instances;1841}1842 1843bool PluginManager::RegisterPlugin(1844    llvm::StringRef name, llvm::StringRef description,1845    TypeSystemCreateInstance create_callback,1846    LanguageSet supported_languages_for_types,1847    LanguageSet supported_languages_for_expressions) {1848  return GetTypeSystemInstances().RegisterPlugin(1849      name, description, create_callback, supported_languages_for_types,1850      supported_languages_for_expressions);1851}1852 1853bool PluginManager::UnregisterPlugin(TypeSystemCreateInstance create_callback) {1854  return GetTypeSystemInstances().UnregisterPlugin(create_callback);1855}1856 1857TypeSystemCreateInstance1858PluginManager::GetTypeSystemCreateCallbackAtIndex(uint32_t idx) {1859  return GetTypeSystemInstances().GetCallbackAtIndex(idx);1860}1861 1862LanguageSet PluginManager::GetAllTypeSystemSupportedLanguagesForTypes() {1863  const auto instances = GetTypeSystemInstances().GetSnapshot();1864  LanguageSet all;1865  for (unsigned i = 0; i < instances.size(); ++i)1866    all.bitvector |= instances[i].supported_languages_for_types.bitvector;1867  return all;1868}1869 1870LanguageSet PluginManager::GetAllTypeSystemSupportedLanguagesForExpressions() {1871  const auto instances = GetTypeSystemInstances().GetSnapshot();1872  LanguageSet all;1873  for (unsigned i = 0; i < instances.size(); ++i)1874    all.bitvector |= instances[i].supported_languages_for_expressions.bitvector;1875  return all;1876}1877 1878#pragma mark ScriptedInterfaces1879 1880struct ScriptedInterfaceInstance1881    : public PluginInstance<ScriptedInterfaceCreateInstance> {1882  ScriptedInterfaceInstance(llvm::StringRef name, llvm::StringRef description,1883                            ScriptedInterfaceCreateInstance create_callback,1884                            lldb::ScriptLanguage language,1885                            ScriptedInterfaceUsages usages)1886      : PluginInstance<ScriptedInterfaceCreateInstance>(name, description,1887                                                        create_callback),1888        language(language), usages(usages) {}1889 1890  lldb::ScriptLanguage language;1891  ScriptedInterfaceUsages usages;1892};1893 1894typedef PluginInstances<ScriptedInterfaceInstance> ScriptedInterfaceInstances;1895 1896static ScriptedInterfaceInstances &GetScriptedInterfaceInstances() {1897  static ScriptedInterfaceInstances g_instances;1898  return g_instances;1899}1900 1901bool PluginManager::RegisterPlugin(1902    llvm::StringRef name, llvm::StringRef description,1903    ScriptedInterfaceCreateInstance create_callback,1904    lldb::ScriptLanguage language, ScriptedInterfaceUsages usages) {1905  return GetScriptedInterfaceInstances().RegisterPlugin(1906      name, description, create_callback, language, usages);1907}1908 1909bool PluginManager::UnregisterPlugin(1910    ScriptedInterfaceCreateInstance create_callback) {1911  return GetScriptedInterfaceInstances().UnregisterPlugin(create_callback);1912}1913 1914uint32_t PluginManager::GetNumScriptedInterfaces() {1915  return GetScriptedInterfaceInstances().GetSnapshot().size();1916}1917 1918llvm::StringRef PluginManager::GetScriptedInterfaceNameAtIndex(uint32_t index) {1919  return GetScriptedInterfaceInstances().GetNameAtIndex(index);1920}1921 1922llvm::StringRef1923PluginManager::GetScriptedInterfaceDescriptionAtIndex(uint32_t index) {1924  return GetScriptedInterfaceInstances().GetDescriptionAtIndex(index);1925}1926 1927lldb::ScriptLanguage1928PluginManager::GetScriptedInterfaceLanguageAtIndex(uint32_t idx) {1929  if (auto instance = GetScriptedInterfaceInstances().GetInstanceAtIndex(idx))1930    return instance->language;1931  return ScriptLanguage::eScriptLanguageNone;1932}1933 1934ScriptedInterfaceUsages1935PluginManager::GetScriptedInterfaceUsagesAtIndex(uint32_t idx) {1936  if (auto instance = GetScriptedInterfaceInstances().GetInstanceAtIndex(idx))1937    return instance->usages;1938  return {};1939}1940 1941#pragma mark REPL1942 1943struct REPLInstance : public PluginInstance<REPLCreateInstance> {1944  REPLInstance(llvm::StringRef name, llvm::StringRef description,1945               CallbackType create_callback, LanguageSet supported_languages)1946      : PluginInstance<REPLCreateInstance>(name, description, create_callback),1947        supported_languages(supported_languages) {}1948 1949  LanguageSet supported_languages;1950};1951 1952typedef PluginInstances<REPLInstance> REPLInstances;1953 1954static REPLInstances &GetREPLInstances() {1955  static REPLInstances g_instances;1956  return g_instances;1957}1958 1959bool PluginManager::RegisterPlugin(llvm::StringRef name, llvm::StringRef description,1960                                   REPLCreateInstance create_callback,1961                                   LanguageSet supported_languages) {1962  return GetREPLInstances().RegisterPlugin(name, description, create_callback,1963                                           supported_languages);1964}1965 1966bool PluginManager::UnregisterPlugin(REPLCreateInstance create_callback) {1967  return GetREPLInstances().UnregisterPlugin(create_callback);1968}1969 1970REPLCreateInstance PluginManager::GetREPLCreateCallbackAtIndex(uint32_t idx) {1971  return GetREPLInstances().GetCallbackAtIndex(idx);1972}1973 1974LanguageSet PluginManager::GetREPLSupportedLanguagesAtIndex(uint32_t idx) {1975  if (auto instance = GetREPLInstances().GetInstanceAtIndex(idx))1976    return instance->supported_languages;1977  return LanguageSet();1978}1979 1980LanguageSet PluginManager::GetREPLAllTypeSystemSupportedLanguages() {1981  const auto instances = GetREPLInstances().GetSnapshot();1982  LanguageSet all;1983  for (unsigned i = 0; i < instances.size(); ++i)1984    all.bitvector |= instances[i].supported_languages.bitvector;1985  return all;1986}1987 1988#pragma mark PluginManager1989 1990void PluginManager::DebuggerInitialize(Debugger &debugger) {1991  GetDynamicLoaderInstances().PerformDebuggerCallback(debugger);1992  GetJITLoaderInstances().PerformDebuggerCallback(debugger);1993  GetObjectFileInstances().PerformDebuggerCallback(debugger);1994  GetPlatformInstances().PerformDebuggerCallback(debugger);1995  GetProcessInstances().PerformDebuggerCallback(debugger);1996  GetSymbolFileInstances().PerformDebuggerCallback(debugger);1997  GetSymbolLocatorInstances().PerformDebuggerCallback(debugger);1998  GetOperatingSystemInstances().PerformDebuggerCallback(debugger);1999  GetStructuredDataPluginInstances().PerformDebuggerCallback(debugger);2000  GetTracePluginInstances().PerformDebuggerCallback(debugger);2001  GetScriptedInterfaceInstances().PerformDebuggerCallback(debugger);2002  GetLanguageInstances().PerformDebuggerCallback(debugger);2003}2004 2005// This is the preferred new way to register plugin specific settings.  e.g.2006// This will put a plugin's settings under e.g.2007// "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".2008static lldb::OptionValuePropertiesSP2009GetDebuggerPropertyForPlugins(Debugger &debugger, llvm::StringRef plugin_type_name,2010                              llvm::StringRef plugin_type_desc,2011                              bool can_create) {2012  lldb::OptionValuePropertiesSP parent_properties_sp(2013      debugger.GetValueProperties());2014  if (parent_properties_sp) {2015    static constexpr llvm::StringLiteral g_property_name("plugin");2016 2017    OptionValuePropertiesSP plugin_properties_sp =2018        parent_properties_sp->GetSubProperty(nullptr, g_property_name);2019    if (!plugin_properties_sp && can_create) {2020      plugin_properties_sp =2021          std::make_shared<OptionValueProperties>(g_property_name);2022      parent_properties_sp->AppendProperty(g_property_name,2023                                           "Settings specify to plugins.", true,2024                                           plugin_properties_sp);2025    }2026 2027    if (plugin_properties_sp) {2028      lldb::OptionValuePropertiesSP plugin_type_properties_sp =2029          plugin_properties_sp->GetSubProperty(nullptr, plugin_type_name);2030      if (!plugin_type_properties_sp && can_create) {2031        plugin_type_properties_sp =2032            std::make_shared<OptionValueProperties>(plugin_type_name);2033        plugin_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,2034                                             true, plugin_type_properties_sp);2035      }2036      return plugin_type_properties_sp;2037    }2038  }2039  return lldb::OptionValuePropertiesSP();2040}2041 2042// This is deprecated way to register plugin specific settings.  e.g.2043// "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME" and Platform2044// generic settings would be under "platform.SETTINGNAME".2045static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle(2046    Debugger &debugger, llvm::StringRef plugin_type_name,2047    llvm::StringRef plugin_type_desc, bool can_create) {2048  static constexpr llvm::StringLiteral g_property_name("plugin");2049  lldb::OptionValuePropertiesSP parent_properties_sp(2050      debugger.GetValueProperties());2051  if (parent_properties_sp) {2052    OptionValuePropertiesSP plugin_properties_sp =2053        parent_properties_sp->GetSubProperty(nullptr, plugin_type_name);2054    if (!plugin_properties_sp && can_create) {2055      plugin_properties_sp =2056          std::make_shared<OptionValueProperties>(plugin_type_name);2057      parent_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,2058                                           true, plugin_properties_sp);2059    }2060 2061    if (plugin_properties_sp) {2062      lldb::OptionValuePropertiesSP plugin_type_properties_sp =2063          plugin_properties_sp->GetSubProperty(nullptr, g_property_name);2064      if (!plugin_type_properties_sp && can_create) {2065        plugin_type_properties_sp =2066            std::make_shared<OptionValueProperties>(g_property_name);2067        plugin_properties_sp->AppendProperty(g_property_name,2068                                             "Settings specific to plugins",2069                                             true, plugin_type_properties_sp);2070      }2071      return plugin_type_properties_sp;2072    }2073  }2074  return lldb::OptionValuePropertiesSP();2075}2076 2077namespace {2078 2079typedef lldb::OptionValuePropertiesSP2080GetDebuggerPropertyForPluginsPtr(Debugger &, llvm::StringRef, llvm::StringRef,2081                                 bool can_create);2082}2083 2084static lldb::OptionValuePropertiesSP2085GetSettingForPlugin(Debugger &debugger, llvm::StringRef setting_name,2086                    llvm::StringRef plugin_type_name,2087                    GetDebuggerPropertyForPluginsPtr get_debugger_property =2088                        GetDebuggerPropertyForPlugins) {2089  lldb::OptionValuePropertiesSP properties_sp;2090  lldb::OptionValuePropertiesSP plugin_type_properties_sp(get_debugger_property(2091      debugger, plugin_type_name,2092      "", // not creating to so we don't need the description2093      false));2094  if (plugin_type_properties_sp)2095    properties_sp =2096        plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);2097  return properties_sp;2098}2099 2100static bool2101CreateSettingForPlugin(Debugger &debugger, llvm::StringRef plugin_type_name,2102                       llvm::StringRef plugin_type_desc,2103                       const lldb::OptionValuePropertiesSP &properties_sp,2104                       llvm::StringRef description, bool is_global_property,2105                       GetDebuggerPropertyForPluginsPtr get_debugger_property =2106                           GetDebuggerPropertyForPlugins) {2107  if (properties_sp) {2108    lldb::OptionValuePropertiesSP plugin_type_properties_sp(2109        get_debugger_property(debugger, plugin_type_name, plugin_type_desc,2110                              true));2111    if (plugin_type_properties_sp) {2112      plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),2113                                                description, is_global_property,2114                                                properties_sp);2115      return true;2116    }2117  }2118  return false;2119}2120 2121static constexpr llvm::StringLiteral kDynamicLoaderPluginName("dynamic-loader");2122static constexpr llvm::StringLiteral kPlatformPluginName("platform");2123static constexpr llvm::StringLiteral kProcessPluginName("process");2124static constexpr llvm::StringLiteral kTracePluginName("trace");2125static constexpr llvm::StringLiteral kObjectFilePluginName("object-file");2126static constexpr llvm::StringLiteral kSymbolFilePluginName("symbol-file");2127static constexpr llvm::StringLiteral kSymbolLocatorPluginName("symbol-locator");2128static constexpr llvm::StringLiteral kJITLoaderPluginName("jit-loader");2129static constexpr llvm::StringLiteral2130    kStructuredDataPluginName("structured-data");2131static constexpr llvm::StringLiteral kCPlusPlusLanguagePlugin("cplusplus");2132 2133lldb::OptionValuePropertiesSP2134PluginManager::GetSettingForDynamicLoaderPlugin(Debugger &debugger,2135                                                llvm::StringRef setting_name) {2136  return GetSettingForPlugin(debugger, setting_name, kDynamicLoaderPluginName);2137}2138 2139bool PluginManager::CreateSettingForDynamicLoaderPlugin(2140    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2141    llvm::StringRef description, bool is_global_property) {2142  return CreateSettingForPlugin(debugger, kDynamicLoaderPluginName,2143                                "Settings for dynamic loader plug-ins",2144                                properties_sp, description, is_global_property);2145}2146 2147lldb::OptionValuePropertiesSP2148PluginManager::GetSettingForPlatformPlugin(Debugger &debugger,2149                                           llvm::StringRef setting_name) {2150  return GetSettingForPlugin(debugger, setting_name, kPlatformPluginName,2151                             GetDebuggerPropertyForPluginsOldStyle);2152}2153 2154bool PluginManager::CreateSettingForPlatformPlugin(2155    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2156    llvm::StringRef description, bool is_global_property) {2157  return CreateSettingForPlugin(debugger, kPlatformPluginName,2158                                "Settings for platform plug-ins", properties_sp,2159                                description, is_global_property,2160                                GetDebuggerPropertyForPluginsOldStyle);2161}2162 2163lldb::OptionValuePropertiesSP2164PluginManager::GetSettingForProcessPlugin(Debugger &debugger,2165                                          llvm::StringRef setting_name) {2166  return GetSettingForPlugin(debugger, setting_name, kProcessPluginName);2167}2168 2169bool PluginManager::CreateSettingForProcessPlugin(2170    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2171    llvm::StringRef description, bool is_global_property) {2172  return CreateSettingForPlugin(debugger, kProcessPluginName,2173                                "Settings for process plug-ins", properties_sp,2174                                description, is_global_property);2175}2176 2177lldb::OptionValuePropertiesSP2178PluginManager::GetSettingForSymbolLocatorPlugin(Debugger &debugger,2179                                                llvm::StringRef setting_name) {2180  return GetSettingForPlugin(debugger, setting_name, kSymbolLocatorPluginName);2181}2182 2183bool PluginManager::CreateSettingForSymbolLocatorPlugin(2184    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2185    llvm::StringRef description, bool is_global_property) {2186  return CreateSettingForPlugin(debugger, kSymbolLocatorPluginName,2187                                "Settings for symbol locator plug-ins",2188                                properties_sp, description, is_global_property);2189}2190 2191bool PluginManager::CreateSettingForTracePlugin(2192    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2193    llvm::StringRef description, bool is_global_property) {2194  return CreateSettingForPlugin(debugger, kTracePluginName,2195                                "Settings for trace plug-ins", properties_sp,2196                                description, is_global_property);2197}2198 2199lldb::OptionValuePropertiesSP2200PluginManager::GetSettingForObjectFilePlugin(Debugger &debugger,2201                                             llvm::StringRef setting_name) {2202  return GetSettingForPlugin(debugger, setting_name, kObjectFilePluginName);2203}2204 2205bool PluginManager::CreateSettingForObjectFilePlugin(2206    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2207    llvm::StringRef description, bool is_global_property) {2208  return CreateSettingForPlugin(debugger, kObjectFilePluginName,2209                                "Settings for object file plug-ins",2210                                properties_sp, description, is_global_property);2211}2212 2213lldb::OptionValuePropertiesSP2214PluginManager::GetSettingForSymbolFilePlugin(Debugger &debugger,2215                                             llvm::StringRef setting_name) {2216  return GetSettingForPlugin(debugger, setting_name, kSymbolFilePluginName);2217}2218 2219bool PluginManager::CreateSettingForSymbolFilePlugin(2220    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2221    llvm::StringRef description, bool is_global_property) {2222  return CreateSettingForPlugin(debugger, kSymbolFilePluginName,2223                                "Settings for symbol file plug-ins",2224                                properties_sp, description, is_global_property);2225}2226 2227lldb::OptionValuePropertiesSP2228PluginManager::GetSettingForJITLoaderPlugin(Debugger &debugger,2229                                            llvm::StringRef setting_name) {2230  return GetSettingForPlugin(debugger, setting_name, kJITLoaderPluginName);2231}2232 2233bool PluginManager::CreateSettingForJITLoaderPlugin(2234    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2235    llvm::StringRef description, bool is_global_property) {2236  return CreateSettingForPlugin(debugger, kJITLoaderPluginName,2237                                "Settings for JIT loader plug-ins",2238                                properties_sp, description, is_global_property);2239}2240 2241static const char *kOperatingSystemPluginName("os");2242 2243lldb::OptionValuePropertiesSP2244PluginManager::GetSettingForOperatingSystemPlugin(Debugger &debugger,2245                                                  llvm::StringRef setting_name) {2246  lldb::OptionValuePropertiesSP properties_sp;2247  lldb::OptionValuePropertiesSP plugin_type_properties_sp(2248      GetDebuggerPropertyForPlugins(2249          debugger, kOperatingSystemPluginName,2250          "", // not creating to so we don't need the description2251          false));2252  if (plugin_type_properties_sp)2253    properties_sp =2254        plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);2255  return properties_sp;2256}2257 2258bool PluginManager::CreateSettingForOperatingSystemPlugin(2259    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2260    llvm::StringRef description, bool is_global_property) {2261  if (properties_sp) {2262    lldb::OptionValuePropertiesSP plugin_type_properties_sp(2263        GetDebuggerPropertyForPlugins(debugger, kOperatingSystemPluginName,2264                                      "Settings for operating system plug-ins",2265                                      true));2266    if (plugin_type_properties_sp) {2267      plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),2268                                                description, is_global_property,2269                                                properties_sp);2270      return true;2271    }2272  }2273  return false;2274}2275 2276lldb::OptionValuePropertiesSP2277PluginManager::GetSettingForStructuredDataPlugin(Debugger &debugger,2278                                                 llvm::StringRef setting_name) {2279  return GetSettingForPlugin(debugger, setting_name, kStructuredDataPluginName);2280}2281 2282bool PluginManager::CreateSettingForStructuredDataPlugin(2283    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2284    llvm::StringRef description, bool is_global_property) {2285  return CreateSettingForPlugin(debugger, kStructuredDataPluginName,2286                                "Settings for structured data plug-ins",2287                                properties_sp, description, is_global_property);2288}2289 2290lldb::OptionValuePropertiesSP2291PluginManager::GetSettingForCPlusPlusLanguagePlugin(2292    Debugger &debugger, llvm::StringRef setting_name) {2293  return GetSettingForPlugin(debugger, setting_name, kCPlusPlusLanguagePlugin);2294}2295 2296bool PluginManager::CreateSettingForCPlusPlusLanguagePlugin(2297    Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,2298    llvm::StringRef description, bool is_global_property) {2299  return CreateSettingForPlugin(debugger, kCPlusPlusLanguagePlugin,2300                                "Settings for CPlusPlus language plug-ins",2301                                properties_sp, description, is_global_property);2302}2303 2304//2305// Plugin Info+Enable Implementations2306//2307std::vector<RegisteredPluginInfo> PluginManager::GetABIPluginInfo() {2308  return GetABIInstances().GetPluginInfoForAllInstances();2309}2310bool PluginManager::SetABIPluginEnabled(llvm::StringRef name, bool enable) {2311  return GetABIInstances().SetInstanceEnabled(name, enable);2312}2313 2314std::vector<RegisteredPluginInfo> PluginManager::GetArchitecturePluginInfo() {2315  return GetArchitectureInstances().GetPluginInfoForAllInstances();2316}2317bool PluginManager::SetArchitecturePluginEnabled(llvm::StringRef name,2318                                                 bool enable) {2319  return GetArchitectureInstances().SetInstanceEnabled(name, enable);2320}2321 2322std::vector<RegisteredPluginInfo> PluginManager::GetDisassemblerPluginInfo() {2323  return GetDisassemblerInstances().GetPluginInfoForAllInstances();2324}2325bool PluginManager::SetDisassemblerPluginEnabled(llvm::StringRef name,2326                                                 bool enable) {2327  return GetDisassemblerInstances().SetInstanceEnabled(name, enable);2328}2329 2330std::vector<RegisteredPluginInfo> PluginManager::GetDynamicLoaderPluginInfo() {2331  return GetDynamicLoaderInstances().GetPluginInfoForAllInstances();2332}2333bool PluginManager::SetDynamicLoaderPluginEnabled(llvm::StringRef name,2334                                                  bool enable) {2335  return GetDynamicLoaderInstances().SetInstanceEnabled(name, enable);2336}2337 2338std::vector<RegisteredPluginInfo>2339PluginManager::GetEmulateInstructionPluginInfo() {2340  return GetEmulateInstructionInstances().GetPluginInfoForAllInstances();2341}2342bool PluginManager::SetEmulateInstructionPluginEnabled(llvm::StringRef name,2343                                                       bool enable) {2344  return GetEmulateInstructionInstances().SetInstanceEnabled(name, enable);2345}2346 2347std::vector<RegisteredPluginInfo>2348PluginManager::GetInstrumentationRuntimePluginInfo() {2349  return GetInstrumentationRuntimeInstances().GetPluginInfoForAllInstances();2350}2351bool PluginManager::SetInstrumentationRuntimePluginEnabled(llvm::StringRef name,2352                                                           bool enable) {2353  return GetInstrumentationRuntimeInstances().SetInstanceEnabled(name, enable);2354}2355 2356std::vector<RegisteredPluginInfo> PluginManager::GetJITLoaderPluginInfo() {2357  return GetJITLoaderInstances().GetPluginInfoForAllInstances();2358}2359bool PluginManager::SetJITLoaderPluginEnabled(llvm::StringRef name,2360                                              bool enable) {2361  return GetJITLoaderInstances().SetInstanceEnabled(name, enable);2362}2363 2364std::vector<RegisteredPluginInfo> PluginManager::GetLanguagePluginInfo() {2365  return GetLanguageInstances().GetPluginInfoForAllInstances();2366}2367bool PluginManager::SetLanguagePluginEnabled(llvm::StringRef name,2368                                             bool enable) {2369  return GetLanguageInstances().SetInstanceEnabled(name, enable);2370}2371 2372std::vector<RegisteredPluginInfo>2373PluginManager::GetLanguageRuntimePluginInfo() {2374  return GetLanguageRuntimeInstances().GetPluginInfoForAllInstances();2375}2376bool PluginManager::SetLanguageRuntimePluginEnabled(llvm::StringRef name,2377                                                    bool enable) {2378  return GetLanguageRuntimeInstances().SetInstanceEnabled(name, enable);2379}2380 2381std::vector<RegisteredPluginInfo> PluginManager::GetMemoryHistoryPluginInfo() {2382  return GetMemoryHistoryInstances().GetPluginInfoForAllInstances();2383}2384bool PluginManager::SetMemoryHistoryPluginEnabled(llvm::StringRef name,2385                                                  bool enable) {2386  return GetMemoryHistoryInstances().SetInstanceEnabled(name, enable);2387}2388 2389std::vector<RegisteredPluginInfo>2390PluginManager::GetObjectContainerPluginInfo() {2391  return GetObjectContainerInstances().GetPluginInfoForAllInstances();2392}2393bool PluginManager::SetObjectContainerPluginEnabled(llvm::StringRef name,2394                                                    bool enable) {2395  return GetObjectContainerInstances().SetInstanceEnabled(name, enable);2396}2397 2398std::vector<RegisteredPluginInfo> PluginManager::GetObjectFilePluginInfo() {2399  return GetObjectFileInstances().GetPluginInfoForAllInstances();2400}2401bool PluginManager::SetObjectFilePluginEnabled(llvm::StringRef name,2402                                               bool enable) {2403  return GetObjectFileInstances().SetInstanceEnabled(name, enable);2404}2405 2406std::vector<RegisteredPluginInfo>2407PluginManager::GetOperatingSystemPluginInfo() {2408  return GetOperatingSystemInstances().GetPluginInfoForAllInstances();2409}2410bool PluginManager::SetOperatingSystemPluginEnabled(llvm::StringRef name,2411                                                    bool enable) {2412  return GetOperatingSystemInstances().SetInstanceEnabled(name, enable);2413}2414 2415std::vector<RegisteredPluginInfo> PluginManager::GetPlatformPluginInfo() {2416  return GetPlatformInstances().GetPluginInfoForAllInstances();2417}2418bool PluginManager::SetPlatformPluginEnabled(llvm::StringRef name,2419                                             bool enable) {2420  return GetPlatformInstances().SetInstanceEnabled(name, enable);2421}2422 2423std::vector<RegisteredPluginInfo> PluginManager::GetProcessPluginInfo() {2424  return GetProcessInstances().GetPluginInfoForAllInstances();2425}2426bool PluginManager::SetProcessPluginEnabled(llvm::StringRef name, bool enable) {2427  return GetProcessInstances().SetInstanceEnabled(name, enable);2428}2429 2430std::vector<RegisteredPluginInfo> PluginManager::GetREPLPluginInfo() {2431  return GetREPLInstances().GetPluginInfoForAllInstances();2432}2433bool PluginManager::SetREPLPluginEnabled(llvm::StringRef name, bool enable) {2434  return GetREPLInstances().SetInstanceEnabled(name, enable);2435}2436 2437std::vector<RegisteredPluginInfo>2438PluginManager::GetRegisterTypeBuilderPluginInfo() {2439  return GetRegisterTypeBuilderInstances().GetPluginInfoForAllInstances();2440}2441bool PluginManager::SetRegisterTypeBuilderPluginEnabled(llvm::StringRef name,2442                                                        bool enable) {2443  return GetRegisterTypeBuilderInstances().SetInstanceEnabled(name, enable);2444}2445 2446std::vector<RegisteredPluginInfo>2447PluginManager::GetScriptInterpreterPluginInfo() {2448  return GetScriptInterpreterInstances().GetPluginInfoForAllInstances();2449}2450bool PluginManager::SetScriptInterpreterPluginEnabled(llvm::StringRef name,2451                                                      bool enable) {2452  return GetScriptInterpreterInstances().SetInstanceEnabled(name, enable);2453}2454 2455std::vector<RegisteredPluginInfo>2456PluginManager::GetScriptedInterfacePluginInfo() {2457  return GetScriptedInterfaceInstances().GetPluginInfoForAllInstances();2458}2459bool PluginManager::SetScriptedInterfacePluginEnabled(llvm::StringRef name,2460                                                      bool enable) {2461  return GetScriptedInterfaceInstances().SetInstanceEnabled(name, enable);2462}2463 2464std::vector<RegisteredPluginInfo> PluginManager::GetStructuredDataPluginInfo() {2465  return GetStructuredDataPluginInstances().GetPluginInfoForAllInstances();2466}2467bool PluginManager::SetStructuredDataPluginEnabled(llvm::StringRef name,2468                                                   bool enable) {2469  return GetStructuredDataPluginInstances().SetInstanceEnabled(name, enable);2470}2471 2472std::vector<RegisteredPluginInfo> PluginManager::GetSymbolFilePluginInfo() {2473  return GetSymbolFileInstances().GetPluginInfoForAllInstances();2474}2475bool PluginManager::SetSymbolFilePluginEnabled(llvm::StringRef name,2476                                               bool enable) {2477  return GetSymbolFileInstances().SetInstanceEnabled(name, enable);2478}2479 2480std::vector<RegisteredPluginInfo> PluginManager::GetSymbolLocatorPluginInfo() {2481  return GetSymbolLocatorInstances().GetPluginInfoForAllInstances();2482}2483bool PluginManager::SetSymbolLocatorPluginEnabled(llvm::StringRef name,2484                                                  bool enable) {2485  return GetSymbolLocatorInstances().SetInstanceEnabled(name, enable);2486}2487 2488std::vector<RegisteredPluginInfo> PluginManager::GetSymbolVendorPluginInfo() {2489  return GetSymbolVendorInstances().GetPluginInfoForAllInstances();2490}2491bool PluginManager::SetSymbolVendorPluginEnabled(llvm::StringRef name,2492                                                 bool enable) {2493  return GetSymbolVendorInstances().SetInstanceEnabled(name, enable);2494}2495 2496std::vector<RegisteredPluginInfo> PluginManager::GetSystemRuntimePluginInfo() {2497  return GetSystemRuntimeInstances().GetPluginInfoForAllInstances();2498}2499bool PluginManager::SetSystemRuntimePluginEnabled(llvm::StringRef name,2500                                                  bool enable) {2501  return GetSystemRuntimeInstances().SetInstanceEnabled(name, enable);2502}2503 2504std::vector<RegisteredPluginInfo> PluginManager::GetTracePluginInfo() {2505  return GetTracePluginInstances().GetPluginInfoForAllInstances();2506}2507bool PluginManager::SetTracePluginEnabled(llvm::StringRef name, bool enable) {2508  return GetTracePluginInstances().SetInstanceEnabled(name, enable);2509}2510 2511std::vector<RegisteredPluginInfo> PluginManager::GetTraceExporterPluginInfo() {2512  return GetTraceExporterInstances().GetPluginInfoForAllInstances();2513}2514bool PluginManager::SetTraceExporterPluginEnabled(llvm::StringRef name,2515                                                  bool enable) {2516  return GetTraceExporterInstances().SetInstanceEnabled(name, enable);2517}2518 2519std::vector<RegisteredPluginInfo> PluginManager::GetTypeSystemPluginInfo() {2520  return GetTypeSystemInstances().GetPluginInfoForAllInstances();2521}2522bool PluginManager::SetTypeSystemPluginEnabled(llvm::StringRef name,2523                                               bool enable) {2524  return GetTypeSystemInstances().SetInstanceEnabled(name, enable);2525}2526 2527std::vector<RegisteredPluginInfo> PluginManager::GetUnwindAssemblyPluginInfo() {2528  return GetUnwindAssemblyInstances().GetPluginInfoForAllInstances();2529}2530bool PluginManager::SetUnwindAssemblyPluginEnabled(llvm::StringRef name,2531                                                   bool enable) {2532  return GetUnwindAssemblyInstances().SetInstanceEnabled(name, enable);2533}2534 2535void PluginManager::AutoCompletePluginName(llvm::StringRef name,2536                                           CompletionRequest &request) {2537  // Split the name into the namespace and the plugin name.2538  // If there is no dot then the ns_name will be equal to name and2539  // plugin_prefix will be empty.2540  llvm::StringRef ns_name, plugin_prefix;2541  std::tie(ns_name, plugin_prefix) = name.split('.');2542 2543  for (const PluginNamespace &plugin_ns : GetPluginNamespaces()) {2544    // If the plugin namespace matches exactly then2545    // add all the plugins in this namespace as completions if the2546    // plugin names starts with the plugin_prefix. If the plugin_prefix2547    // is empty then it will match all the plugins (empty string is a2548    // prefix of everything).2549    if (plugin_ns.name == ns_name) {2550      for (const RegisteredPluginInfo &plugin : plugin_ns.get_info()) {2551        llvm::SmallString<128> buf;2552        if (plugin.name.starts_with(plugin_prefix))2553          request.AddCompletion(2554              (plugin_ns.name + "." + plugin.name).toStringRef(buf));2555      }2556    } else if (plugin_ns.name.starts_with(name) &&2557               !plugin_ns.get_info().empty()) {2558      // Otherwise check if the namespace is a prefix of the full name.2559      // Use a partial completion here so that we can either operate on the full2560      // namespace or tab-complete to the next level.2561      request.AddCompletion(plugin_ns.name, "", CompletionMode::Partial);2562    }2563  }2564}2565