1 //===-- PluginManager.cpp -------------------------------------------------===//
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-exception
7 //===----------------------------------------------------------------------===//
9 #include "lldb/Core/PluginManager.h"
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/Utility/ConstString.h"
16 #include "lldb/Utility/FileSpec.h"
17 #include "lldb/Utility/Status.h"
18 #include "lldb/Utility/StringList.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Support/DynamicLibrary.h"
21 #include "llvm/Support/FileSystem.h"
22 #include "llvm/Support/raw_ostream.h"
31 #include "lldb/Host/windows/PosixApi.h"
35 using namespace lldb_private;
37 typedef bool (*PluginInitCallback)();
38 typedef void (*PluginTermCallback)();
41 PluginInfo() : plugin_init_callback(nullptr), plugin_term_callback(nullptr) {}
43 llvm::sys::DynamicLibrary library;
44 PluginInitCallback plugin_init_callback;
45 PluginTermCallback plugin_term_callback;
48 typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;
50 static std::recursive_mutex &GetPluginMapMutex() {
51 static std::recursive_mutex g_plugin_map_mutex;
52 return g_plugin_map_mutex;
55 static PluginTerminateMap &GetPluginMap() {
56 static PluginTerminateMap g_plugin_map;
60 static bool PluginIsLoaded(const FileSpec &plugin_file_spec) {
61 std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
62 PluginTerminateMap &plugin_map = GetPluginMap();
63 return plugin_map.find(plugin_file_spec) != plugin_map.end();
66 static void SetPluginInfo(const FileSpec &plugin_file_spec,
67 const PluginInfo &plugin_info) {
68 std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
69 PluginTerminateMap &plugin_map = GetPluginMap();
70 assert(plugin_map.find(plugin_file_spec) == plugin_map.end());
71 plugin_map[plugin_file_spec] = plugin_info;
74 template <typename FPtrTy> static FPtrTy CastToFPtr(void *VPtr) {
75 return reinterpret_cast<FPtrTy>(VPtr);
78 static FileSystem::EnumerateDirectoryResult
79 LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
80 llvm::StringRef path) {
83 namespace fs = llvm::sys::fs;
84 // If we have a regular file, a symbolic link or unknown file type, try and
85 // process the file. We must handle unknown as sometimes the directory
86 // enumeration might be enumerating a file system that doesn't have correct
87 // file type information.
88 if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
89 ft == fs::file_type::type_unknown) {
90 FileSpec plugin_file_spec(path);
91 FileSystem::Instance().Resolve(plugin_file_spec);
93 if (PluginIsLoaded(plugin_file_spec))
94 return FileSystem::eEnumerateDirectoryResultNext;
96 PluginInfo plugin_info;
98 std::string pluginLoadError;
99 plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(
100 plugin_file_spec.GetPath().c_str(), &pluginLoadError);
101 if (plugin_info.library.isValid()) {
102 bool success = false;
103 plugin_info.plugin_init_callback = CastToFPtr<PluginInitCallback>(
104 plugin_info.library.getAddressOfSymbol("LLDBPluginInitialize"));
105 if (plugin_info.plugin_init_callback) {
106 // Call the plug-in "bool LLDBPluginInitialize(void)" function
107 success = plugin_info.plugin_init_callback();
111 // It is ok for the "LLDBPluginTerminate" symbol to be nullptr
112 plugin_info.plugin_term_callback = CastToFPtr<PluginTermCallback>(
113 plugin_info.library.getAddressOfSymbol("LLDBPluginTerminate"));
115 // The initialize function returned FALSE which means the plug-in
116 // might not be compatible, or might be too new or too old, or might
117 // not want to run on this machine. Set it to a default-constructed
118 // instance to invalidate it.
119 plugin_info = PluginInfo();
122 // Regardless of success or failure, cache the plug-in load in our
123 // plug-in info so we don't try to load it again and again.
124 SetPluginInfo(plugin_file_spec, plugin_info);
126 return FileSystem::eEnumerateDirectoryResultNext;
131 if (ft == fs::file_type::directory_file ||
132 ft == fs::file_type::symlink_file || ft == fs::file_type::type_unknown) {
133 // Try and recurse into anything that a directory or symbolic link. We must
134 // also do this for unknown as sometimes the directory enumeration might be
135 // enumerating a file system that doesn't have correct file type
137 return FileSystem::eEnumerateDirectoryResultEnter;
140 return FileSystem::eEnumerateDirectoryResultNext;
143 void PluginManager::Initialize() {
144 const bool find_directories = true;
145 const bool find_files = true;
146 const bool find_other = true;
147 char dir_path[PATH_MAX];
148 if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
149 if (FileSystem::Instance().Exists(dir_spec) &&
150 dir_spec.GetPath(dir_path, sizeof(dir_path))) {
151 FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
152 find_files, find_other,
153 LoadPluginCallback, nullptr);
157 if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
158 if (FileSystem::Instance().Exists(dir_spec) &&
159 dir_spec.GetPath(dir_path, sizeof(dir_path))) {
160 FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
161 find_files, find_other,
162 LoadPluginCallback, nullptr);
167 void PluginManager::Terminate() {
168 std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
169 PluginTerminateMap &plugin_map = GetPluginMap();
171 PluginTerminateMap::const_iterator pos, end = plugin_map.end();
172 for (pos = plugin_map.begin(); pos != end; ++pos) {
173 // Call the plug-in "void LLDBPluginTerminate (void)" function if there is
174 // one (if the symbol was not nullptr).
175 if (pos->second.library.isValid()) {
176 if (pos->second.plugin_term_callback)
177 pos->second.plugin_term_callback();
183 template <typename Callback> struct PluginInstance {
184 typedef Callback CallbackType;
186 PluginInstance() = default;
187 PluginInstance(ConstString name, std::string description,
188 Callback create_callback = nullptr,
189 DebuggerInitializeCallback debugger_init_callback = nullptr)
190 : name(name), description(std::move(description)),
191 create_callback(create_callback),
192 debugger_init_callback(debugger_init_callback) {}
195 std::string description;
196 Callback create_callback;
197 DebuggerInitializeCallback debugger_init_callback;
200 template <typename Instance> class PluginInstances {
202 template <typename... Args>
203 bool RegisterPlugin(ConstString name, const char *description,
204 typename Instance::CallbackType callback,
210 Instance(name, description, callback, std::forward<Args>(args)...);
211 m_instances.push_back(instance);
215 bool UnregisterPlugin(typename Instance::CallbackType callback) {
218 auto pos = m_instances.begin();
219 auto end = m_instances.end();
220 for (; pos != end; ++pos) {
221 if (pos->create_callback == callback) {
222 m_instances.erase(pos);
229 typename Instance::CallbackType GetCallbackAtIndex(uint32_t idx) {
230 if (Instance *instance = GetInstanceAtIndex(idx))
231 return instance->create_callback;
235 const char *GetDescriptionAtIndex(uint32_t idx) {
236 if (Instance *instance = GetInstanceAtIndex(idx))
237 return instance->description.c_str();
241 const char *GetNameAtIndex(uint32_t idx) {
242 if (Instance *instance = GetInstanceAtIndex(idx))
243 return instance->name.GetCString();
247 typename Instance::CallbackType GetCallbackForName(ConstString name) {
250 for (auto &instance : m_instances) {
251 if (name == instance.name)
252 return instance.create_callback;
257 void PerformDebuggerCallback(Debugger &debugger) {
258 for (auto &instance : m_instances) {
259 if (instance.debugger_init_callback)
260 instance.debugger_init_callback(debugger);
264 const std::vector<Instance> &GetInstances() const { return m_instances; }
265 std::vector<Instance> &GetInstances() { return m_instances; }
268 Instance *GetInstanceAtIndex(uint32_t idx) {
269 if (idx < m_instances.size())
270 return &m_instances[idx];
273 std::vector<Instance> m_instances;
278 typedef PluginInstance<ABICreateInstance> ABIInstance;
279 typedef PluginInstances<ABIInstance> ABIInstances;
281 static ABIInstances &GetABIInstances() {
282 static ABIInstances g_instances;
286 bool PluginManager::RegisterPlugin(ConstString name, const char *description,
287 ABICreateInstance create_callback) {
288 return GetABIInstances().RegisterPlugin(name, description, create_callback);
291 bool PluginManager::UnregisterPlugin(ABICreateInstance create_callback) {
292 return GetABIInstances().UnregisterPlugin(create_callback);
295 ABICreateInstance PluginManager::GetABICreateCallbackAtIndex(uint32_t idx) {
296 return GetABIInstances().GetCallbackAtIndex(idx);
299 #pragma mark Architecture
301 typedef PluginInstance<ArchitectureCreateInstance> ArchitectureInstance;
302 typedef std::vector<ArchitectureInstance> ArchitectureInstances;
304 static ArchitectureInstances &GetArchitectureInstances() {
305 static ArchitectureInstances g_instances;
309 void PluginManager::RegisterPlugin(ConstString name,
310 llvm::StringRef description,
311 ArchitectureCreateInstance create_callback) {
312 GetArchitectureInstances().push_back(
313 {name, std::string(description), create_callback});
316 void PluginManager::UnregisterPlugin(
317 ArchitectureCreateInstance create_callback) {
318 auto &instances = GetArchitectureInstances();
320 for (auto pos = instances.begin(), end = instances.end(); pos != end; ++pos) {
321 if (pos->create_callback == create_callback) {
322 instances.erase(pos);
326 llvm_unreachable("Plugin not found");
329 std::unique_ptr<Architecture>
330 PluginManager::CreateArchitectureInstance(const ArchSpec &arch) {
331 for (const auto &instances : GetArchitectureInstances()) {
332 if (auto plugin_up = instances.create_callback(arch))
338 #pragma mark Disassembler
340 typedef PluginInstance<DisassemblerCreateInstance> DisassemblerInstance;
341 typedef PluginInstances<DisassemblerInstance> DisassemblerInstances;
343 static DisassemblerInstances &GetDisassemblerInstances() {
344 static DisassemblerInstances g_instances;
348 bool PluginManager::RegisterPlugin(ConstString name, const char *description,
349 DisassemblerCreateInstance create_callback) {
350 return GetDisassemblerInstances().RegisterPlugin(name, description,
354 bool PluginManager::UnregisterPlugin(
355 DisassemblerCreateInstance create_callback) {
356 return GetDisassemblerInstances().UnregisterPlugin(create_callback);
359 DisassemblerCreateInstance
360 PluginManager::GetDisassemblerCreateCallbackAtIndex(uint32_t idx) {
361 return GetDisassemblerInstances().GetCallbackAtIndex(idx);
364 DisassemblerCreateInstance
365 PluginManager::GetDisassemblerCreateCallbackForPluginName(ConstString name) {
366 return GetDisassemblerInstances().GetCallbackForName(name);
369 #pragma mark DynamicLoader
371 typedef PluginInstance<DynamicLoaderCreateInstance> DynamicLoaderInstance;
372 typedef PluginInstances<DynamicLoaderInstance> DynamicLoaderInstances;
374 static DynamicLoaderInstances &GetDynamicLoaderInstances() {
375 static DynamicLoaderInstances g_instances;
379 bool PluginManager::RegisterPlugin(
380 ConstString name, const char *description,
381 DynamicLoaderCreateInstance create_callback,
382 DebuggerInitializeCallback debugger_init_callback) {
383 return GetDynamicLoaderInstances().RegisterPlugin(
384 name, description, create_callback, debugger_init_callback);
387 bool PluginManager::UnregisterPlugin(
388 DynamicLoaderCreateInstance create_callback) {
389 return GetDynamicLoaderInstances().UnregisterPlugin(create_callback);
392 DynamicLoaderCreateInstance
393 PluginManager::GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx) {
394 return GetDynamicLoaderInstances().GetCallbackAtIndex(idx);
397 DynamicLoaderCreateInstance
398 PluginManager::GetDynamicLoaderCreateCallbackForPluginName(ConstString name) {
399 return GetDynamicLoaderInstances().GetCallbackForName(name);
402 #pragma mark JITLoader
404 typedef PluginInstance<JITLoaderCreateInstance> JITLoaderInstance;
405 typedef PluginInstances<JITLoaderInstance> JITLoaderInstances;
407 static JITLoaderInstances &GetJITLoaderInstances() {
408 static JITLoaderInstances g_instances;
412 bool PluginManager::RegisterPlugin(
413 ConstString name, const char *description,
414 JITLoaderCreateInstance create_callback,
415 DebuggerInitializeCallback debugger_init_callback) {
416 return GetJITLoaderInstances().RegisterPlugin(
417 name, description, create_callback, debugger_init_callback);
420 bool PluginManager::UnregisterPlugin(JITLoaderCreateInstance create_callback) {
421 return GetJITLoaderInstances().UnregisterPlugin(create_callback);
424 JITLoaderCreateInstance
425 PluginManager::GetJITLoaderCreateCallbackAtIndex(uint32_t idx) {
426 return GetJITLoaderInstances().GetCallbackAtIndex(idx);
429 #pragma mark EmulateInstruction
431 typedef PluginInstance<EmulateInstructionCreateInstance>
432 EmulateInstructionInstance;
433 typedef PluginInstances<EmulateInstructionInstance> EmulateInstructionInstances;
435 static EmulateInstructionInstances &GetEmulateInstructionInstances() {
436 static EmulateInstructionInstances g_instances;
440 bool PluginManager::RegisterPlugin(
441 ConstString name, const char *description,
442 EmulateInstructionCreateInstance create_callback) {
443 return GetEmulateInstructionInstances().RegisterPlugin(name, description,
447 bool PluginManager::UnregisterPlugin(
448 EmulateInstructionCreateInstance create_callback) {
449 return GetEmulateInstructionInstances().UnregisterPlugin(create_callback);
452 EmulateInstructionCreateInstance
453 PluginManager::GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx) {
454 return GetEmulateInstructionInstances().GetCallbackAtIndex(idx);
457 EmulateInstructionCreateInstance
458 PluginManager::GetEmulateInstructionCreateCallbackForPluginName(
460 return GetEmulateInstructionInstances().GetCallbackForName(name);
463 #pragma mark OperatingSystem
465 typedef PluginInstance<OperatingSystemCreateInstance> OperatingSystemInstance;
466 typedef PluginInstances<OperatingSystemInstance> OperatingSystemInstances;
468 static OperatingSystemInstances &GetOperatingSystemInstances() {
469 static OperatingSystemInstances g_instances;
473 bool PluginManager::RegisterPlugin(
474 ConstString name, const char *description,
475 OperatingSystemCreateInstance create_callback,
476 DebuggerInitializeCallback debugger_init_callback) {
477 return GetOperatingSystemInstances().RegisterPlugin(
478 name, description, create_callback, debugger_init_callback);
481 bool PluginManager::UnregisterPlugin(
482 OperatingSystemCreateInstance create_callback) {
483 return GetOperatingSystemInstances().UnregisterPlugin(create_callback);
486 OperatingSystemCreateInstance
487 PluginManager::GetOperatingSystemCreateCallbackAtIndex(uint32_t idx) {
488 return GetOperatingSystemInstances().GetCallbackAtIndex(idx);
491 OperatingSystemCreateInstance
492 PluginManager::GetOperatingSystemCreateCallbackForPluginName(ConstString name) {
493 return GetOperatingSystemInstances().GetCallbackForName(name);
496 #pragma mark Language
498 typedef PluginInstance<LanguageCreateInstance> LanguageInstance;
499 typedef PluginInstances<LanguageInstance> LanguageInstances;
501 static LanguageInstances &GetLanguageInstances() {
502 static LanguageInstances g_instances;
506 bool PluginManager::RegisterPlugin(ConstString name, const char *description,
507 LanguageCreateInstance create_callback) {
508 return GetLanguageInstances().RegisterPlugin(name, description,
512 bool PluginManager::UnregisterPlugin(LanguageCreateInstance create_callback) {
513 return GetLanguageInstances().UnregisterPlugin(create_callback);
516 LanguageCreateInstance
517 PluginManager::GetLanguageCreateCallbackAtIndex(uint32_t idx) {
518 return GetLanguageInstances().GetCallbackAtIndex(idx);
521 #pragma mark LanguageRuntime
523 struct LanguageRuntimeInstance
524 : public PluginInstance<LanguageRuntimeCreateInstance> {
525 LanguageRuntimeInstance(
526 ConstString name, std::string description, CallbackType create_callback,
527 DebuggerInitializeCallback debugger_init_callback,
528 LanguageRuntimeGetCommandObject command_callback,
529 LanguageRuntimeGetExceptionPrecondition precondition_callback)
530 : PluginInstance<LanguageRuntimeCreateInstance>(
531 name, std::move(description), create_callback,
532 debugger_init_callback),
533 command_callback(command_callback),
534 precondition_callback(precondition_callback) {}
536 LanguageRuntimeGetCommandObject command_callback;
537 LanguageRuntimeGetExceptionPrecondition precondition_callback;
540 typedef PluginInstances<LanguageRuntimeInstance> LanguageRuntimeInstances;
542 static LanguageRuntimeInstances &GetLanguageRuntimeInstances() {
543 static LanguageRuntimeInstances g_instances;
547 bool PluginManager::RegisterPlugin(
548 ConstString name, const char *description,
549 LanguageRuntimeCreateInstance create_callback,
550 LanguageRuntimeGetCommandObject command_callback,
551 LanguageRuntimeGetExceptionPrecondition precondition_callback) {
552 return GetLanguageRuntimeInstances().RegisterPlugin(
553 name, description, create_callback, nullptr, command_callback,
554 precondition_callback);
557 bool PluginManager::UnregisterPlugin(
558 LanguageRuntimeCreateInstance create_callback) {
559 return GetLanguageRuntimeInstances().UnregisterPlugin(create_callback);
562 LanguageRuntimeCreateInstance
563 PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(uint32_t idx) {
564 return GetLanguageRuntimeInstances().GetCallbackAtIndex(idx);
567 LanguageRuntimeGetCommandObject
568 PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx) {
569 const auto &instances = GetLanguageRuntimeInstances().GetInstances();
570 if (idx < instances.size())
571 return instances[idx].command_callback;
575 LanguageRuntimeGetExceptionPrecondition
576 PluginManager::GetLanguageRuntimeGetExceptionPreconditionAtIndex(uint32_t idx) {
577 const auto &instances = GetLanguageRuntimeInstances().GetInstances();
578 if (idx < instances.size())
579 return instances[idx].precondition_callback;
583 #pragma mark SystemRuntime
585 typedef PluginInstance<SystemRuntimeCreateInstance> SystemRuntimeInstance;
586 typedef PluginInstances<SystemRuntimeInstance> SystemRuntimeInstances;
588 static SystemRuntimeInstances &GetSystemRuntimeInstances() {
589 static SystemRuntimeInstances g_instances;
593 bool PluginManager::RegisterPlugin(
594 ConstString name, const char *description,
595 SystemRuntimeCreateInstance create_callback) {
596 return GetSystemRuntimeInstances().RegisterPlugin(name, description,
600 bool PluginManager::UnregisterPlugin(
601 SystemRuntimeCreateInstance create_callback) {
602 return GetSystemRuntimeInstances().UnregisterPlugin(create_callback);
605 SystemRuntimeCreateInstance
606 PluginManager::GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx) {
607 return GetSystemRuntimeInstances().GetCallbackAtIndex(idx);
610 #pragma mark ObjectFile
612 struct ObjectFileInstance : public PluginInstance<ObjectFileCreateInstance> {
614 ConstString name, std::string description, CallbackType create_callback,
615 ObjectFileCreateMemoryInstance create_memory_callback,
616 ObjectFileGetModuleSpecifications get_module_specifications,
617 ObjectFileSaveCore save_core)
618 : PluginInstance<ObjectFileCreateInstance>(name, std::move(description),
620 create_memory_callback(create_memory_callback),
621 get_module_specifications(get_module_specifications),
622 save_core(save_core) {}
624 ObjectFileCreateMemoryInstance create_memory_callback;
625 ObjectFileGetModuleSpecifications get_module_specifications;
626 ObjectFileSaveCore save_core;
628 typedef PluginInstances<ObjectFileInstance> ObjectFileInstances;
630 static ObjectFileInstances &GetObjectFileInstances() {
631 static ObjectFileInstances g_instances;
635 bool PluginManager::RegisterPlugin(
636 ConstString name, const char *description,
637 ObjectFileCreateInstance create_callback,
638 ObjectFileCreateMemoryInstance create_memory_callback,
639 ObjectFileGetModuleSpecifications get_module_specifications,
640 ObjectFileSaveCore save_core) {
641 return GetObjectFileInstances().RegisterPlugin(
642 name, description, create_callback, create_memory_callback,
643 get_module_specifications, save_core);
646 bool PluginManager::UnregisterPlugin(ObjectFileCreateInstance create_callback) {
647 return GetObjectFileInstances().UnregisterPlugin(create_callback);
650 ObjectFileCreateInstance
651 PluginManager::GetObjectFileCreateCallbackAtIndex(uint32_t idx) {
652 return GetObjectFileInstances().GetCallbackAtIndex(idx);
655 ObjectFileCreateMemoryInstance
656 PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx) {
657 const auto &instances = GetObjectFileInstances().GetInstances();
658 if (idx < instances.size())
659 return instances[idx].create_memory_callback;
663 ObjectFileGetModuleSpecifications
664 PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(
666 const auto &instances = GetObjectFileInstances().GetInstances();
667 if (idx < instances.size())
668 return instances[idx].get_module_specifications;
672 ObjectFileCreateMemoryInstance
673 PluginManager::GetObjectFileCreateMemoryCallbackForPluginName(
677 const auto &instances = GetObjectFileInstances().GetInstances();
678 for (auto &instance : instances) {
679 if (instance.name == name)
680 return instance.create_memory_callback;
685 Status PluginManager::SaveCore(const lldb::ProcessSP &process_sp,
686 const FileSpec &outfile) {
688 auto &instances = GetObjectFileInstances().GetInstances();
689 for (auto &instance : instances) {
690 if (instance.save_core && instance.save_core(process_sp, outfile, error))
693 error.SetErrorString(
694 "no ObjectFile plugins were able to save a core for this process");
698 #pragma mark ObjectContainer
700 struct ObjectContainerInstance
701 : public PluginInstance<ObjectContainerCreateInstance> {
702 ObjectContainerInstance(
703 ConstString name, std::string description, CallbackType create_callback,
704 ObjectFileGetModuleSpecifications get_module_specifications)
705 : PluginInstance<ObjectContainerCreateInstance>(
706 name, std::move(description), create_callback),
707 get_module_specifications(get_module_specifications) {}
709 ObjectFileGetModuleSpecifications get_module_specifications;
711 typedef PluginInstances<ObjectContainerInstance> ObjectContainerInstances;
713 static ObjectContainerInstances &GetObjectContainerInstances() {
714 static ObjectContainerInstances g_instances;
718 bool PluginManager::RegisterPlugin(
719 ConstString name, const char *description,
720 ObjectContainerCreateInstance create_callback,
721 ObjectFileGetModuleSpecifications get_module_specifications) {
722 return GetObjectContainerInstances().RegisterPlugin(
723 name, description, create_callback, get_module_specifications);
726 bool PluginManager::UnregisterPlugin(
727 ObjectContainerCreateInstance create_callback) {
728 return GetObjectContainerInstances().UnregisterPlugin(create_callback);
731 ObjectContainerCreateInstance
732 PluginManager::GetObjectContainerCreateCallbackAtIndex(uint32_t idx) {
733 return GetObjectContainerInstances().GetCallbackAtIndex(idx);
736 ObjectFileGetModuleSpecifications
737 PluginManager::GetObjectContainerGetModuleSpecificationsCallbackAtIndex(
739 const auto &instances = GetObjectContainerInstances().GetInstances();
740 if (idx < instances.size())
741 return instances[idx].get_module_specifications;
745 #pragma mark Platform
747 typedef PluginInstance<PlatformCreateInstance> PlatformInstance;
748 typedef PluginInstances<PlatformInstance> PlatformInstances;
750 static PlatformInstances &GetPlatformInstances() {
751 static PlatformInstances g_platform_instances;
752 return g_platform_instances;
755 bool PluginManager::RegisterPlugin(
756 ConstString name, const char *description,
757 PlatformCreateInstance create_callback,
758 DebuggerInitializeCallback debugger_init_callback) {
759 return GetPlatformInstances().RegisterPlugin(
760 name, description, create_callback, debugger_init_callback);
763 bool PluginManager::UnregisterPlugin(PlatformCreateInstance create_callback) {
764 return GetPlatformInstances().UnregisterPlugin(create_callback);
767 const char *PluginManager::GetPlatformPluginNameAtIndex(uint32_t idx) {
768 return GetPlatformInstances().GetNameAtIndex(idx);
771 const char *PluginManager::GetPlatformPluginDescriptionAtIndex(uint32_t idx) {
772 return GetPlatformInstances().GetDescriptionAtIndex(idx);
775 PlatformCreateInstance
776 PluginManager::GetPlatformCreateCallbackAtIndex(uint32_t idx) {
777 return GetPlatformInstances().GetCallbackAtIndex(idx);
780 PlatformCreateInstance
781 PluginManager::GetPlatformCreateCallbackForPluginName(ConstString name) {
782 return GetPlatformInstances().GetCallbackForName(name);
785 void PluginManager::AutoCompletePlatformName(llvm::StringRef name,
786 CompletionRequest &request) {
787 for (const auto &instance : GetPlatformInstances().GetInstances()) {
788 if (instance.name.GetStringRef().startswith(name))
789 request.AddCompletion(instance.name.GetCString());
795 typedef PluginInstance<ProcessCreateInstance> ProcessInstance;
796 typedef PluginInstances<ProcessInstance> ProcessInstances;
798 static ProcessInstances &GetProcessInstances() {
799 static ProcessInstances g_instances;
803 bool PluginManager::RegisterPlugin(
804 ConstString name, const char *description,
805 ProcessCreateInstance create_callback,
806 DebuggerInitializeCallback debugger_init_callback) {
807 return GetProcessInstances().RegisterPlugin(
808 name, description, create_callback, debugger_init_callback);
811 bool PluginManager::UnregisterPlugin(ProcessCreateInstance create_callback) {
812 return GetProcessInstances().UnregisterPlugin(create_callback);
815 const char *PluginManager::GetProcessPluginNameAtIndex(uint32_t idx) {
816 return GetProcessInstances().GetNameAtIndex(idx);
819 const char *PluginManager::GetProcessPluginDescriptionAtIndex(uint32_t idx) {
820 return GetProcessInstances().GetDescriptionAtIndex(idx);
823 ProcessCreateInstance
824 PluginManager::GetProcessCreateCallbackAtIndex(uint32_t idx) {
825 return GetProcessInstances().GetCallbackAtIndex(idx);
828 ProcessCreateInstance
829 PluginManager::GetProcessCreateCallbackForPluginName(ConstString name) {
830 return GetProcessInstances().GetCallbackForName(name);
833 void PluginManager::AutoCompleteProcessName(llvm::StringRef name,
834 CompletionRequest &request) {
835 for (const auto &instance : GetProcessInstances().GetInstances()) {
836 if (instance.name.GetStringRef().startswith(name))
837 request.AddCompletion(instance.name.GetCString(), instance.description);
841 #pragma mark ScriptInterpreter
843 struct ScriptInterpreterInstance
844 : public PluginInstance<ScriptInterpreterCreateInstance> {
845 ScriptInterpreterInstance(ConstString name, std::string description,
846 CallbackType create_callback,
847 lldb::ScriptLanguage language)
848 : PluginInstance<ScriptInterpreterCreateInstance>(
849 name, std::move(description), create_callback),
850 language(language) {}
852 lldb::ScriptLanguage language = lldb::eScriptLanguageNone;
855 typedef PluginInstances<ScriptInterpreterInstance> ScriptInterpreterInstances;
857 static ScriptInterpreterInstances &GetScriptInterpreterInstances() {
858 static ScriptInterpreterInstances g_instances;
862 bool PluginManager::RegisterPlugin(
863 ConstString name, const char *description,
864 lldb::ScriptLanguage script_language,
865 ScriptInterpreterCreateInstance create_callback) {
866 return GetScriptInterpreterInstances().RegisterPlugin(
867 name, description, create_callback, script_language);
870 bool PluginManager::UnregisterPlugin(
871 ScriptInterpreterCreateInstance create_callback) {
872 return GetScriptInterpreterInstances().UnregisterPlugin(create_callback);
875 ScriptInterpreterCreateInstance
876 PluginManager::GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx) {
877 return GetScriptInterpreterInstances().GetCallbackAtIndex(idx);
880 lldb::ScriptInterpreterSP
881 PluginManager::GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang,
882 Debugger &debugger) {
883 const auto &instances = GetScriptInterpreterInstances().GetInstances();
884 ScriptInterpreterCreateInstance none_instance = nullptr;
885 for (const auto &instance : instances) {
886 if (instance.language == lldb::eScriptLanguageNone)
887 none_instance = instance.create_callback;
889 if (script_lang == instance.language)
890 return instance.create_callback(debugger);
893 // If we didn't find one, return the ScriptInterpreter for the null language.
894 assert(none_instance != nullptr);
895 return none_instance(debugger);
898 #pragma mark StructuredDataPlugin
900 struct StructuredDataPluginInstance
901 : public PluginInstance<StructuredDataPluginCreateInstance> {
902 StructuredDataPluginInstance(
903 ConstString name, std::string description, CallbackType create_callback,
904 DebuggerInitializeCallback debugger_init_callback,
905 StructuredDataFilterLaunchInfo filter_callback)
906 : PluginInstance<StructuredDataPluginCreateInstance>(
907 name, std::move(description), create_callback,
908 debugger_init_callback),
909 filter_callback(filter_callback) {}
911 StructuredDataFilterLaunchInfo filter_callback = nullptr;
914 typedef PluginInstances<StructuredDataPluginInstance>
915 StructuredDataPluginInstances;
917 static StructuredDataPluginInstances &GetStructuredDataPluginInstances() {
918 static StructuredDataPluginInstances g_instances;
922 bool PluginManager::RegisterPlugin(
923 ConstString name, const char *description,
924 StructuredDataPluginCreateInstance create_callback,
925 DebuggerInitializeCallback debugger_init_callback,
926 StructuredDataFilterLaunchInfo filter_callback) {
927 return GetStructuredDataPluginInstances().RegisterPlugin(
928 name, description, create_callback, debugger_init_callback,
932 bool PluginManager::UnregisterPlugin(
933 StructuredDataPluginCreateInstance create_callback) {
934 return GetStructuredDataPluginInstances().UnregisterPlugin(create_callback);
937 StructuredDataPluginCreateInstance
938 PluginManager::GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx) {
939 return GetStructuredDataPluginInstances().GetCallbackAtIndex(idx);
942 StructuredDataFilterLaunchInfo
943 PluginManager::GetStructuredDataFilterCallbackAtIndex(
944 uint32_t idx, bool &iteration_complete) {
945 const auto &instances = GetStructuredDataPluginInstances().GetInstances();
946 if (idx < instances.size()) {
947 iteration_complete = false;
948 return instances[idx].filter_callback;
950 iteration_complete = true;
955 #pragma mark SymbolFile
957 typedef PluginInstance<SymbolFileCreateInstance> SymbolFileInstance;
958 typedef PluginInstances<SymbolFileInstance> SymbolFileInstances;
960 static SymbolFileInstances &GetSymbolFileInstances() {
961 static SymbolFileInstances g_instances;
965 bool PluginManager::RegisterPlugin(
966 ConstString name, const char *description,
967 SymbolFileCreateInstance create_callback,
968 DebuggerInitializeCallback debugger_init_callback) {
969 return GetSymbolFileInstances().RegisterPlugin(
970 name, description, create_callback, debugger_init_callback);
973 bool PluginManager::UnregisterPlugin(SymbolFileCreateInstance create_callback) {
974 return GetSymbolFileInstances().UnregisterPlugin(create_callback);
977 SymbolFileCreateInstance
978 PluginManager::GetSymbolFileCreateCallbackAtIndex(uint32_t idx) {
979 return GetSymbolFileInstances().GetCallbackAtIndex(idx);
982 #pragma mark SymbolVendor
984 typedef PluginInstance<SymbolVendorCreateInstance> SymbolVendorInstance;
985 typedef PluginInstances<SymbolVendorInstance> SymbolVendorInstances;
987 static SymbolVendorInstances &GetSymbolVendorInstances() {
988 static SymbolVendorInstances g_instances;
992 bool PluginManager::RegisterPlugin(ConstString name, const char *description,
993 SymbolVendorCreateInstance create_callback) {
994 return GetSymbolVendorInstances().RegisterPlugin(name, description,
998 bool PluginManager::UnregisterPlugin(
999 SymbolVendorCreateInstance create_callback) {
1000 return GetSymbolVendorInstances().UnregisterPlugin(create_callback);
1003 SymbolVendorCreateInstance
1004 PluginManager::GetSymbolVendorCreateCallbackAtIndex(uint32_t idx) {
1005 return GetSymbolVendorInstances().GetCallbackAtIndex(idx);
1008 #pragma mark UnwindAssembly
1010 typedef PluginInstance<UnwindAssemblyCreateInstance> UnwindAssemblyInstance;
1011 typedef PluginInstances<UnwindAssemblyInstance> UnwindAssemblyInstances;
1013 static UnwindAssemblyInstances &GetUnwindAssemblyInstances() {
1014 static UnwindAssemblyInstances g_instances;
1018 bool PluginManager::RegisterPlugin(
1019 ConstString name, const char *description,
1020 UnwindAssemblyCreateInstance create_callback) {
1021 return GetUnwindAssemblyInstances().RegisterPlugin(name, description,
1025 bool PluginManager::UnregisterPlugin(
1026 UnwindAssemblyCreateInstance create_callback) {
1027 return GetUnwindAssemblyInstances().UnregisterPlugin(create_callback);
1030 UnwindAssemblyCreateInstance
1031 PluginManager::GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx) {
1032 return GetUnwindAssemblyInstances().GetCallbackAtIndex(idx);
1035 #pragma mark MemoryHistory
1037 typedef PluginInstance<MemoryHistoryCreateInstance> MemoryHistoryInstance;
1038 typedef PluginInstances<MemoryHistoryInstance> MemoryHistoryInstances;
1040 static MemoryHistoryInstances &GetMemoryHistoryInstances() {
1041 static MemoryHistoryInstances g_instances;
1045 bool PluginManager::RegisterPlugin(
1046 ConstString name, const char *description,
1047 MemoryHistoryCreateInstance create_callback) {
1048 return GetMemoryHistoryInstances().RegisterPlugin(name, description,
1052 bool PluginManager::UnregisterPlugin(
1053 MemoryHistoryCreateInstance create_callback) {
1054 return GetMemoryHistoryInstances().UnregisterPlugin(create_callback);
1057 MemoryHistoryCreateInstance
1058 PluginManager::GetMemoryHistoryCreateCallbackAtIndex(uint32_t idx) {
1059 return GetMemoryHistoryInstances().GetCallbackAtIndex(idx);
1062 #pragma mark InstrumentationRuntime
1064 struct InstrumentationRuntimeInstance
1065 : public PluginInstance<InstrumentationRuntimeCreateInstance> {
1066 InstrumentationRuntimeInstance(
1067 ConstString name, std::string description, CallbackType create_callback,
1068 InstrumentationRuntimeGetType get_type_callback)
1069 : PluginInstance<InstrumentationRuntimeCreateInstance>(
1070 name, std::move(description), create_callback),
1071 get_type_callback(get_type_callback) {}
1073 InstrumentationRuntimeGetType get_type_callback = nullptr;
1076 typedef PluginInstances<InstrumentationRuntimeInstance>
1077 InstrumentationRuntimeInstances;
1079 static InstrumentationRuntimeInstances &GetInstrumentationRuntimeInstances() {
1080 static InstrumentationRuntimeInstances g_instances;
1084 bool PluginManager::RegisterPlugin(
1085 ConstString name, const char *description,
1086 InstrumentationRuntimeCreateInstance create_callback,
1087 InstrumentationRuntimeGetType get_type_callback) {
1088 return GetInstrumentationRuntimeInstances().RegisterPlugin(
1089 name, description, create_callback, get_type_callback);
1092 bool PluginManager::UnregisterPlugin(
1093 InstrumentationRuntimeCreateInstance create_callback) {
1094 return GetInstrumentationRuntimeInstances().UnregisterPlugin(create_callback);
1097 InstrumentationRuntimeGetType
1098 PluginManager::GetInstrumentationRuntimeGetTypeCallbackAtIndex(uint32_t idx) {
1099 const auto &instances = GetInstrumentationRuntimeInstances().GetInstances();
1100 if (idx < instances.size())
1101 return instances[idx].get_type_callback;
1105 InstrumentationRuntimeCreateInstance
1106 PluginManager::GetInstrumentationRuntimeCreateCallbackAtIndex(uint32_t idx) {
1107 return GetInstrumentationRuntimeInstances().GetCallbackAtIndex(idx);
1110 #pragma mark TypeSystem
1112 struct TypeSystemInstance : public PluginInstance<TypeSystemCreateInstance> {
1113 TypeSystemInstance(ConstString name, std::string description,
1114 CallbackType create_callback,
1115 LanguageSet supported_languages_for_types,
1116 LanguageSet supported_languages_for_expressions)
1117 : PluginInstance<TypeSystemCreateInstance>(name, std::move(description),
1119 supported_languages_for_types(supported_languages_for_types),
1120 supported_languages_for_expressions(
1121 supported_languages_for_expressions) {}
1123 LanguageSet supported_languages_for_types;
1124 LanguageSet supported_languages_for_expressions;
1127 typedef PluginInstances<TypeSystemInstance> TypeSystemInstances;
1129 static TypeSystemInstances &GetTypeSystemInstances() {
1130 static TypeSystemInstances g_instances;
1134 bool PluginManager::RegisterPlugin(
1135 ConstString name, const char *description,
1136 TypeSystemCreateInstance create_callback,
1137 LanguageSet supported_languages_for_types,
1138 LanguageSet supported_languages_for_expressions) {
1139 return GetTypeSystemInstances().RegisterPlugin(
1140 name, description, create_callback, supported_languages_for_types,
1141 supported_languages_for_expressions);
1144 bool PluginManager::UnregisterPlugin(TypeSystemCreateInstance create_callback) {
1145 return GetTypeSystemInstances().UnregisterPlugin(create_callback);
1148 TypeSystemCreateInstance
1149 PluginManager::GetTypeSystemCreateCallbackAtIndex(uint32_t idx) {
1150 return GetTypeSystemInstances().GetCallbackAtIndex(idx);
1153 LanguageSet PluginManager::GetAllTypeSystemSupportedLanguagesForTypes() {
1154 const auto &instances = GetTypeSystemInstances().GetInstances();
1156 for (unsigned i = 0; i < instances.size(); ++i)
1157 all.bitvector |= instances[i].supported_languages_for_types.bitvector;
1161 LanguageSet PluginManager::GetAllTypeSystemSupportedLanguagesForExpressions() {
1162 const auto &instances = GetTypeSystemInstances().GetInstances();
1164 for (unsigned i = 0; i < instances.size(); ++i)
1165 all.bitvector |= instances[i].supported_languages_for_expressions.bitvector;
1171 struct REPLInstance : public PluginInstance<REPLCreateInstance> {
1172 REPLInstance(ConstString name, std::string description,
1173 CallbackType create_callback, LanguageSet supported_languages)
1174 : PluginInstance<REPLCreateInstance>(name, std::move(description),
1176 supported_languages(supported_languages) {}
1178 LanguageSet supported_languages;
1181 typedef PluginInstances<REPLInstance> REPLInstances;
1183 static REPLInstances &GetREPLInstances() {
1184 static REPLInstances g_instances;
1188 bool PluginManager::RegisterPlugin(ConstString name, const char *description,
1189 REPLCreateInstance create_callback,
1190 LanguageSet supported_languages) {
1191 return GetREPLInstances().RegisterPlugin(name, description, create_callback,
1192 supported_languages);
1195 bool PluginManager::UnregisterPlugin(REPLCreateInstance create_callback) {
1196 return GetREPLInstances().UnregisterPlugin(create_callback);
1199 REPLCreateInstance PluginManager::GetREPLCreateCallbackAtIndex(uint32_t idx) {
1200 return GetREPLInstances().GetCallbackAtIndex(idx);
1203 LanguageSet PluginManager::GetREPLAllTypeSystemSupportedLanguages() {
1204 const auto &instances = GetREPLInstances().GetInstances();
1206 for (unsigned i = 0; i < instances.size(); ++i)
1207 all.bitvector |= instances[i].supported_languages.bitvector;
1211 #pragma mark PluginManager
1213 void PluginManager::DebuggerInitialize(Debugger &debugger) {
1214 GetDynamicLoaderInstances().PerformDebuggerCallback(debugger);
1215 GetJITLoaderInstances().PerformDebuggerCallback(debugger);
1216 GetPlatformInstances().PerformDebuggerCallback(debugger);
1217 GetProcessInstances().PerformDebuggerCallback(debugger);
1218 GetSymbolFileInstances().PerformDebuggerCallback(debugger);
1219 GetOperatingSystemInstances().PerformDebuggerCallback(debugger);
1220 GetStructuredDataPluginInstances().PerformDebuggerCallback(debugger);
1223 // This is the preferred new way to register plugin specific settings. e.g.
1224 // This will put a plugin's settings under e.g.
1225 // "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".
1226 static lldb::OptionValuePropertiesSP
1227 GetDebuggerPropertyForPlugins(Debugger &debugger, ConstString plugin_type_name,
1228 ConstString plugin_type_desc, bool can_create) {
1229 lldb::OptionValuePropertiesSP parent_properties_sp(
1230 debugger.GetValueProperties());
1231 if (parent_properties_sp) {
1232 static ConstString g_property_name("plugin");
1234 OptionValuePropertiesSP plugin_properties_sp =
1235 parent_properties_sp->GetSubProperty(nullptr, g_property_name);
1236 if (!plugin_properties_sp && can_create) {
1237 plugin_properties_sp =
1238 std::make_shared<OptionValueProperties>(g_property_name);
1239 parent_properties_sp->AppendProperty(
1240 g_property_name, ConstString("Settings specify to plugins."), true,
1241 plugin_properties_sp);
1244 if (plugin_properties_sp) {
1245 lldb::OptionValuePropertiesSP plugin_type_properties_sp =
1246 plugin_properties_sp->GetSubProperty(nullptr, plugin_type_name);
1247 if (!plugin_type_properties_sp && can_create) {
1248 plugin_type_properties_sp =
1249 std::make_shared<OptionValueProperties>(plugin_type_name);
1250 plugin_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
1251 true, plugin_type_properties_sp);
1253 return plugin_type_properties_sp;
1256 return lldb::OptionValuePropertiesSP();
1259 // This is deprecated way to register plugin specific settings. e.g.
1260 // "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME" and Platform
1261 // generic settings would be under "platform.SETTINGNAME".
1262 static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle(
1263 Debugger &debugger, ConstString plugin_type_name,
1264 ConstString plugin_type_desc, bool can_create) {
1265 static ConstString g_property_name("plugin");
1266 lldb::OptionValuePropertiesSP parent_properties_sp(
1267 debugger.GetValueProperties());
1268 if (parent_properties_sp) {
1269 OptionValuePropertiesSP plugin_properties_sp =
1270 parent_properties_sp->GetSubProperty(nullptr, plugin_type_name);
1271 if (!plugin_properties_sp && can_create) {
1272 plugin_properties_sp =
1273 std::make_shared<OptionValueProperties>(plugin_type_name);
1274 parent_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
1275 true, plugin_properties_sp);
1278 if (plugin_properties_sp) {
1279 lldb::OptionValuePropertiesSP plugin_type_properties_sp =
1280 plugin_properties_sp->GetSubProperty(nullptr, g_property_name);
1281 if (!plugin_type_properties_sp && can_create) {
1282 plugin_type_properties_sp =
1283 std::make_shared<OptionValueProperties>(g_property_name);
1284 plugin_properties_sp->AppendProperty(
1285 g_property_name, ConstString("Settings specific to plugins"), true,
1286 plugin_type_properties_sp);
1288 return plugin_type_properties_sp;
1291 return lldb::OptionValuePropertiesSP();
1296 typedef lldb::OptionValuePropertiesSP
1297 GetDebuggerPropertyForPluginsPtr(Debugger &, ConstString, ConstString,
1300 lldb::OptionValuePropertiesSP
1301 GetSettingForPlugin(Debugger &debugger, ConstString setting_name,
1302 ConstString plugin_type_name,
1303 GetDebuggerPropertyForPluginsPtr get_debugger_property =
1304 GetDebuggerPropertyForPlugins) {
1305 lldb::OptionValuePropertiesSP properties_sp;
1306 lldb::OptionValuePropertiesSP plugin_type_properties_sp(get_debugger_property(
1307 debugger, plugin_type_name,
1308 ConstString(), // not creating to so we don't need the description
1310 if (plugin_type_properties_sp)
1312 plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
1313 return properties_sp;
1316 bool CreateSettingForPlugin(
1317 Debugger &debugger, ConstString plugin_type_name,
1318 ConstString plugin_type_desc,
1319 const lldb::OptionValuePropertiesSP &properties_sp, ConstString description,
1320 bool is_global_property,
1321 GetDebuggerPropertyForPluginsPtr get_debugger_property =
1322 GetDebuggerPropertyForPlugins) {
1323 if (properties_sp) {
1324 lldb::OptionValuePropertiesSP plugin_type_properties_sp(
1325 get_debugger_property(debugger, plugin_type_name, plugin_type_desc,
1327 if (plugin_type_properties_sp) {
1328 plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
1329 description, is_global_property,
1337 const char *kDynamicLoaderPluginName("dynamic-loader");
1338 const char *kPlatformPluginName("platform");
1339 const char *kProcessPluginName("process");
1340 const char *kSymbolFilePluginName("symbol-file");
1341 const char *kJITLoaderPluginName("jit-loader");
1342 const char *kStructuredDataPluginName("structured-data");
1344 } // anonymous namespace
1346 lldb::OptionValuePropertiesSP
1347 PluginManager::GetSettingForDynamicLoaderPlugin(Debugger &debugger,
1348 ConstString setting_name) {
1349 return GetSettingForPlugin(debugger, setting_name,
1350 ConstString(kDynamicLoaderPluginName));
1353 bool PluginManager::CreateSettingForDynamicLoaderPlugin(
1354 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1355 ConstString description, bool is_global_property) {
1356 return CreateSettingForPlugin(
1357 debugger, ConstString(kDynamicLoaderPluginName),
1358 ConstString("Settings for dynamic loader plug-ins"), properties_sp,
1359 description, is_global_property);
1362 lldb::OptionValuePropertiesSP
1363 PluginManager::GetSettingForPlatformPlugin(Debugger &debugger,
1364 ConstString setting_name) {
1365 return GetSettingForPlugin(debugger, setting_name,
1366 ConstString(kPlatformPluginName),
1367 GetDebuggerPropertyForPluginsOldStyle);
1370 bool PluginManager::CreateSettingForPlatformPlugin(
1371 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1372 ConstString description, bool is_global_property) {
1373 return CreateSettingForPlugin(debugger, ConstString(kPlatformPluginName),
1374 ConstString("Settings for platform plug-ins"),
1375 properties_sp, description, is_global_property,
1376 GetDebuggerPropertyForPluginsOldStyle);
1379 lldb::OptionValuePropertiesSP
1380 PluginManager::GetSettingForProcessPlugin(Debugger &debugger,
1381 ConstString setting_name) {
1382 return GetSettingForPlugin(debugger, setting_name,
1383 ConstString(kProcessPluginName));
1386 bool PluginManager::CreateSettingForProcessPlugin(
1387 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1388 ConstString description, bool is_global_property) {
1389 return CreateSettingForPlugin(debugger, ConstString(kProcessPluginName),
1390 ConstString("Settings for process plug-ins"),
1391 properties_sp, description, is_global_property);
1394 lldb::OptionValuePropertiesSP
1395 PluginManager::GetSettingForSymbolFilePlugin(Debugger &debugger,
1396 ConstString setting_name) {
1397 return GetSettingForPlugin(debugger, setting_name,
1398 ConstString(kSymbolFilePluginName));
1401 bool PluginManager::CreateSettingForSymbolFilePlugin(
1402 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1403 ConstString description, bool is_global_property) {
1404 return CreateSettingForPlugin(
1405 debugger, ConstString(kSymbolFilePluginName),
1406 ConstString("Settings for symbol file plug-ins"), properties_sp,
1407 description, is_global_property);
1410 lldb::OptionValuePropertiesSP
1411 PluginManager::GetSettingForJITLoaderPlugin(Debugger &debugger,
1412 ConstString setting_name) {
1413 return GetSettingForPlugin(debugger, setting_name,
1414 ConstString(kJITLoaderPluginName));
1417 bool PluginManager::CreateSettingForJITLoaderPlugin(
1418 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1419 ConstString description, bool is_global_property) {
1420 return CreateSettingForPlugin(debugger, ConstString(kJITLoaderPluginName),
1421 ConstString("Settings for JIT loader plug-ins"),
1422 properties_sp, description, is_global_property);
1425 static const char *kOperatingSystemPluginName("os");
1427 lldb::OptionValuePropertiesSP
1428 PluginManager::GetSettingForOperatingSystemPlugin(Debugger &debugger,
1429 ConstString setting_name) {
1430 lldb::OptionValuePropertiesSP properties_sp;
1431 lldb::OptionValuePropertiesSP plugin_type_properties_sp(
1432 GetDebuggerPropertyForPlugins(
1433 debugger, ConstString(kOperatingSystemPluginName),
1434 ConstString(), // not creating to so we don't need the description
1436 if (plugin_type_properties_sp)
1438 plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
1439 return properties_sp;
1442 bool PluginManager::CreateSettingForOperatingSystemPlugin(
1443 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1444 ConstString description, bool is_global_property) {
1445 if (properties_sp) {
1446 lldb::OptionValuePropertiesSP plugin_type_properties_sp(
1447 GetDebuggerPropertyForPlugins(
1448 debugger, ConstString(kOperatingSystemPluginName),
1449 ConstString("Settings for operating system plug-ins"), true));
1450 if (plugin_type_properties_sp) {
1451 plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
1452 description, is_global_property,
1460 lldb::OptionValuePropertiesSP
1461 PluginManager::GetSettingForStructuredDataPlugin(Debugger &debugger,
1462 ConstString setting_name) {
1463 return GetSettingForPlugin(debugger, setting_name,
1464 ConstString(kStructuredDataPluginName));
1467 bool PluginManager::CreateSettingForStructuredDataPlugin(
1468 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1469 ConstString description, bool is_global_property) {
1470 return CreateSettingForPlugin(
1471 debugger, ConstString(kStructuredDataPluginName),
1472 ConstString("Settings for structured data plug-ins"), properties_sp,
1473 description, is_global_property);