LLDB mainline
PluginManager.cpp
Go to the documentation of this file.
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-exception
6//
7//===----------------------------------------------------------------------===//
8
10
11#include "lldb/Core/Debugger.h"
13#include "lldb/Host/HostInfo.h"
15#include "lldb/Target/Process.h"
18#include "lldb/Utility/Status.h"
20#include "llvm/ADT/StringRef.h"
21#include "llvm/Support/DynamicLibrary.h"
22#include "llvm/Support/FileSystem.h"
23#include "llvm/Support/raw_ostream.h"
24#include <cassert>
25#include <map>
26#include <memory>
27#include <mutex>
28#include <string>
29#include <utility>
30#include <vector>
31#if defined(_WIN32)
33#endif
34
35using namespace lldb;
36using namespace lldb_private;
37
38typedef bool (*PluginInitCallback)();
39typedef void (*PluginTermCallback)();
40
41struct PluginInfo {
42 PluginInfo() = default;
43
44 llvm::sys::DynamicLibrary library;
47};
48
49typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;
50
51static std::recursive_mutex &GetPluginMapMutex() {
52 static std::recursive_mutex g_plugin_map_mutex;
53 return g_plugin_map_mutex;
54}
55
57 static PluginTerminateMap g_plugin_map;
58 return g_plugin_map;
59}
60
61static bool PluginIsLoaded(const FileSpec &plugin_file_spec) {
62 std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
63 PluginTerminateMap &plugin_map = GetPluginMap();
64 return plugin_map.find(plugin_file_spec) != plugin_map.end();
65}
66
67static void SetPluginInfo(const FileSpec &plugin_file_spec,
68 const PluginInfo &plugin_info) {
69 std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
70 PluginTerminateMap &plugin_map = GetPluginMap();
71 assert(plugin_map.find(plugin_file_spec) == plugin_map.end());
72 plugin_map[plugin_file_spec] = plugin_info;
73}
74
75template <typename FPtrTy> static FPtrTy CastToFPtr(void *VPtr) {
76 return reinterpret_cast<FPtrTy>(VPtr);
77}
78
80LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
81 llvm::StringRef path) {
83
84 namespace fs = llvm::sys::fs;
85 // If we have a regular file, a symbolic link or unknown file type, try and
86 // process the file. We must handle unknown as sometimes the directory
87 // enumeration might be enumerating a file system that doesn't have correct
88 // file type information.
89 if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
90 ft == fs::file_type::type_unknown) {
91 FileSpec plugin_file_spec(path);
92 FileSystem::Instance().Resolve(plugin_file_spec);
93
94 if (PluginIsLoaded(plugin_file_spec))
96 else {
97 PluginInfo plugin_info;
98
99 std::string pluginLoadError;
100 plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(
101 plugin_file_spec.GetPath().c_str(), &pluginLoadError);
102 if (plugin_info.library.isValid()) {
103 bool success = false;
104 plugin_info.plugin_init_callback = CastToFPtr<PluginInitCallback>(
105 plugin_info.library.getAddressOfSymbol("LLDBPluginInitialize"));
106 if (plugin_info.plugin_init_callback) {
107 // Call the plug-in "bool LLDBPluginInitialize(void)" function
108 success = plugin_info.plugin_init_callback();
109 }
110
111 if (success) {
112 // It is ok for the "LLDBPluginTerminate" symbol to be nullptr
113 plugin_info.plugin_term_callback = CastToFPtr<PluginTermCallback>(
114 plugin_info.library.getAddressOfSymbol("LLDBPluginTerminate"));
115 } else {
116 // The initialize function returned FALSE which means the plug-in
117 // might not be compatible, or might be too new or too old, or might
118 // not want to run on this machine. Set it to a default-constructed
119 // instance to invalidate it.
120 plugin_info = PluginInfo();
121 }
122
123 // Regardless of success or failure, cache the plug-in load in our
124 // plug-in info so we don't try to load it again and again.
125 SetPluginInfo(plugin_file_spec, plugin_info);
126
128 }
129 }
130 }
131
132 if (ft == fs::file_type::directory_file ||
133 ft == fs::file_type::symlink_file || ft == fs::file_type::type_unknown) {
134 // Try and recurse into anything that a directory or symbolic link. We must
135 // also do this for unknown as sometimes the directory enumeration might be
136 // enumerating a file system that doesn't have correct file type
137 // information.
139 }
140
142}
143
145 const bool find_directories = true;
146 const bool find_files = true;
147 const bool find_other = true;
148 char dir_path[PATH_MAX];
149 if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
150 if (FileSystem::Instance().Exists(dir_spec) &&
151 dir_spec.GetPath(dir_path, sizeof(dir_path))) {
152 FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
153 find_files, find_other,
154 LoadPluginCallback, nullptr);
155 }
156 }
157
158 if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
159 if (FileSystem::Instance().Exists(dir_spec) &&
160 dir_spec.GetPath(dir_path, sizeof(dir_path))) {
161 FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
162 find_files, find_other,
163 LoadPluginCallback, nullptr);
164 }
165 }
166}
167
169 std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
170 PluginTerminateMap &plugin_map = GetPluginMap();
171
172 PluginTerminateMap::const_iterator pos, end = plugin_map.end();
173 for (pos = plugin_map.begin(); pos != end; ++pos) {
174 // Call the plug-in "void LLDBPluginTerminate (void)" function if there is
175 // one (if the symbol was not nullptr).
176 if (pos->second.library.isValid()) {
177 if (pos->second.plugin_term_callback)
178 pos->second.plugin_term_callback();
179 }
180 }
181 plugin_map.clear();
182}
183
184template <typename Callback> struct PluginInstance {
185 typedef Callback CallbackType;
186
187 PluginInstance() = default;
188 PluginInstance(llvm::StringRef name, llvm::StringRef description,
189 Callback create_callback,
190 DebuggerInitializeCallback debugger_init_callback = nullptr)
191 : name(name), description(description), create_callback(create_callback),
192 debugger_init_callback(debugger_init_callback) {}
193
194 llvm::StringRef name;
195 llvm::StringRef description;
198};
199
200template <typename Instance> class PluginInstances {
201public:
202 template <typename... Args>
203 bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description,
204 typename Instance::CallbackType callback,
205 Args &&...args) {
206 if (!callback)
207 return false;
208 assert(!name.empty());
209 Instance instance =
210 Instance(name, description, callback, std::forward<Args>(args)...);
211 m_instances.push_back(instance);
212 return false;
213 }
214
215 bool UnregisterPlugin(typename Instance::CallbackType callback) {
216 if (!callback)
217 return false;
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);
223 return true;
224 }
225 }
226 return false;
227 }
228
229 typename Instance::CallbackType GetCallbackAtIndex(uint32_t idx) {
230 if (Instance *instance = GetInstanceAtIndex(idx))
231 return instance->create_callback;
232 return nullptr;
233 }
234
235 llvm::StringRef GetDescriptionAtIndex(uint32_t idx) {
236 if (Instance *instance = GetInstanceAtIndex(idx))
237 return instance->description;
238 return "";
239 }
240
241 llvm::StringRef GetNameAtIndex(uint32_t idx) {
242 if (Instance *instance = GetInstanceAtIndex(idx))
243 return instance->name;
244 return "";
245 }
246
247 typename Instance::CallbackType GetCallbackForName(llvm::StringRef name) {
248 if (name.empty())
249 return nullptr;
250 for (auto &instance : m_instances) {
251 if (name == instance.name)
252 return instance.create_callback;
253 }
254 return nullptr;
255 }
256
258 for (auto &instance : m_instances) {
259 if (instance.debugger_init_callback)
260 instance.debugger_init_callback(debugger);
261 }
262 }
263
264 const std::vector<Instance> &GetInstances() const { return m_instances; }
265 std::vector<Instance> &GetInstances() { return m_instances; }
266
268 if (idx < m_instances.size())
269 return &m_instances[idx];
270 return nullptr;
271 }
272
273private:
274 std::vector<Instance> m_instances;
275};
276
277#pragma mark ABI
278
281
283 static ABIInstances g_instances;
284 return g_instances;
285}
286
287bool PluginManager::RegisterPlugin(llvm::StringRef name,
288 llvm::StringRef description,
289 ABICreateInstance create_callback) {
290 return GetABIInstances().RegisterPlugin(name, description, create_callback);
291}
292
293bool PluginManager::UnregisterPlugin(ABICreateInstance create_callback) {
294 return GetABIInstances().UnregisterPlugin(create_callback);
295}
296
299}
300
301#pragma mark Architecture
302
304typedef std::vector<ArchitectureInstance> ArchitectureInstances;
305
307 static ArchitectureInstances g_instances;
308 return g_instances;
309}
310
311void PluginManager::RegisterPlugin(llvm::StringRef name,
312 llvm::StringRef description,
313 ArchitectureCreateInstance create_callback) {
314 GetArchitectureInstances().push_back({name, description, create_callback});
315}
316
318 ArchitectureCreateInstance create_callback) {
319 auto &instances = GetArchitectureInstances();
320
321 for (auto pos = instances.begin(), end = instances.end(); pos != end; ++pos) {
322 if (pos->create_callback == create_callback) {
323 instances.erase(pos);
324 return;
325 }
326 }
327 llvm_unreachable("Plugin not found");
328}
329
330std::unique_ptr<Architecture>
332 for (const auto &instances : GetArchitectureInstances()) {
333 if (auto plugin_up = instances.create_callback(arch))
334 return plugin_up;
335 }
336 return nullptr;
337}
338
339#pragma mark Disassembler
340
343
345 static DisassemblerInstances g_instances;
346 return g_instances;
347}
348
349bool PluginManager::RegisterPlugin(llvm::StringRef name,
350 llvm::StringRef description,
351 DisassemblerCreateInstance create_callback) {
352 return GetDisassemblerInstances().RegisterPlugin(name, description,
353 create_callback);
354}
355
357 DisassemblerCreateInstance create_callback) {
358 return GetDisassemblerInstances().UnregisterPlugin(create_callback);
359}
360
361DisassemblerCreateInstance
364}
365
366DisassemblerCreateInstance
368 llvm::StringRef name) {
370}
371
372#pragma mark DynamicLoader
373
376
378 static DynamicLoaderInstances g_instances;
379 return g_instances;
380}
381
383 llvm::StringRef name, llvm::StringRef description,
384 DynamicLoaderCreateInstance create_callback,
385 DebuggerInitializeCallback debugger_init_callback) {
387 name, description, create_callback, debugger_init_callback);
388}
389
391 DynamicLoaderCreateInstance create_callback) {
392 return GetDynamicLoaderInstances().UnregisterPlugin(create_callback);
393}
394
395DynamicLoaderCreateInstance
398}
399
400DynamicLoaderCreateInstance
402 llvm::StringRef name) {
404}
405
406#pragma mark JITLoader
407
410
412 static JITLoaderInstances g_instances;
413 return g_instances;
414}
415
417 llvm::StringRef name, llvm::StringRef description,
418 JITLoaderCreateInstance create_callback,
419 DebuggerInitializeCallback debugger_init_callback) {
421 name, description, create_callback, debugger_init_callback);
422}
423
424bool PluginManager::UnregisterPlugin(JITLoaderCreateInstance create_callback) {
425 return GetJITLoaderInstances().UnregisterPlugin(create_callback);
426}
427
428JITLoaderCreateInstance
431}
432
433#pragma mark EmulateInstruction
434
438
440 static EmulateInstructionInstances g_instances;
441 return g_instances;
442}
443
445 llvm::StringRef name, llvm::StringRef description,
446 EmulateInstructionCreateInstance create_callback) {
447 return GetEmulateInstructionInstances().RegisterPlugin(name, description,
448 create_callback);
449}
450
452 EmulateInstructionCreateInstance create_callback) {
453 return GetEmulateInstructionInstances().UnregisterPlugin(create_callback);
454}
455
456EmulateInstructionCreateInstance
459}
460
461EmulateInstructionCreateInstance
463 llvm::StringRef name) {
465}
466
467#pragma mark OperatingSystem
468
471
473 static OperatingSystemInstances g_instances;
474 return g_instances;
475}
476
478 llvm::StringRef name, llvm::StringRef description,
479 OperatingSystemCreateInstance create_callback,
480 DebuggerInitializeCallback debugger_init_callback) {
482 name, description, create_callback, debugger_init_callback);
483}
484
486 OperatingSystemCreateInstance create_callback) {
487 return GetOperatingSystemInstances().UnregisterPlugin(create_callback);
488}
489
490OperatingSystemCreateInstance
493}
494
495OperatingSystemCreateInstance
497 llvm::StringRef name) {
499}
500
501#pragma mark Language
502
505
507 static LanguageInstances g_instances;
508 return g_instances;
509}
510
511bool PluginManager::RegisterPlugin(llvm::StringRef name,
512 llvm::StringRef description,
513 LanguageCreateInstance create_callback) {
514 return GetLanguageInstances().RegisterPlugin(name, description,
515 create_callback);
516}
517
518bool PluginManager::UnregisterPlugin(LanguageCreateInstance create_callback) {
519 return GetLanguageInstances().UnregisterPlugin(create_callback);
520}
521
522LanguageCreateInstance
525}
526
527#pragma mark LanguageRuntime
528
530 : public PluginInstance<LanguageRuntimeCreateInstance> {
532 llvm::StringRef name, llvm::StringRef description,
533 CallbackType create_callback,
534 DebuggerInitializeCallback debugger_init_callback,
535 LanguageRuntimeGetCommandObject command_callback,
536 LanguageRuntimeGetExceptionPrecondition precondition_callback)
538 name, description, create_callback, debugger_init_callback),
539 command_callback(command_callback),
540 precondition_callback(precondition_callback) {}
541
542 LanguageRuntimeGetCommandObject command_callback;
543 LanguageRuntimeGetExceptionPrecondition precondition_callback;
544};
545
547
549 static LanguageRuntimeInstances g_instances;
550 return g_instances;
551}
552
554 llvm::StringRef name, llvm::StringRef description,
555 LanguageRuntimeCreateInstance create_callback,
556 LanguageRuntimeGetCommandObject command_callback,
557 LanguageRuntimeGetExceptionPrecondition precondition_callback) {
559 name, description, create_callback, nullptr, command_callback,
560 precondition_callback);
561}
562
564 LanguageRuntimeCreateInstance create_callback) {
565 return GetLanguageRuntimeInstances().UnregisterPlugin(create_callback);
566}
567
571}
572
573LanguageRuntimeGetCommandObject
575 const auto &instances = GetLanguageRuntimeInstances().GetInstances();
576 if (idx < instances.size())
577 return instances[idx].command_callback;
578 return nullptr;
579}
580
581LanguageRuntimeGetExceptionPrecondition
583 const auto &instances = GetLanguageRuntimeInstances().GetInstances();
584 if (idx < instances.size())
585 return instances[idx].precondition_callback;
586 return nullptr;
587}
588
589#pragma mark SystemRuntime
590
593
595 static SystemRuntimeInstances g_instances;
596 return g_instances;
597}
598
600 llvm::StringRef name, llvm::StringRef description,
601 SystemRuntimeCreateInstance create_callback) {
602 return GetSystemRuntimeInstances().RegisterPlugin(name, description,
603 create_callback);
604}
605
607 SystemRuntimeCreateInstance create_callback) {
608 return GetSystemRuntimeInstances().UnregisterPlugin(create_callback);
609}
610
611SystemRuntimeCreateInstance
614}
615
616#pragma mark ObjectFile
617
618struct ObjectFileInstance : public PluginInstance<ObjectFileCreateInstance> {
620 llvm::StringRef name, llvm::StringRef description,
621 CallbackType create_callback,
622 ObjectFileCreateMemoryInstance create_memory_callback,
623 ObjectFileGetModuleSpecifications get_module_specifications,
624 ObjectFileSaveCore save_core,
625 DebuggerInitializeCallback debugger_init_callback)
627 name, description, create_callback, debugger_init_callback),
628 create_memory_callback(create_memory_callback),
629 get_module_specifications(get_module_specifications),
630 save_core(save_core) {}
631
632 ObjectFileCreateMemoryInstance create_memory_callback;
633 ObjectFileGetModuleSpecifications get_module_specifications;
634 ObjectFileSaveCore save_core;
635};
637
639 static ObjectFileInstances g_instances;
640 return g_instances;
641}
642
644 llvm::StringRef name, llvm::StringRef description,
645 ObjectFileCreateInstance create_callback,
646 ObjectFileCreateMemoryInstance create_memory_callback,
647 ObjectFileGetModuleSpecifications get_module_specifications,
648 ObjectFileSaveCore save_core,
649 DebuggerInitializeCallback debugger_init_callback) {
651 name, description, create_callback, create_memory_callback,
652 get_module_specifications, save_core, debugger_init_callback);
653}
654
656 return GetObjectFileInstances().UnregisterPlugin(create_callback);
657}
658
662}
663
664ObjectFileCreateMemoryInstance
666 const auto &instances = GetObjectFileInstances().GetInstances();
667 if (idx < instances.size())
668 return instances[idx].create_memory_callback;
669 return nullptr;
670}
671
672ObjectFileGetModuleSpecifications
674 uint32_t idx) {
675 const auto &instances = GetObjectFileInstances().GetInstances();
676 if (idx < instances.size())
677 return instances[idx].get_module_specifications;
678 return nullptr;
679}
680
681ObjectFileCreateMemoryInstance
683 llvm::StringRef name) {
684 const auto &instances = GetObjectFileInstances().GetInstances();
685 for (auto &instance : instances) {
686 if (instance.name == name)
687 return instance.create_memory_callback;
688 }
689 return nullptr;
690}
691
692Status PluginManager::SaveCore(const lldb::ProcessSP &process_sp,
693 const FileSpec &outfile,
694 lldb::SaveCoreStyle &core_style,
695 llvm::StringRef plugin_name) {
696 if (plugin_name.empty()) {
697 // Try saving core directly from the process plugin first.
698 llvm::Expected<bool> ret = process_sp->SaveCore(outfile.GetPath());
699 if (!ret)
700 return Status(ret.takeError());
701 if (ret.get())
702 return Status();
703 }
704
705 // Fall back to object plugins.
707 auto &instances = GetObjectFileInstances().GetInstances();
708 for (auto &instance : instances) {
709 if (plugin_name.empty() || instance.name == plugin_name) {
710 if (instance.save_core &&
711 instance.save_core(process_sp, outfile, core_style, error))
712 return error;
713 }
714 }
715 error.SetErrorString(
716 "no ObjectFile plugins were able to save a core for this process");
717 return error;
718}
719
720#pragma mark ObjectContainer
721
723 : public PluginInstance<ObjectContainerCreateInstance> {
725 llvm::StringRef name, llvm::StringRef description,
726 CallbackType create_callback,
727 ObjectContainerCreateMemoryInstance create_memory_callback,
728 ObjectFileGetModuleSpecifications get_module_specifications)
730 create_callback),
731 create_memory_callback(create_memory_callback),
732 get_module_specifications(get_module_specifications) {}
733
734 ObjectContainerCreateMemoryInstance create_memory_callback;
735 ObjectFileGetModuleSpecifications get_module_specifications;
736};
738
740 static ObjectContainerInstances g_instances;
741 return g_instances;
742}
743
745 llvm::StringRef name, llvm::StringRef description,
746 ObjectContainerCreateInstance create_callback,
747 ObjectFileGetModuleSpecifications get_module_specifications,
748 ObjectContainerCreateMemoryInstance create_memory_callback) {
750 name, description, create_callback, create_memory_callback,
751 get_module_specifications);
752}
753
755 ObjectContainerCreateInstance create_callback) {
756 return GetObjectContainerInstances().UnregisterPlugin(create_callback);
757}
758
762}
763
764ObjectContainerCreateMemoryInstance
766 const auto &instances = GetObjectContainerInstances().GetInstances();
767 if (idx < instances.size())
768 return instances[idx].create_memory_callback;
769 return nullptr;
770}
771
772ObjectFileGetModuleSpecifications
774 uint32_t idx) {
775 const auto &instances = GetObjectContainerInstances().GetInstances();
776 if (idx < instances.size())
777 return instances[idx].get_module_specifications;
778 return nullptr;
779}
780
781#pragma mark Platform
782
785
787 static PlatformInstances g_platform_instances;
788 return g_platform_instances;
789}
790
792 llvm::StringRef name, llvm::StringRef description,
793 PlatformCreateInstance create_callback,
794 DebuggerInitializeCallback debugger_init_callback) {
796 name, description, create_callback, debugger_init_callback);
797}
798
799bool PluginManager::UnregisterPlugin(PlatformCreateInstance create_callback) {
800 return GetPlatformInstances().UnregisterPlugin(create_callback);
801}
802
805}
806
807llvm::StringRef
810}
811
812PlatformCreateInstance
815}
816
817PlatformCreateInstance
820}
821
823 CompletionRequest &request) {
824 for (const auto &instance : GetPlatformInstances().GetInstances()) {
825 if (instance.name.startswith(name))
826 request.AddCompletion(instance.name);
827 }
828}
829
830#pragma mark Process
831
834
836 static ProcessInstances g_instances;
837 return g_instances;
838}
839
841 llvm::StringRef name, llvm::StringRef description,
842 ProcessCreateInstance create_callback,
843 DebuggerInitializeCallback debugger_init_callback) {
845 name, description, create_callback, debugger_init_callback);
846}
847
848bool PluginManager::UnregisterPlugin(ProcessCreateInstance create_callback) {
849 return GetProcessInstances().UnregisterPlugin(create_callback);
850}
851
854}
855
858}
859
860ProcessCreateInstance
863}
864
865ProcessCreateInstance
868}
869
871 CompletionRequest &request) {
872 for (const auto &instance : GetProcessInstances().GetInstances()) {
873 if (instance.name.startswith(name))
874 request.AddCompletion(instance.name, instance.description);
875 }
876}
877
878#pragma mark ScriptInterpreter
879
881 : public PluginInstance<ScriptInterpreterCreateInstance> {
882 ScriptInterpreterInstance(llvm::StringRef name, llvm::StringRef description,
883 CallbackType create_callback,
884 lldb::ScriptLanguage language)
886 create_callback),
887 language(language) {}
888
890};
891
893
895 static ScriptInterpreterInstances g_instances;
896 return g_instances;
897}
898
900 llvm::StringRef name, llvm::StringRef description,
901 lldb::ScriptLanguage script_language,
902 ScriptInterpreterCreateInstance create_callback) {
904 name, description, create_callback, script_language);
905}
906
908 ScriptInterpreterCreateInstance create_callback) {
909 return GetScriptInterpreterInstances().UnregisterPlugin(create_callback);
910}
911
915}
916
917lldb::ScriptInterpreterSP
919 Debugger &debugger) {
920 const auto &instances = GetScriptInterpreterInstances().GetInstances();
921 ScriptInterpreterCreateInstance none_instance = nullptr;
922 for (const auto &instance : instances) {
923 if (instance.language == lldb::eScriptLanguageNone)
924 none_instance = instance.create_callback;
925
926 if (script_lang == instance.language)
927 return instance.create_callback(debugger);
928 }
929
930 // If we didn't find one, return the ScriptInterpreter for the null language.
931 assert(none_instance != nullptr);
932 return none_instance(debugger);
933}
934
935#pragma mark StructuredDataPlugin
936
938 : public PluginInstance<StructuredDataPluginCreateInstance> {
940 llvm::StringRef name, llvm::StringRef description,
941 CallbackType create_callback,
942 DebuggerInitializeCallback debugger_init_callback,
943 StructuredDataFilterLaunchInfo filter_callback)
945 name, description, create_callback, debugger_init_callback),
946 filter_callback(filter_callback) {}
947
948 StructuredDataFilterLaunchInfo filter_callback = nullptr;
949};
950
953
955 static StructuredDataPluginInstances g_instances;
956 return g_instances;
957}
958
960 llvm::StringRef name, llvm::StringRef description,
962 DebuggerInitializeCallback debugger_init_callback,
963 StructuredDataFilterLaunchInfo filter_callback) {
965 name, description, create_callback, debugger_init_callback,
966 filter_callback);
967}
968
970 StructuredDataPluginCreateInstance create_callback) {
971 return GetStructuredDataPluginInstances().UnregisterPlugin(create_callback);
972}
973
977}
978
979StructuredDataFilterLaunchInfo
981 uint32_t idx, bool &iteration_complete) {
982 const auto &instances = GetStructuredDataPluginInstances().GetInstances();
983 if (idx < instances.size()) {
984 iteration_complete = false;
985 return instances[idx].filter_callback;
986 } else {
987 iteration_complete = true;
988 }
989 return nullptr;
990}
991
992#pragma mark SymbolFile
993
996
998 static SymbolFileInstances g_instances;
999 return g_instances;
1000}
1001
1003 llvm::StringRef name, llvm::StringRef description,
1004 SymbolFileCreateInstance create_callback,
1005 DebuggerInitializeCallback debugger_init_callback) {
1007 name, description, create_callback, debugger_init_callback);
1008}
1009
1010bool PluginManager::UnregisterPlugin(SymbolFileCreateInstance create_callback) {
1011 return GetSymbolFileInstances().UnregisterPlugin(create_callback);
1012}
1013
1014SymbolFileCreateInstance
1017}
1018
1019#pragma mark SymbolVendor
1020
1023
1025 static SymbolVendorInstances g_instances;
1026 return g_instances;
1027}
1028
1029bool PluginManager::RegisterPlugin(llvm::StringRef name,
1030 llvm::StringRef description,
1031 SymbolVendorCreateInstance create_callback) {
1032 return GetSymbolVendorInstances().RegisterPlugin(name, description,
1033 create_callback);
1034}
1035
1037 SymbolVendorCreateInstance create_callback) {
1038 return GetSymbolVendorInstances().UnregisterPlugin(create_callback);
1039}
1040
1041SymbolVendorCreateInstance
1044}
1045
1046#pragma mark Trace
1047
1049 : public PluginInstance<TraceCreateInstanceFromBundle> {
1051 llvm::StringRef name, llvm::StringRef description,
1052 CallbackType create_callback_from_bundle,
1053 TraceCreateInstanceForLiveProcess create_callback_for_live_process,
1054 llvm::StringRef schema, DebuggerInitializeCallback debugger_init_callback)
1056 name, description, create_callback_from_bundle,
1057 debugger_init_callback),
1058 schema(schema),
1059 create_callback_for_live_process(create_callback_for_live_process) {}
1060
1061 llvm::StringRef schema;
1062 TraceCreateInstanceForLiveProcess create_callback_for_live_process;
1063};
1064
1066
1068 static TraceInstances g_instances;
1069 return g_instances;
1070}
1071
1073 llvm::StringRef name, llvm::StringRef description,
1074 TraceCreateInstanceFromBundle create_callback_from_bundle,
1075 TraceCreateInstanceForLiveProcess create_callback_for_live_process,
1076 llvm::StringRef schema, DebuggerInitializeCallback debugger_init_callback) {
1078 name, description, create_callback_from_bundle,
1079 create_callback_for_live_process, schema, debugger_init_callback);
1080}
1081
1083 TraceCreateInstanceFromBundle create_callback_from_bundle) {
1085 create_callback_from_bundle);
1086}
1087
1089PluginManager::GetTraceCreateCallback(llvm::StringRef plugin_name) {
1090 return GetTracePluginInstances().GetCallbackForName(plugin_name);
1091}
1092
1093TraceCreateInstanceForLiveProcess
1095 for (const TraceInstance &instance : GetTracePluginInstances().GetInstances())
1096 if (instance.name == plugin_name)
1097 return instance.create_callback_for_live_process;
1098 return nullptr;
1099}
1100
1101llvm::StringRef PluginManager::GetTraceSchema(llvm::StringRef plugin_name) {
1102 for (const TraceInstance &instance : GetTracePluginInstances().GetInstances())
1103 if (instance.name == plugin_name)
1104 return instance.schema;
1105 return llvm::StringRef();
1106}
1107
1108llvm::StringRef PluginManager::GetTraceSchema(size_t index) {
1109 if (TraceInstance *instance =
1110 GetTracePluginInstances().GetInstanceAtIndex(index))
1111 return instance->schema;
1112 return llvm::StringRef();
1113}
1114
1115#pragma mark TraceExporter
1116
1118 : public PluginInstance<TraceExporterCreateInstance> {
1120 llvm::StringRef name, llvm::StringRef description,
1121 TraceExporterCreateInstance create_instance,
1122 ThreadTraceExportCommandCreator create_thread_trace_export_command)
1123 : PluginInstance<TraceExporterCreateInstance>(name, description,
1124 create_instance),
1125 create_thread_trace_export_command(create_thread_trace_export_command) {
1126 }
1127
1128 ThreadTraceExportCommandCreator create_thread_trace_export_command;
1129};
1130
1132
1134 static TraceExporterInstances g_instances;
1135 return g_instances;
1136}
1137
1139 llvm::StringRef name, llvm::StringRef description,
1140 TraceExporterCreateInstance create_callback,
1141 ThreadTraceExportCommandCreator create_thread_trace_export_command) {
1143 name, description, create_callback, create_thread_trace_export_command);
1144}
1145
1148 return GetTraceExporterInstances().GetCallbackForName(plugin_name);
1149}
1150
1152 TraceExporterCreateInstance create_callback) {
1153 return GetTraceExporterInstances().UnregisterPlugin(create_callback);
1154}
1155
1156ThreadTraceExportCommandCreator
1158 if (TraceExporterInstance *instance =
1159 GetTraceExporterInstances().GetInstanceAtIndex(index))
1160 return instance->create_thread_trace_export_command;
1161 return nullptr;
1162}
1163
1164llvm::StringRef
1167}
1168
1169#pragma mark UnwindAssembly
1170
1173
1175 static UnwindAssemblyInstances g_instances;
1176 return g_instances;
1177}
1178
1180 llvm::StringRef name, llvm::StringRef description,
1181 UnwindAssemblyCreateInstance create_callback) {
1182 return GetUnwindAssemblyInstances().RegisterPlugin(name, description,
1183 create_callback);
1184}
1185
1187 UnwindAssemblyCreateInstance create_callback) {
1188 return GetUnwindAssemblyInstances().UnregisterPlugin(create_callback);
1189}
1190
1191UnwindAssemblyCreateInstance
1194}
1195
1196#pragma mark MemoryHistory
1197
1200
1202 static MemoryHistoryInstances g_instances;
1203 return g_instances;
1204}
1205
1207 llvm::StringRef name, llvm::StringRef description,
1208 MemoryHistoryCreateInstance create_callback) {
1209 return GetMemoryHistoryInstances().RegisterPlugin(name, description,
1210 create_callback);
1211}
1212
1214 MemoryHistoryCreateInstance create_callback) {
1215 return GetMemoryHistoryInstances().UnregisterPlugin(create_callback);
1216}
1217
1218MemoryHistoryCreateInstance
1221}
1222
1223#pragma mark InstrumentationRuntime
1224
1226 : public PluginInstance<InstrumentationRuntimeCreateInstance> {
1228 llvm::StringRef name, llvm::StringRef description,
1229 CallbackType create_callback,
1230 InstrumentationRuntimeGetType get_type_callback)
1232 create_callback),
1233 get_type_callback(get_type_callback) {}
1234
1235 InstrumentationRuntimeGetType get_type_callback = nullptr;
1236};
1237
1240
1242 static InstrumentationRuntimeInstances g_instances;
1243 return g_instances;
1244}
1245
1247 llvm::StringRef name, llvm::StringRef description,
1249 InstrumentationRuntimeGetType get_type_callback) {
1251 name, description, create_callback, get_type_callback);
1252}
1253
1255 InstrumentationRuntimeCreateInstance create_callback) {
1256 return GetInstrumentationRuntimeInstances().UnregisterPlugin(create_callback);
1257}
1258
1259InstrumentationRuntimeGetType
1261 const auto &instances = GetInstrumentationRuntimeInstances().GetInstances();
1262 if (idx < instances.size())
1263 return instances[idx].get_type_callback;
1264 return nullptr;
1265}
1266
1270}
1271
1272#pragma mark TypeSystem
1273
1274struct TypeSystemInstance : public PluginInstance<TypeSystemCreateInstance> {
1275 TypeSystemInstance(llvm::StringRef name, llvm::StringRef description,
1276 CallbackType create_callback,
1277 LanguageSet supported_languages_for_types,
1278 LanguageSet supported_languages_for_expressions)
1279 : PluginInstance<TypeSystemCreateInstance>(name, description,
1280 create_callback),
1281 supported_languages_for_types(supported_languages_for_types),
1282 supported_languages_for_expressions(
1283 supported_languages_for_expressions) {}
1284
1287};
1288
1290
1292 static TypeSystemInstances g_instances;
1293 return g_instances;
1294}
1295
1297 llvm::StringRef name, llvm::StringRef description,
1298 TypeSystemCreateInstance create_callback,
1299 LanguageSet supported_languages_for_types,
1300 LanguageSet supported_languages_for_expressions) {
1302 name, description, create_callback, supported_languages_for_types,
1303 supported_languages_for_expressions);
1304}
1305
1307 return GetTypeSystemInstances().UnregisterPlugin(create_callback);
1308}
1309
1313}
1314
1316 const auto &instances = GetTypeSystemInstances().GetInstances();
1317 LanguageSet all;
1318 for (unsigned i = 0; i < instances.size(); ++i)
1319 all.bitvector |= instances[i].supported_languages_for_types.bitvector;
1320 return all;
1321}
1322
1324 const auto &instances = GetTypeSystemInstances().GetInstances();
1325 LanguageSet all;
1326 for (unsigned i = 0; i < instances.size(); ++i)
1327 all.bitvector |= instances[i].supported_languages_for_expressions.bitvector;
1328 return all;
1329}
1330
1331#pragma mark REPL
1332
1333struct REPLInstance : public PluginInstance<REPLCreateInstance> {
1334 REPLInstance(llvm::StringRef name, llvm::StringRef description,
1335 CallbackType create_callback, LanguageSet supported_languages)
1336 : PluginInstance<REPLCreateInstance>(name, description, create_callback),
1337 supported_languages(supported_languages) {}
1338
1340};
1341
1343
1345 static REPLInstances g_instances;
1346 return g_instances;
1347}
1348
1349bool PluginManager::RegisterPlugin(llvm::StringRef name, llvm::StringRef description,
1350 REPLCreateInstance create_callback,
1351 LanguageSet supported_languages) {
1352 return GetREPLInstances().RegisterPlugin(name, description, create_callback,
1353 supported_languages);
1354}
1355
1357 return GetREPLInstances().UnregisterPlugin(create_callback);
1358}
1359
1362}
1363
1365 const auto &instances = GetREPLInstances().GetInstances();
1366 return idx < instances.size() ? instances[idx].supported_languages
1367 : LanguageSet();
1368}
1369
1371 const auto &instances = GetREPLInstances().GetInstances();
1372 LanguageSet all;
1373 for (unsigned i = 0; i < instances.size(); ++i)
1374 all.bitvector |= instances[i].supported_languages.bitvector;
1375 return all;
1376}
1377
1378#pragma mark PluginManager
1379
1390}
1391
1392// This is the preferred new way to register plugin specific settings. e.g.
1393// This will put a plugin's settings under e.g.
1394// "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".
1395static lldb::OptionValuePropertiesSP
1397 ConstString plugin_type_desc, bool can_create) {
1398 lldb::OptionValuePropertiesSP parent_properties_sp(
1399 debugger.GetValueProperties());
1400 if (parent_properties_sp) {
1401 static ConstString g_property_name("plugin");
1402
1403 OptionValuePropertiesSP plugin_properties_sp =
1404 parent_properties_sp->GetSubProperty(nullptr, g_property_name);
1405 if (!plugin_properties_sp && can_create) {
1406 plugin_properties_sp =
1407 std::make_shared<OptionValueProperties>(g_property_name);
1408 parent_properties_sp->AppendProperty(
1409 g_property_name, ConstString("Settings specify to plugins."), true,
1410 plugin_properties_sp);
1411 }
1412
1413 if (plugin_properties_sp) {
1414 lldb::OptionValuePropertiesSP plugin_type_properties_sp =
1415 plugin_properties_sp->GetSubProperty(nullptr, plugin_type_name);
1416 if (!plugin_type_properties_sp && can_create) {
1417 plugin_type_properties_sp =
1418 std::make_shared<OptionValueProperties>(plugin_type_name);
1419 plugin_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
1420 true, plugin_type_properties_sp);
1421 }
1422 return plugin_type_properties_sp;
1423 }
1424 }
1425 return lldb::OptionValuePropertiesSP();
1426}
1427
1428// This is deprecated way to register plugin specific settings. e.g.
1429// "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME" and Platform
1430// generic settings would be under "platform.SETTINGNAME".
1431static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle(
1432 Debugger &debugger, ConstString plugin_type_name,
1433 ConstString plugin_type_desc, bool can_create) {
1434 static ConstString g_property_name("plugin");
1435 lldb::OptionValuePropertiesSP parent_properties_sp(
1436 debugger.GetValueProperties());
1437 if (parent_properties_sp) {
1438 OptionValuePropertiesSP plugin_properties_sp =
1439 parent_properties_sp->GetSubProperty(nullptr, plugin_type_name);
1440 if (!plugin_properties_sp && can_create) {
1441 plugin_properties_sp =
1442 std::make_shared<OptionValueProperties>(plugin_type_name);
1443 parent_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
1444 true, plugin_properties_sp);
1445 }
1446
1447 if (plugin_properties_sp) {
1448 lldb::OptionValuePropertiesSP plugin_type_properties_sp =
1449 plugin_properties_sp->GetSubProperty(nullptr, g_property_name);
1450 if (!plugin_type_properties_sp && can_create) {
1451 plugin_type_properties_sp =
1452 std::make_shared<OptionValueProperties>(g_property_name);
1453 plugin_properties_sp->AppendProperty(
1454 g_property_name, ConstString("Settings specific to plugins"), true,
1455 plugin_type_properties_sp);
1456 }
1457 return plugin_type_properties_sp;
1458 }
1459 }
1460 return lldb::OptionValuePropertiesSP();
1461}
1462
1463namespace {
1464
1465typedef lldb::OptionValuePropertiesSP
1466GetDebuggerPropertyForPluginsPtr(Debugger &, ConstString, ConstString,
1467 bool can_create);
1468}
1469
1470static lldb::OptionValuePropertiesSP
1472 ConstString plugin_type_name,
1473 GetDebuggerPropertyForPluginsPtr get_debugger_property =
1475 lldb::OptionValuePropertiesSP properties_sp;
1476 lldb::OptionValuePropertiesSP plugin_type_properties_sp(get_debugger_property(
1477 debugger, plugin_type_name,
1478 ConstString(), // not creating to so we don't need the description
1479 false));
1480 if (plugin_type_properties_sp)
1481 properties_sp =
1482 plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
1483 return properties_sp;
1484}
1485
1486static bool
1487CreateSettingForPlugin(Debugger &debugger, ConstString plugin_type_name,
1488 ConstString plugin_type_desc,
1489 const lldb::OptionValuePropertiesSP &properties_sp,
1490 ConstString description, bool is_global_property,
1491 GetDebuggerPropertyForPluginsPtr get_debugger_property =
1493 if (properties_sp) {
1494 lldb::OptionValuePropertiesSP plugin_type_properties_sp(
1495 get_debugger_property(debugger, plugin_type_name, plugin_type_desc,
1496 true));
1497 if (plugin_type_properties_sp) {
1498 plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
1499 description, is_global_property,
1500 properties_sp);
1501 return true;
1502 }
1503 }
1504 return false;
1505}
1506
1507static const char *kDynamicLoaderPluginName("dynamic-loader");
1508static const char *kPlatformPluginName("platform");
1509static const char *kProcessPluginName("process");
1510static const char *kTracePluginName("trace");
1511static const char *kObjectFilePluginName("object-file");
1512static const char *kSymbolFilePluginName("symbol-file");
1513static const char *kJITLoaderPluginName("jit-loader");
1514static const char *kStructuredDataPluginName("structured-data");
1515
1516lldb::OptionValuePropertiesSP
1518 ConstString setting_name) {
1519 return GetSettingForPlugin(debugger, setting_name,
1521}
1522
1524 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1525 ConstString description, bool is_global_property) {
1528 ConstString("Settings for dynamic loader plug-ins"), properties_sp,
1529 description, is_global_property);
1530}
1531
1532lldb::OptionValuePropertiesSP
1534 ConstString setting_name) {
1535 return GetSettingForPlugin(debugger, setting_name,
1538}
1539
1541 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1542 ConstString description, bool is_global_property) {
1544 ConstString("Settings for platform plug-ins"),
1545 properties_sp, description, is_global_property,
1547}
1548
1549lldb::OptionValuePropertiesSP
1551 ConstString setting_name) {
1552 return GetSettingForPlugin(debugger, setting_name,
1554}
1555
1557 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1558 ConstString description, bool is_global_property) {
1560 ConstString("Settings for process plug-ins"),
1561 properties_sp, description, is_global_property);
1562}
1563
1565 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1566 ConstString description, bool is_global_property) {
1568 ConstString("Settings for trace plug-ins"),
1569 properties_sp, description, is_global_property);
1570}
1571
1572lldb::OptionValuePropertiesSP
1574 ConstString setting_name) {
1575 return GetSettingForPlugin(debugger, setting_name,
1577}
1578
1580 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1581 ConstString description, bool is_global_property) {
1584 ConstString("Settings for object file plug-ins"), properties_sp,
1585 description, is_global_property);
1586}
1587
1588lldb::OptionValuePropertiesSP
1590 ConstString setting_name) {
1591 return GetSettingForPlugin(debugger, setting_name,
1593}
1594
1596 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1597 ConstString description, bool is_global_property) {
1600 ConstString("Settings for symbol file plug-ins"), properties_sp,
1601 description, is_global_property);
1602}
1603
1604lldb::OptionValuePropertiesSP
1606 ConstString setting_name) {
1607 return GetSettingForPlugin(debugger, setting_name,
1609}
1610
1612 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1613 ConstString description, bool is_global_property) {
1615 ConstString("Settings for JIT loader plug-ins"),
1616 properties_sp, description, is_global_property);
1617}
1618
1619static const char *kOperatingSystemPluginName("os");
1620
1621lldb::OptionValuePropertiesSP
1623 ConstString setting_name) {
1624 lldb::OptionValuePropertiesSP properties_sp;
1625 lldb::OptionValuePropertiesSP plugin_type_properties_sp(
1628 ConstString(), // not creating to so we don't need the description
1629 false));
1630 if (plugin_type_properties_sp)
1631 properties_sp =
1632 plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
1633 return properties_sp;
1634}
1635
1637 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1638 ConstString description, bool is_global_property) {
1639 if (properties_sp) {
1640 lldb::OptionValuePropertiesSP plugin_type_properties_sp(
1643 ConstString("Settings for operating system plug-ins"), true));
1644 if (plugin_type_properties_sp) {
1645 plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
1646 description, is_global_property,
1647 properties_sp);
1648 return true;
1649 }
1650 }
1651 return false;
1652}
1653
1654lldb::OptionValuePropertiesSP
1656 ConstString setting_name) {
1657 return GetSettingForPlugin(debugger, setting_name,
1659}
1660
1662 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
1663 ConstString description, bool is_global_property) {
1666 ConstString("Settings for structured data plug-ins"), properties_sp,
1667 description, is_global_property);
1668}
static llvm::raw_ostream & error(Stream &strm)
static FileSystem::EnumerateDirectoryResult LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path)
Definition: Debugger.cpp:601
static DisassemblerInstances & GetDisassemblerInstances()
static TraceInstances & GetTracePluginInstances()
static ObjectContainerInstances & GetObjectContainerInstances()
PluginInstances< JITLoaderInstance > JITLoaderInstances
static MemoryHistoryInstances & GetMemoryHistoryInstances()
PluginInstance< PlatformCreateInstance > PlatformInstance
PluginInstances< InstrumentationRuntimeInstance > InstrumentationRuntimeInstances
static DynamicLoaderInstances & GetDynamicLoaderInstances()
PluginInstances< SymbolFileInstance > SymbolFileInstances
std::map< FileSpec, PluginInfo > PluginTerminateMap
PluginInstances< TypeSystemInstance > TypeSystemInstances
PluginInstance< ABICreateInstance > ABIInstance
static SystemRuntimeInstances & GetSystemRuntimeInstances()
PluginInstances< TraceExporterInstance > TraceExporterInstances
PluginInstance< EmulateInstructionCreateInstance > EmulateInstructionInstance
static ABIInstances & GetABIInstances()
PluginInstances< SymbolVendorInstance > SymbolVendorInstances
static ScriptInterpreterInstances & GetScriptInterpreterInstances()
static const char * kPlatformPluginName("platform")
PluginInstance< DynamicLoaderCreateInstance > DynamicLoaderInstance
PluginInstances< PlatformInstance > PlatformInstances
PluginInstance< JITLoaderCreateInstance > JITLoaderInstance
PluginInstance< ArchitectureCreateInstance > ArchitectureInstance
PluginInstances< SystemRuntimeInstance > SystemRuntimeInstances
static const char * kDynamicLoaderPluginName("dynamic-loader")
static TraceExporterInstances & GetTraceExporterInstances()
static void SetPluginInfo(const FileSpec &plugin_file_spec, const PluginInfo &plugin_info)
static PluginTerminateMap & GetPluginMap()
static const char * kJITLoaderPluginName("jit-loader")
PluginInstance< LanguageCreateInstance > LanguageInstance
PluginInstance< SymbolFileCreateInstance > SymbolFileInstance
PluginInstances< ObjectFileInstance > ObjectFileInstances
void(* PluginTermCallback)()
static StructuredDataPluginInstances & GetStructuredDataPluginInstances()
PluginInstances< MemoryHistoryInstance > MemoryHistoryInstances
PluginInstances< DynamicLoaderInstance > DynamicLoaderInstances
PluginInstances< LanguageInstance > LanguageInstances
PluginInstances< TraceInstance > TraceInstances
static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPlugins(Debugger &debugger, ConstString plugin_type_name, ConstString plugin_type_desc, bool can_create)
PluginInstances< StructuredDataPluginInstance > StructuredDataPluginInstances
PluginInstance< MemoryHistoryCreateInstance > MemoryHistoryInstance
static const char * kOperatingSystemPluginName("os")
PluginInstance< OperatingSystemCreateInstance > OperatingSystemInstance
static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle(Debugger &debugger, ConstString plugin_type_name, ConstString plugin_type_desc, bool can_create)
static ObjectFileInstances & GetObjectFileInstances()
PluginInstance< SystemRuntimeCreateInstance > SystemRuntimeInstance
PluginInstance< SymbolVendorCreateInstance > SymbolVendorInstance
static EmulateInstructionInstances & GetEmulateInstructionInstances()
PluginInstance< UnwindAssemblyCreateInstance > UnwindAssemblyInstance
static LanguageInstances & GetLanguageInstances()
static const char * kObjectFilePluginName("object-file")
PluginInstances< OperatingSystemInstance > OperatingSystemInstances
static LanguageRuntimeInstances & GetLanguageRuntimeInstances()
PluginInstances< LanguageRuntimeInstance > LanguageRuntimeInstances
static InstrumentationRuntimeInstances & GetInstrumentationRuntimeInstances()
PluginInstances< ProcessInstance > ProcessInstances
PluginInstances< REPLInstance > REPLInstances
std::vector< ArchitectureInstance > ArchitectureInstances
static ArchitectureInstances & GetArchitectureInstances()
static lldb::OptionValuePropertiesSP GetSettingForPlugin(Debugger &debugger, ConstString setting_name, ConstString plugin_type_name, GetDebuggerPropertyForPluginsPtr get_debugger_property=GetDebuggerPropertyForPlugins)
static bool CreateSettingForPlugin(Debugger &debugger, ConstString plugin_type_name, ConstString plugin_type_desc, const lldb::OptionValuePropertiesSP &properties_sp, ConstString description, bool is_global_property, GetDebuggerPropertyForPluginsPtr get_debugger_property=GetDebuggerPropertyForPlugins)
static std::recursive_mutex & GetPluginMapMutex()
static const char * kProcessPluginName("process")
static TypeSystemInstances & GetTypeSystemInstances()
static PlatformInstances & GetPlatformInstances()
static FileSystem::EnumerateDirectoryResult LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path)
static const char * kTracePluginName("trace")
PluginInstances< EmulateInstructionInstance > EmulateInstructionInstances
static JITLoaderInstances & GetJITLoaderInstances()
PluginInstances< DisassemblerInstance > DisassemblerInstances
PluginInstance< ProcessCreateInstance > ProcessInstance
static UnwindAssemblyInstances & GetUnwindAssemblyInstances()
PluginInstances< UnwindAssemblyInstance > UnwindAssemblyInstances
static SymbolFileInstances & GetSymbolFileInstances()
PluginInstances< ABIInstance > ABIInstances
static FPtrTy CastToFPtr(void *VPtr)
static ProcessInstances & GetProcessInstances()
static bool PluginIsLoaded(const FileSpec &plugin_file_spec)
static OperatingSystemInstances & GetOperatingSystemInstances()
PluginInstances< ScriptInterpreterInstance > ScriptInterpreterInstances
bool(* PluginInitCallback)()
PluginInstance< DisassemblerCreateInstance > DisassemblerInstance
static const char * kSymbolFilePluginName("symbol-file")
static SymbolVendorInstances & GetSymbolVendorInstances()
PluginInstances< ObjectContainerInstance > ObjectContainerInstances
static const char * kStructuredDataPluginName("structured-data")
static REPLInstances & GetREPLInstances()
bool UnregisterPlugin(typename Instance::CallbackType callback)
llvm::StringRef GetNameAtIndex(uint32_t idx)
Instance::CallbackType GetCallbackAtIndex(uint32_t idx)
llvm::StringRef GetDescriptionAtIndex(uint32_t idx)
Instance * GetInstanceAtIndex(uint32_t idx)
Instance::CallbackType GetCallbackForName(llvm::StringRef name)
bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, typename Instance::CallbackType callback, Args &&...args)
std::vector< Instance > m_instances
const std::vector< Instance > & GetInstances() const
void PerformDebuggerCallback(Debugger &debugger)
std::vector< Instance > & GetInstances()
An architecture specification class.
Definition: ArchSpec.h:32
A command line argument class.
Definition: Args.h:33
"lldb/Utility/ArgCompletionRequest.h"
void AddCompletion(llvm::StringRef completion, llvm::StringRef description="", CompletionMode mode=CompletionMode::Normal)
Adds a possible completion string.
A uniqued constant string class.
Definition: ConstString.h:39
A class to manage flag bits.
Definition: Debugger.h:77
A file utility class.
Definition: FileSpec.h:56
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:366
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
void EnumerateDirectory(llvm::Twine path, bool find_directories, bool find_files, bool find_other, EnumerateDirectoryCallbackType callback, void *callback_baton)
@ eEnumerateDirectoryResultEnter
Recurse into the current entry if it is a directory or symlink, or next if not.
Definition: FileSystem.h:171
@ eEnumerateDirectoryResultNext
Enumerate next entry in the current directory.
Definition: FileSystem.h:168
static FileSystem & Instance()
static bool CreateSettingForStructuredDataPlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, ConstString description, bool is_global_property)
static llvm::StringRef GetPlatformPluginDescriptionAtIndex(uint32_t idx)
static lldb::OptionValuePropertiesSP GetSettingForJITLoaderPlugin(Debugger &debugger, ConstString setting_name)
static llvm::StringRef GetTraceExporterPluginNameAtIndex(uint32_t index)
static lldb::OptionValuePropertiesSP GetSettingForObjectFilePlugin(Debugger &debugger, ConstString setting_name)
static ProcessCreateInstance GetProcessCreateCallbackAtIndex(uint32_t idx)
static JITLoaderCreateInstance GetJITLoaderCreateCallbackAtIndex(uint32_t idx)
static ABICreateInstance GetABICreateCallbackAtIndex(uint32_t idx)
static bool CreateSettingForOperatingSystemPlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, ConstString description, bool is_global_property)
static LanguageSet GetAllTypeSystemSupportedLanguagesForExpressions()
static bool CreateSettingForDynamicLoaderPlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, ConstString description, bool is_global_property)
static void AutoCompletePlatformName(llvm::StringRef partial_name, CompletionRequest &request)
static TraceExporterCreateInstance GetTraceExporterCreateCallback(llvm::StringRef plugin_name)
static lldb::ScriptInterpreterSP GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang, Debugger &debugger)
static void AutoCompleteProcessName(llvm::StringRef partial_name, CompletionRequest &request)
static ThreadTraceExportCommandCreator GetThreadTraceExportCommandCreatorAtIndex(uint32_t index)
Return the callback used to create the CommandObject that will be listed under "thread trace export".
static bool CreateSettingForObjectFilePlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, ConstString description, bool is_global_property)
static LanguageSet GetREPLAllTypeSystemSupportedLanguages()
static PlatformCreateInstance GetPlatformCreateCallbackAtIndex(uint32_t idx)
static UnwindAssemblyCreateInstance GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx)
static bool CreateSettingForTracePlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, ConstString description, bool is_global_property)
static SymbolFileCreateInstance GetSymbolFileCreateCallbackAtIndex(uint32_t idx)
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static TypeSystemCreateInstance GetTypeSystemCreateCallbackAtIndex(uint32_t idx)
static InstrumentationRuntimeGetType GetInstrumentationRuntimeGetTypeCallbackAtIndex(uint32_t idx)
static llvm::StringRef GetTraceSchema(llvm::StringRef plugin_name)
Get the JSON schema for a trace bundle description file corresponding to the given plugin.
static TraceCreateInstanceForLiveProcess GetTraceCreateCallbackForLiveProcess(llvm::StringRef plugin_name)
static lldb::OptionValuePropertiesSP GetSettingForProcessPlugin(Debugger &debugger, ConstString setting_name)
static LanguageRuntimeCreateInstance GetLanguageRuntimeCreateCallbackAtIndex(uint32_t idx)
static std::unique_ptr< Architecture > CreateArchitectureInstance(const ArchSpec &arch)
static SystemRuntimeCreateInstance GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx)
static lldb::OptionValuePropertiesSP GetSettingForOperatingSystemPlugin(Debugger &debugger, ConstString setting_name)
static lldb::OptionValuePropertiesSP GetSettingForPlatformPlugin(Debugger &debugger, ConstString setting_name)
static SymbolVendorCreateInstance GetSymbolVendorCreateCallbackAtIndex(uint32_t idx)
static LanguageRuntimeGetCommandObject GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx)
static OperatingSystemCreateInstance GetOperatingSystemCreateCallbackAtIndex(uint32_t idx)
static bool CreateSettingForJITLoaderPlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, ConstString description, bool is_global_property)
static bool CreateSettingForSymbolFilePlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, ConstString description, bool is_global_property)
static bool CreateSettingForProcessPlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, ConstString description, bool is_global_property)
static LanguageRuntimeGetExceptionPrecondition GetLanguageRuntimeGetExceptionPreconditionAtIndex(uint32_t idx)
static REPLCreateInstance GetREPLCreateCallbackAtIndex(uint32_t idx)
static ObjectFileCreateMemoryInstance GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx)
static lldb::OptionValuePropertiesSP GetSettingForSymbolFilePlugin(Debugger &debugger, ConstString setting_name)
static DisassemblerCreateInstance GetDisassemblerCreateCallbackForPluginName(llvm::StringRef name)
static MemoryHistoryCreateInstance GetMemoryHistoryCreateCallbackAtIndex(uint32_t idx)
static OperatingSystemCreateInstance GetOperatingSystemCreateCallbackForPluginName(llvm::StringRef name)
static DisassemblerCreateInstance GetDisassemblerCreateCallbackAtIndex(uint32_t idx)
static ObjectContainerCreateInstance GetObjectContainerCreateCallbackAtIndex(uint32_t idx)
static ObjectFileCreateInstance GetObjectFileCreateCallbackAtIndex(uint32_t idx)
static bool CreateSettingForPlatformPlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, ConstString description, bool is_global_property)
static EmulateInstructionCreateInstance GetEmulateInstructionCreateCallbackForPluginName(llvm::StringRef name)
static DynamicLoaderCreateInstance GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx)
static lldb::OptionValuePropertiesSP GetSettingForDynamicLoaderPlugin(Debugger &debugger, ConstString setting_name)
static ObjectFileGetModuleSpecifications GetObjectContainerGetModuleSpecificationsCallbackAtIndex(uint32_t idx)
static DynamicLoaderCreateInstance GetDynamicLoaderCreateCallbackForPluginName(llvm::StringRef name)
static PlatformCreateInstance GetPlatformCreateCallbackForPluginName(llvm::StringRef name)
static ScriptInterpreterCreateInstance GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx)
static LanguageCreateInstance GetLanguageCreateCallbackAtIndex(uint32_t idx)
static Status SaveCore(const lldb::ProcessSP &process_sp, const FileSpec &outfile, lldb::SaveCoreStyle &core_style, llvm::StringRef plugin_name)
static ProcessCreateInstance GetProcessCreateCallbackForPluginName(llvm::StringRef name)
static lldb::OptionValuePropertiesSP GetSettingForStructuredDataPlugin(Debugger &debugger, ConstString setting_name)
static llvm::StringRef GetProcessPluginDescriptionAtIndex(uint32_t idx)
static StructuredDataPluginCreateInstance GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx)
static ObjectFileGetModuleSpecifications GetObjectFileGetModuleSpecificationsCallbackAtIndex(uint32_t idx)
static llvm::StringRef GetPlatformPluginNameAtIndex(uint32_t idx)
static TraceCreateInstanceFromBundle GetTraceCreateCallback(llvm::StringRef plugin_name)
static void DebuggerInitialize(Debugger &debugger)
static llvm::StringRef GetProcessPluginNameAtIndex(uint32_t idx)
static LanguageSet GetAllTypeSystemSupportedLanguagesForTypes()
static bool UnregisterPlugin(ABICreateInstance create_callback)
static ObjectContainerCreateMemoryInstance GetObjectContainerCreateMemoryCallbackAtIndex(uint32_t idx)
static StructuredDataFilterLaunchInfo GetStructuredDataFilterCallbackAtIndex(uint32_t idx, bool &iteration_complete)
static InstrumentationRuntimeCreateInstance GetInstrumentationRuntimeCreateCallbackAtIndex(uint32_t idx)
static LanguageSet GetREPLSupportedLanguagesAtIndex(uint32_t idx)
static ObjectFileCreateMemoryInstance GetObjectFileCreateMemoryCallbackForPluginName(llvm::StringRef name)
static EmulateInstructionCreateInstance GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx)
virtual lldb::OptionValuePropertiesSP GetValueProperties() const
An error handling class.
Definition: Status.h:44
A class that represents a running process on the host machine.
Definition: SBAddress.h:15
ScriptLanguage
Script interpreter types.
@ eScriptLanguageNone
InstrumentationRuntimeInstance(llvm::StringRef name, llvm::StringRef description, CallbackType create_callback, InstrumentationRuntimeGetType get_type_callback)
LanguageRuntimeGetExceptionPrecondition precondition_callback
LanguageRuntimeInstance(llvm::StringRef name, llvm::StringRef description, CallbackType create_callback, DebuggerInitializeCallback debugger_init_callback, LanguageRuntimeGetCommandObject command_callback, LanguageRuntimeGetExceptionPrecondition precondition_callback)
LanguageRuntimeGetCommandObject command_callback
ObjectFileGetModuleSpecifications get_module_specifications
ObjectContainerInstance(llvm::StringRef name, llvm::StringRef description, CallbackType create_callback, ObjectContainerCreateMemoryInstance create_memory_callback, ObjectFileGetModuleSpecifications get_module_specifications)
ObjectContainerCreateMemoryInstance create_memory_callback
ObjectFileCreateMemoryInstance create_memory_callback
ObjectFileGetModuleSpecifications get_module_specifications
ObjectFileInstance(llvm::StringRef name, llvm::StringRef description, CallbackType create_callback, ObjectFileCreateMemoryInstance create_memory_callback, ObjectFileGetModuleSpecifications get_module_specifications, ObjectFileSaveCore save_core, DebuggerInitializeCallback debugger_init_callback)
ObjectFileSaveCore save_core
PluginTermCallback plugin_term_callback
PluginInfo()=default
llvm::sys::DynamicLibrary library
PluginInitCallback plugin_init_callback
llvm::StringRef name
llvm::StringRef description
Callback CallbackType
DebuggerInitializeCallback debugger_init_callback
Callback create_callback
PluginInstance()=default
PluginInstance(llvm::StringRef name, llvm::StringRef description, Callback create_callback, DebuggerInitializeCallback debugger_init_callback=nullptr)
LanguageSet supported_languages
REPLInstance(llvm::StringRef name, llvm::StringRef description, CallbackType create_callback, LanguageSet supported_languages)
ScriptInterpreterInstance(llvm::StringRef name, llvm::StringRef description, CallbackType create_callback, lldb::ScriptLanguage language)
StructuredDataPluginInstance(llvm::StringRef name, llvm::StringRef description, CallbackType create_callback, DebuggerInitializeCallback debugger_init_callback, StructuredDataFilterLaunchInfo filter_callback)
ThreadTraceExportCommandCreator create_thread_trace_export_command
TraceExporterInstance(llvm::StringRef name, llvm::StringRef description, TraceExporterCreateInstance create_instance, ThreadTraceExportCommandCreator create_thread_trace_export_command)
llvm::StringRef schema
TraceInstance(llvm::StringRef name, llvm::StringRef description, CallbackType create_callback_from_bundle, TraceCreateInstanceForLiveProcess create_callback_for_live_process, llvm::StringRef schema, DebuggerInitializeCallback debugger_init_callback)
TraceCreateInstanceForLiveProcess create_callback_for_live_process
LanguageSet supported_languages_for_expressions
LanguageSet supported_languages_for_types
TypeSystemInstance(llvm::StringRef name, llvm::StringRef description, CallbackType create_callback, LanguageSet supported_languages_for_types, LanguageSet supported_languages_for_expressions)
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
Definition: TypeSystem.h:45
llvm::SmallBitVector bitvector
Definition: TypeSystem.h:46
#define PATH_MAX