1 //===-- PluginManager.cpp ---------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Core/PluginManager.h"
11 
12 // C Includes
13 // C++ Includes
14 #include <climits>
15 #include <mutex>
16 #include <string>
17 #include <vector>
18 
19 // Other libraries and framework includes
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/Support/DynamicLibrary.h"
22 
23 // Project includes
24 #include "lldb/Core/Debugger.h"
25 #include "lldb/Core/Error.h"
26 #include "lldb/Host/FileSpec.h"
27 #include "lldb/Host/Host.h"
28 #include "lldb/Host/HostInfo.h"
29 #include "lldb/Interpreter/OptionValueProperties.h"
30 
31 using namespace lldb;
32 using namespace lldb_private;
33 
34 enum PluginAction {
35   ePluginRegisterInstance,
36   ePluginUnregisterInstance,
37   ePluginGetInstanceAtIndex
38 };
39 
40 typedef bool (*PluginInitCallback)();
41 typedef void (*PluginTermCallback)();
42 
43 struct PluginInfo {
44   PluginInfo() : plugin_init_callback(nullptr), plugin_term_callback(nullptr) {}
45 
46   llvm::sys::DynamicLibrary library;
47   PluginInitCallback plugin_init_callback;
48   PluginTermCallback plugin_term_callback;
49 };
50 
51 typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;
52 
53 static std::recursive_mutex &GetPluginMapMutex() {
54   static std::recursive_mutex g_plugin_map_mutex;
55   return g_plugin_map_mutex;
56 }
57 
58 static PluginTerminateMap &GetPluginMap() {
59   static PluginTerminateMap g_plugin_map;
60   return g_plugin_map;
61 }
62 
63 static bool PluginIsLoaded(const FileSpec &plugin_file_spec) {
64   std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
65   PluginTerminateMap &plugin_map = GetPluginMap();
66   return plugin_map.find(plugin_file_spec) != plugin_map.end();
67 }
68 
69 static void SetPluginInfo(const FileSpec &plugin_file_spec,
70                           const PluginInfo &plugin_info) {
71   std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
72   PluginTerminateMap &plugin_map = GetPluginMap();
73   assert(plugin_map.find(plugin_file_spec) == plugin_map.end());
74   plugin_map[plugin_file_spec] = plugin_info;
75 }
76 
77 template <typename FPtrTy> static FPtrTy CastToFPtr(void *VPtr) {
78   return reinterpret_cast<FPtrTy>(reinterpret_cast<intptr_t>(VPtr));
79 }
80 
81 static FileSpec::EnumerateDirectoryResult
82 LoadPluginCallback(void *baton, FileSpec::FileType file_type,
83                    const FileSpec &file_spec) {
84   //    PluginManager *plugin_manager = (PluginManager *)baton;
85   Error error;
86 
87   // If we have a regular file, a symbolic link or unknown file type, try
88   // and process the file. We must handle unknown as sometimes the directory
89   // enumeration might be enumerating a file system that doesn't have correct
90   // file type information.
91   if (file_type == FileSpec::eFileTypeRegular ||
92       file_type == FileSpec::eFileTypeSymbolicLink ||
93       file_type == FileSpec::eFileTypeUnknown) {
94     FileSpec plugin_file_spec(file_spec);
95     plugin_file_spec.ResolvePath();
96 
97     if (PluginIsLoaded(plugin_file_spec))
98       return FileSpec::eEnumerateDirectoryResultNext;
99     else {
100       PluginInfo plugin_info;
101 
102       std::string pluginLoadError;
103       plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(
104           plugin_file_spec.GetPath().c_str(), &pluginLoadError);
105       if (plugin_info.library.isValid()) {
106         bool success = false;
107         plugin_info.plugin_init_callback = CastToFPtr<PluginInitCallback>(
108             plugin_info.library.getAddressOfSymbol("LLDBPluginInitialize"));
109         if (plugin_info.plugin_init_callback) {
110           // Call the plug-in "bool LLDBPluginInitialize(void)" function
111           success = plugin_info.plugin_init_callback();
112         }
113 
114         if (success) {
115           // It is ok for the "LLDBPluginTerminate" symbol to be nullptr
116           plugin_info.plugin_term_callback = CastToFPtr<PluginTermCallback>(
117               plugin_info.library.getAddressOfSymbol("LLDBPluginTerminate"));
118         } else {
119           // The initialize function returned FALSE which means the plug-in
120           // might not be
121           // compatible, or might be too new or too old, or might not want to
122           // run on this
123           // machine.  Set it to a default-constructed instance to invalidate
124           // it.
125           plugin_info = PluginInfo();
126         }
127 
128         // Regardless of success or failure, cache the plug-in load
129         // in our plug-in info so we don't try to load it again and
130         // again.
131         SetPluginInfo(plugin_file_spec, plugin_info);
132 
133         return FileSpec::eEnumerateDirectoryResultNext;
134       }
135     }
136   }
137 
138   if (file_type == FileSpec::eFileTypeUnknown ||
139       file_type == FileSpec::eFileTypeDirectory ||
140       file_type == FileSpec::eFileTypeSymbolicLink) {
141     // Try and recurse into anything that a directory or symbolic link.
142     // We must also do this for unknown as sometimes the directory enumeration
143     // might be enumerating a file system that doesn't have correct file type
144     // information.
145     return FileSpec::eEnumerateDirectoryResultEnter;
146   }
147 
148   return FileSpec::eEnumerateDirectoryResultNext;
149 }
150 
151 void PluginManager::Initialize() {
152 #if 1
153   FileSpec dir_spec;
154   const bool find_directories = true;
155   const bool find_files = true;
156   const bool find_other = true;
157   char dir_path[PATH_MAX];
158   if (HostInfo::GetLLDBPath(ePathTypeLLDBSystemPlugins, dir_spec)) {
159     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
160       FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
161                                    find_other, LoadPluginCallback, nullptr);
162     }
163   }
164 
165   if (HostInfo::GetLLDBPath(ePathTypeLLDBUserPlugins, dir_spec)) {
166     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
167       FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
168                                    find_other, LoadPluginCallback, nullptr);
169     }
170   }
171 #endif
172 }
173 
174 void PluginManager::Terminate() {
175   std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
176   PluginTerminateMap &plugin_map = GetPluginMap();
177 
178   PluginTerminateMap::const_iterator pos, end = plugin_map.end();
179   for (pos = plugin_map.begin(); pos != end; ++pos) {
180     // Call the plug-in "void LLDBPluginTerminate (void)" function if there
181     // is one (if the symbol was not nullptr).
182     if (pos->second.library.isValid()) {
183       if (pos->second.plugin_term_callback)
184         pos->second.plugin_term_callback();
185     }
186   }
187   plugin_map.clear();
188 }
189 
190 #pragma mark ABI
191 
192 struct ABIInstance {
193   ABIInstance() : name(), description(), create_callback(nullptr) {}
194 
195   ConstString name;
196   std::string description;
197   ABICreateInstance create_callback;
198 };
199 
200 typedef std::vector<ABIInstance> ABIInstances;
201 
202 static std::recursive_mutex &GetABIInstancesMutex() {
203   static std::recursive_mutex g_instances_mutex;
204   return g_instances_mutex;
205 }
206 
207 static ABIInstances &GetABIInstances() {
208   static ABIInstances g_instances;
209   return g_instances;
210 }
211 
212 bool PluginManager::RegisterPlugin(const ConstString &name,
213                                    const char *description,
214                                    ABICreateInstance create_callback) {
215   if (create_callback) {
216     ABIInstance instance;
217     assert((bool)name);
218     instance.name = name;
219     if (description && description[0])
220       instance.description = description;
221     instance.create_callback = create_callback;
222     std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
223     GetABIInstances().push_back(instance);
224     return true;
225   }
226   return false;
227 }
228 
229 bool PluginManager::UnregisterPlugin(ABICreateInstance create_callback) {
230   if (create_callback) {
231     std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
232     ABIInstances &instances = GetABIInstances();
233 
234     ABIInstances::iterator pos, end = instances.end();
235     for (pos = instances.begin(); pos != end; ++pos) {
236       if (pos->create_callback == create_callback) {
237         instances.erase(pos);
238         return true;
239       }
240     }
241   }
242   return false;
243 }
244 
245 ABICreateInstance PluginManager::GetABICreateCallbackAtIndex(uint32_t idx) {
246   std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
247   ABIInstances &instances = GetABIInstances();
248   if (idx < instances.size())
249     return instances[idx].create_callback;
250   return nullptr;
251 }
252 
253 ABICreateInstance
254 PluginManager::GetABICreateCallbackForPluginName(const ConstString &name) {
255   if (name) {
256     std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
257     ABIInstances &instances = GetABIInstances();
258 
259     ABIInstances::iterator pos, end = instances.end();
260     for (pos = instances.begin(); pos != end; ++pos) {
261       if (name == pos->name)
262         return pos->create_callback;
263     }
264   }
265   return nullptr;
266 }
267 
268 #pragma mark Disassembler
269 
270 struct DisassemblerInstance {
271   DisassemblerInstance() : name(), description(), create_callback(nullptr) {}
272 
273   ConstString name;
274   std::string description;
275   DisassemblerCreateInstance create_callback;
276 };
277 
278 typedef std::vector<DisassemblerInstance> DisassemblerInstances;
279 
280 static std::recursive_mutex &GetDisassemblerMutex() {
281   static std::recursive_mutex g_instances_mutex;
282   return g_instances_mutex;
283 }
284 
285 static DisassemblerInstances &GetDisassemblerInstances() {
286   static DisassemblerInstances g_instances;
287   return g_instances;
288 }
289 
290 bool PluginManager::RegisterPlugin(const ConstString &name,
291                                    const char *description,
292                                    DisassemblerCreateInstance create_callback) {
293   if (create_callback) {
294     DisassemblerInstance instance;
295     assert((bool)name);
296     instance.name = name;
297     if (description && description[0])
298       instance.description = description;
299     instance.create_callback = create_callback;
300     std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
301     GetDisassemblerInstances().push_back(instance);
302     return true;
303   }
304   return false;
305 }
306 
307 bool PluginManager::UnregisterPlugin(
308     DisassemblerCreateInstance create_callback) {
309   if (create_callback) {
310     std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
311     DisassemblerInstances &instances = GetDisassemblerInstances();
312 
313     DisassemblerInstances::iterator pos, end = instances.end();
314     for (pos = instances.begin(); pos != end; ++pos) {
315       if (pos->create_callback == create_callback) {
316         instances.erase(pos);
317         return true;
318       }
319     }
320   }
321   return false;
322 }
323 
324 DisassemblerCreateInstance
325 PluginManager::GetDisassemblerCreateCallbackAtIndex(uint32_t idx) {
326   std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
327   DisassemblerInstances &instances = GetDisassemblerInstances();
328   if (idx < instances.size())
329     return instances[idx].create_callback;
330   return nullptr;
331 }
332 
333 DisassemblerCreateInstance
334 PluginManager::GetDisassemblerCreateCallbackForPluginName(
335     const ConstString &name) {
336   if (name) {
337     std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
338     DisassemblerInstances &instances = GetDisassemblerInstances();
339 
340     DisassemblerInstances::iterator pos, end = instances.end();
341     for (pos = instances.begin(); pos != end; ++pos) {
342       if (name == pos->name)
343         return pos->create_callback;
344     }
345   }
346   return nullptr;
347 }
348 
349 #pragma mark DynamicLoader
350 
351 struct DynamicLoaderInstance {
352   DynamicLoaderInstance()
353       : name(), description(), create_callback(nullptr),
354         debugger_init_callback(nullptr) {}
355 
356   ConstString name;
357   std::string description;
358   DynamicLoaderCreateInstance create_callback;
359   DebuggerInitializeCallback debugger_init_callback;
360 };
361 
362 typedef std::vector<DynamicLoaderInstance> DynamicLoaderInstances;
363 
364 static std::recursive_mutex &GetDynamicLoaderMutex() {
365   static std::recursive_mutex g_instances_mutex;
366   return g_instances_mutex;
367 }
368 
369 static DynamicLoaderInstances &GetDynamicLoaderInstances() {
370   static DynamicLoaderInstances g_instances;
371   return g_instances;
372 }
373 
374 bool PluginManager::RegisterPlugin(
375     const ConstString &name, const char *description,
376     DynamicLoaderCreateInstance create_callback,
377     DebuggerInitializeCallback debugger_init_callback) {
378   if (create_callback) {
379     DynamicLoaderInstance instance;
380     assert((bool)name);
381     instance.name = name;
382     if (description && description[0])
383       instance.description = description;
384     instance.create_callback = create_callback;
385     instance.debugger_init_callback = debugger_init_callback;
386     std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
387     GetDynamicLoaderInstances().push_back(instance);
388   }
389   return false;
390 }
391 
392 bool PluginManager::UnregisterPlugin(
393     DynamicLoaderCreateInstance create_callback) {
394   if (create_callback) {
395     std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
396     DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
397 
398     DynamicLoaderInstances::iterator pos, end = instances.end();
399     for (pos = instances.begin(); pos != end; ++pos) {
400       if (pos->create_callback == create_callback) {
401         instances.erase(pos);
402         return true;
403       }
404     }
405   }
406   return false;
407 }
408 
409 DynamicLoaderCreateInstance
410 PluginManager::GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx) {
411   std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
412   DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
413   if (idx < instances.size())
414     return instances[idx].create_callback;
415   return nullptr;
416 }
417 
418 DynamicLoaderCreateInstance
419 PluginManager::GetDynamicLoaderCreateCallbackForPluginName(
420     const ConstString &name) {
421   if (name) {
422     std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
423     DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
424 
425     DynamicLoaderInstances::iterator pos, end = instances.end();
426     for (pos = instances.begin(); pos != end; ++pos) {
427       if (name == pos->name)
428         return pos->create_callback;
429     }
430   }
431   return nullptr;
432 }
433 
434 #pragma mark JITLoader
435 
436 struct JITLoaderInstance {
437   JITLoaderInstance()
438       : name(), description(), create_callback(nullptr),
439         debugger_init_callback(nullptr) {}
440 
441   ConstString name;
442   std::string description;
443   JITLoaderCreateInstance create_callback;
444   DebuggerInitializeCallback debugger_init_callback;
445 };
446 
447 typedef std::vector<JITLoaderInstance> JITLoaderInstances;
448 
449 static std::recursive_mutex &GetJITLoaderMutex() {
450   static std::recursive_mutex g_instances_mutex;
451   return g_instances_mutex;
452 }
453 
454 static JITLoaderInstances &GetJITLoaderInstances() {
455   static JITLoaderInstances g_instances;
456   return g_instances;
457 }
458 
459 bool PluginManager::RegisterPlugin(
460     const ConstString &name, const char *description,
461     JITLoaderCreateInstance create_callback,
462     DebuggerInitializeCallback debugger_init_callback) {
463   if (create_callback) {
464     JITLoaderInstance instance;
465     assert((bool)name);
466     instance.name = name;
467     if (description && description[0])
468       instance.description = description;
469     instance.create_callback = create_callback;
470     instance.debugger_init_callback = debugger_init_callback;
471     std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
472     GetJITLoaderInstances().push_back(instance);
473   }
474   return false;
475 }
476 
477 bool PluginManager::UnregisterPlugin(JITLoaderCreateInstance create_callback) {
478   if (create_callback) {
479     std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
480     JITLoaderInstances &instances = GetJITLoaderInstances();
481 
482     JITLoaderInstances::iterator pos, end = instances.end();
483     for (pos = instances.begin(); pos != end; ++pos) {
484       if (pos->create_callback == create_callback) {
485         instances.erase(pos);
486         return true;
487       }
488     }
489   }
490   return false;
491 }
492 
493 JITLoaderCreateInstance
494 PluginManager::GetJITLoaderCreateCallbackAtIndex(uint32_t idx) {
495   std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
496   JITLoaderInstances &instances = GetJITLoaderInstances();
497   if (idx < instances.size())
498     return instances[idx].create_callback;
499   return nullptr;
500 }
501 
502 JITLoaderCreateInstance PluginManager::GetJITLoaderCreateCallbackForPluginName(
503     const ConstString &name) {
504   if (name) {
505     std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
506     JITLoaderInstances &instances = GetJITLoaderInstances();
507 
508     JITLoaderInstances::iterator pos, end = instances.end();
509     for (pos = instances.begin(); pos != end; ++pos) {
510       if (name == pos->name)
511         return pos->create_callback;
512     }
513   }
514   return nullptr;
515 }
516 
517 #pragma mark EmulateInstruction
518 
519 struct EmulateInstructionInstance {
520   EmulateInstructionInstance()
521       : name(), description(), create_callback(nullptr) {}
522 
523   ConstString name;
524   std::string description;
525   EmulateInstructionCreateInstance create_callback;
526 };
527 
528 typedef std::vector<EmulateInstructionInstance> EmulateInstructionInstances;
529 
530 static std::recursive_mutex &GetEmulateInstructionMutex() {
531   static std::recursive_mutex g_instances_mutex;
532   return g_instances_mutex;
533 }
534 
535 static EmulateInstructionInstances &GetEmulateInstructionInstances() {
536   static EmulateInstructionInstances g_instances;
537   return g_instances;
538 }
539 
540 bool PluginManager::RegisterPlugin(
541     const ConstString &name, const char *description,
542     EmulateInstructionCreateInstance create_callback) {
543   if (create_callback) {
544     EmulateInstructionInstance instance;
545     assert((bool)name);
546     instance.name = name;
547     if (description && description[0])
548       instance.description = description;
549     instance.create_callback = create_callback;
550     std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
551     GetEmulateInstructionInstances().push_back(instance);
552   }
553   return false;
554 }
555 
556 bool PluginManager::UnregisterPlugin(
557     EmulateInstructionCreateInstance create_callback) {
558   if (create_callback) {
559     std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
560     EmulateInstructionInstances &instances = GetEmulateInstructionInstances();
561 
562     EmulateInstructionInstances::iterator pos, end = instances.end();
563     for (pos = instances.begin(); pos != end; ++pos) {
564       if (pos->create_callback == create_callback) {
565         instances.erase(pos);
566         return true;
567       }
568     }
569   }
570   return false;
571 }
572 
573 EmulateInstructionCreateInstance
574 PluginManager::GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx) {
575   std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
576   EmulateInstructionInstances &instances = GetEmulateInstructionInstances();
577   if (idx < instances.size())
578     return instances[idx].create_callback;
579   return nullptr;
580 }
581 
582 EmulateInstructionCreateInstance
583 PluginManager::GetEmulateInstructionCreateCallbackForPluginName(
584     const ConstString &name) {
585   if (name) {
586     std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
587     EmulateInstructionInstances &instances = GetEmulateInstructionInstances();
588 
589     EmulateInstructionInstances::iterator pos, end = instances.end();
590     for (pos = instances.begin(); pos != end; ++pos) {
591       if (name == pos->name)
592         return pos->create_callback;
593     }
594   }
595   return nullptr;
596 }
597 
598 #pragma mark OperatingSystem
599 
600 struct OperatingSystemInstance {
601   OperatingSystemInstance()
602       : name(), description(), create_callback(nullptr),
603         debugger_init_callback(nullptr) {}
604 
605   ConstString name;
606   std::string description;
607   OperatingSystemCreateInstance create_callback;
608   DebuggerInitializeCallback debugger_init_callback;
609 };
610 
611 typedef std::vector<OperatingSystemInstance> OperatingSystemInstances;
612 
613 static std::recursive_mutex &GetOperatingSystemMutex() {
614   static std::recursive_mutex g_instances_mutex;
615   return g_instances_mutex;
616 }
617 
618 static OperatingSystemInstances &GetOperatingSystemInstances() {
619   static OperatingSystemInstances g_instances;
620   return g_instances;
621 }
622 
623 bool PluginManager::RegisterPlugin(
624     const ConstString &name, const char *description,
625     OperatingSystemCreateInstance create_callback,
626     DebuggerInitializeCallback debugger_init_callback) {
627   if (create_callback) {
628     OperatingSystemInstance instance;
629     assert((bool)name);
630     instance.name = name;
631     if (description && description[0])
632       instance.description = description;
633     instance.create_callback = create_callback;
634     instance.debugger_init_callback = debugger_init_callback;
635     std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
636     GetOperatingSystemInstances().push_back(instance);
637   }
638   return false;
639 }
640 
641 bool PluginManager::UnregisterPlugin(
642     OperatingSystemCreateInstance create_callback) {
643   if (create_callback) {
644     std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
645     OperatingSystemInstances &instances = GetOperatingSystemInstances();
646 
647     OperatingSystemInstances::iterator pos, end = instances.end();
648     for (pos = instances.begin(); pos != end; ++pos) {
649       if (pos->create_callback == create_callback) {
650         instances.erase(pos);
651         return true;
652       }
653     }
654   }
655   return false;
656 }
657 
658 OperatingSystemCreateInstance
659 PluginManager::GetOperatingSystemCreateCallbackAtIndex(uint32_t idx) {
660   std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
661   OperatingSystemInstances &instances = GetOperatingSystemInstances();
662   if (idx < instances.size())
663     return instances[idx].create_callback;
664   return nullptr;
665 }
666 
667 OperatingSystemCreateInstance
668 PluginManager::GetOperatingSystemCreateCallbackForPluginName(
669     const ConstString &name) {
670   if (name) {
671     std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
672     OperatingSystemInstances &instances = GetOperatingSystemInstances();
673 
674     OperatingSystemInstances::iterator pos, end = instances.end();
675     for (pos = instances.begin(); pos != end; ++pos) {
676       if (name == pos->name)
677         return pos->create_callback;
678     }
679   }
680   return nullptr;
681 }
682 
683 #pragma mark Language
684 
685 struct LanguageInstance {
686   LanguageInstance() : name(), description(), create_callback(nullptr) {}
687 
688   ConstString name;
689   std::string description;
690   LanguageCreateInstance create_callback;
691 };
692 
693 typedef std::vector<LanguageInstance> LanguageInstances;
694 
695 static std::recursive_mutex &GetLanguageMutex() {
696   static std::recursive_mutex g_instances_mutex;
697   return g_instances_mutex;
698 }
699 
700 static LanguageInstances &GetLanguageInstances() {
701   static LanguageInstances g_instances;
702   return g_instances;
703 }
704 
705 bool PluginManager::RegisterPlugin(const ConstString &name,
706                                    const char *description,
707                                    LanguageCreateInstance create_callback) {
708   if (create_callback) {
709     LanguageInstance instance;
710     assert((bool)name);
711     instance.name = name;
712     if (description && description[0])
713       instance.description = description;
714     instance.create_callback = create_callback;
715     std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
716     GetLanguageInstances().push_back(instance);
717   }
718   return false;
719 }
720 
721 bool PluginManager::UnregisterPlugin(LanguageCreateInstance create_callback) {
722   if (create_callback) {
723     std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
724     LanguageInstances &instances = GetLanguageInstances();
725 
726     LanguageInstances::iterator pos, end = instances.end();
727     for (pos = instances.begin(); pos != end; ++pos) {
728       if (pos->create_callback == create_callback) {
729         instances.erase(pos);
730         return true;
731       }
732     }
733   }
734   return false;
735 }
736 
737 LanguageCreateInstance
738 PluginManager::GetLanguageCreateCallbackAtIndex(uint32_t idx) {
739   std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
740   LanguageInstances &instances = GetLanguageInstances();
741   if (idx < instances.size())
742     return instances[idx].create_callback;
743   return nullptr;
744 }
745 
746 LanguageCreateInstance
747 PluginManager::GetLanguageCreateCallbackForPluginName(const ConstString &name) {
748   if (name) {
749     std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
750     LanguageInstances &instances = GetLanguageInstances();
751 
752     LanguageInstances::iterator pos, end = instances.end();
753     for (pos = instances.begin(); pos != end; ++pos) {
754       if (name == pos->name)
755         return pos->create_callback;
756     }
757   }
758   return nullptr;
759 }
760 
761 #pragma mark LanguageRuntime
762 
763 struct LanguageRuntimeInstance {
764   LanguageRuntimeInstance() : name(), description(), create_callback(nullptr) {}
765 
766   ConstString name;
767   std::string description;
768   LanguageRuntimeCreateInstance create_callback;
769   LanguageRuntimeGetCommandObject command_callback;
770 };
771 
772 typedef std::vector<LanguageRuntimeInstance> LanguageRuntimeInstances;
773 
774 static std::recursive_mutex &GetLanguageRuntimeMutex() {
775   static std::recursive_mutex g_instances_mutex;
776   return g_instances_mutex;
777 }
778 
779 static LanguageRuntimeInstances &GetLanguageRuntimeInstances() {
780   static LanguageRuntimeInstances g_instances;
781   return g_instances;
782 }
783 
784 bool PluginManager::RegisterPlugin(
785     const ConstString &name, const char *description,
786     LanguageRuntimeCreateInstance create_callback,
787     LanguageRuntimeGetCommandObject command_callback) {
788   if (create_callback) {
789     LanguageRuntimeInstance instance;
790     assert((bool)name);
791     instance.name = name;
792     if (description && description[0])
793       instance.description = description;
794     instance.create_callback = create_callback;
795     instance.command_callback = command_callback;
796     std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
797     GetLanguageRuntimeInstances().push_back(instance);
798   }
799   return false;
800 }
801 
802 bool PluginManager::UnregisterPlugin(
803     LanguageRuntimeCreateInstance create_callback) {
804   if (create_callback) {
805     std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
806     LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
807 
808     LanguageRuntimeInstances::iterator pos, end = instances.end();
809     for (pos = instances.begin(); pos != end; ++pos) {
810       if (pos->create_callback == create_callback) {
811         instances.erase(pos);
812         return true;
813       }
814     }
815   }
816   return false;
817 }
818 
819 LanguageRuntimeCreateInstance
820 PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(uint32_t idx) {
821   std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
822   LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
823   if (idx < instances.size())
824     return instances[idx].create_callback;
825   return nullptr;
826 }
827 
828 LanguageRuntimeGetCommandObject
829 PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx) {
830   std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
831   LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
832   if (idx < instances.size())
833     return instances[idx].command_callback;
834   return nullptr;
835 }
836 
837 LanguageRuntimeCreateInstance
838 PluginManager::GetLanguageRuntimeCreateCallbackForPluginName(
839     const ConstString &name) {
840   if (name) {
841     std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
842     LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
843 
844     LanguageRuntimeInstances::iterator pos, end = instances.end();
845     for (pos = instances.begin(); pos != end; ++pos) {
846       if (name == pos->name)
847         return pos->create_callback;
848     }
849   }
850   return nullptr;
851 }
852 
853 #pragma mark SystemRuntime
854 
855 struct SystemRuntimeInstance {
856   SystemRuntimeInstance() : name(), description(), create_callback(nullptr) {}
857 
858   ConstString name;
859   std::string description;
860   SystemRuntimeCreateInstance create_callback;
861 };
862 
863 typedef std::vector<SystemRuntimeInstance> SystemRuntimeInstances;
864 
865 static std::recursive_mutex &GetSystemRuntimeMutex() {
866   static std::recursive_mutex g_instances_mutex;
867   return g_instances_mutex;
868 }
869 
870 static SystemRuntimeInstances &GetSystemRuntimeInstances() {
871   static SystemRuntimeInstances g_instances;
872   return g_instances;
873 }
874 
875 bool PluginManager::RegisterPlugin(
876     const ConstString &name, const char *description,
877     SystemRuntimeCreateInstance create_callback) {
878   if (create_callback) {
879     SystemRuntimeInstance instance;
880     assert((bool)name);
881     instance.name = name;
882     if (description && description[0])
883       instance.description = description;
884     instance.create_callback = create_callback;
885     std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
886     GetSystemRuntimeInstances().push_back(instance);
887   }
888   return false;
889 }
890 
891 bool PluginManager::UnregisterPlugin(
892     SystemRuntimeCreateInstance create_callback) {
893   if (create_callback) {
894     std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
895     SystemRuntimeInstances &instances = GetSystemRuntimeInstances();
896 
897     SystemRuntimeInstances::iterator pos, end = instances.end();
898     for (pos = instances.begin(); pos != end; ++pos) {
899       if (pos->create_callback == create_callback) {
900         instances.erase(pos);
901         return true;
902       }
903     }
904   }
905   return false;
906 }
907 
908 SystemRuntimeCreateInstance
909 PluginManager::GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx) {
910   std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
911   SystemRuntimeInstances &instances = GetSystemRuntimeInstances();
912   if (idx < instances.size())
913     return instances[idx].create_callback;
914   return nullptr;
915 }
916 
917 SystemRuntimeCreateInstance
918 PluginManager::GetSystemRuntimeCreateCallbackForPluginName(
919     const ConstString &name) {
920   if (name) {
921     std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
922     SystemRuntimeInstances &instances = GetSystemRuntimeInstances();
923 
924     SystemRuntimeInstances::iterator pos, end = instances.end();
925     for (pos = instances.begin(); pos != end; ++pos) {
926       if (name == pos->name)
927         return pos->create_callback;
928     }
929   }
930   return nullptr;
931 }
932 
933 #pragma mark ObjectFile
934 
935 struct ObjectFileInstance {
936   ObjectFileInstance()
937       : name(), description(), create_callback(nullptr),
938         create_memory_callback(nullptr), get_module_specifications(nullptr),
939         save_core(nullptr) {}
940 
941   ConstString name;
942   std::string description;
943   ObjectFileCreateInstance create_callback;
944   ObjectFileCreateMemoryInstance create_memory_callback;
945   ObjectFileGetModuleSpecifications get_module_specifications;
946   ObjectFileSaveCore save_core;
947 };
948 
949 typedef std::vector<ObjectFileInstance> ObjectFileInstances;
950 
951 static std::recursive_mutex &GetObjectFileMutex() {
952   static std::recursive_mutex g_instances_mutex;
953   return g_instances_mutex;
954 }
955 
956 static ObjectFileInstances &GetObjectFileInstances() {
957   static ObjectFileInstances g_instances;
958   return g_instances;
959 }
960 
961 bool PluginManager::RegisterPlugin(
962     const ConstString &name, const char *description,
963     ObjectFileCreateInstance create_callback,
964     ObjectFileCreateMemoryInstance create_memory_callback,
965     ObjectFileGetModuleSpecifications get_module_specifications,
966     ObjectFileSaveCore save_core) {
967   if (create_callback) {
968     ObjectFileInstance instance;
969     assert((bool)name);
970     instance.name = name;
971     if (description && description[0])
972       instance.description = description;
973     instance.create_callback = create_callback;
974     instance.create_memory_callback = create_memory_callback;
975     instance.save_core = save_core;
976     instance.get_module_specifications = get_module_specifications;
977     std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
978     GetObjectFileInstances().push_back(instance);
979   }
980   return false;
981 }
982 
983 bool PluginManager::UnregisterPlugin(ObjectFileCreateInstance create_callback) {
984   if (create_callback) {
985     std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
986     ObjectFileInstances &instances = GetObjectFileInstances();
987 
988     ObjectFileInstances::iterator pos, end = instances.end();
989     for (pos = instances.begin(); pos != end; ++pos) {
990       if (pos->create_callback == create_callback) {
991         instances.erase(pos);
992         return true;
993       }
994     }
995   }
996   return false;
997 }
998 
999 ObjectFileCreateInstance
1000 PluginManager::GetObjectFileCreateCallbackAtIndex(uint32_t idx) {
1001   std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1002   ObjectFileInstances &instances = GetObjectFileInstances();
1003   if (idx < instances.size())
1004     return instances[idx].create_callback;
1005   return nullptr;
1006 }
1007 
1008 ObjectFileCreateMemoryInstance
1009 PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx) {
1010   std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1011   ObjectFileInstances &instances = GetObjectFileInstances();
1012   if (idx < instances.size())
1013     return instances[idx].create_memory_callback;
1014   return nullptr;
1015 }
1016 
1017 ObjectFileGetModuleSpecifications
1018 PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(
1019     uint32_t idx) {
1020   std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1021   ObjectFileInstances &instances = GetObjectFileInstances();
1022   if (idx < instances.size())
1023     return instances[idx].get_module_specifications;
1024   return nullptr;
1025 }
1026 
1027 ObjectFileCreateInstance
1028 PluginManager::GetObjectFileCreateCallbackForPluginName(
1029     const ConstString &name) {
1030   if (name) {
1031     std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1032     ObjectFileInstances &instances = GetObjectFileInstances();
1033 
1034     ObjectFileInstances::iterator pos, end = instances.end();
1035     for (pos = instances.begin(); pos != end; ++pos) {
1036       if (name == pos->name)
1037         return pos->create_callback;
1038     }
1039   }
1040   return nullptr;
1041 }
1042 
1043 ObjectFileCreateMemoryInstance
1044 PluginManager::GetObjectFileCreateMemoryCallbackForPluginName(
1045     const ConstString &name) {
1046   if (name) {
1047     std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1048     ObjectFileInstances &instances = GetObjectFileInstances();
1049 
1050     ObjectFileInstances::iterator pos, end = instances.end();
1051     for (pos = instances.begin(); pos != end; ++pos) {
1052       if (name == pos->name)
1053         return pos->create_memory_callback;
1054     }
1055   }
1056   return nullptr;
1057 }
1058 
1059 Error PluginManager::SaveCore(const lldb::ProcessSP &process_sp,
1060                               const FileSpec &outfile) {
1061   Error error;
1062   std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1063   ObjectFileInstances &instances = GetObjectFileInstances();
1064 
1065   ObjectFileInstances::iterator pos, end = instances.end();
1066   for (pos = instances.begin(); pos != end; ++pos) {
1067     if (pos->save_core && pos->save_core(process_sp, outfile, error))
1068       return error;
1069   }
1070   error.SetErrorString(
1071       "no ObjectFile plugins were able to save a core for this process");
1072   return error;
1073 }
1074 
1075 #pragma mark ObjectContainer
1076 
1077 struct ObjectContainerInstance {
1078   ObjectContainerInstance()
1079       : name(), description(), create_callback(nullptr),
1080         get_module_specifications(nullptr) {}
1081 
1082   ConstString name;
1083   std::string description;
1084   ObjectContainerCreateInstance create_callback;
1085   ObjectFileGetModuleSpecifications get_module_specifications;
1086 };
1087 
1088 typedef std::vector<ObjectContainerInstance> ObjectContainerInstances;
1089 
1090 static std::recursive_mutex &GetObjectContainerMutex() {
1091   static std::recursive_mutex g_instances_mutex;
1092   return g_instances_mutex;
1093 }
1094 
1095 static ObjectContainerInstances &GetObjectContainerInstances() {
1096   static ObjectContainerInstances g_instances;
1097   return g_instances;
1098 }
1099 
1100 bool PluginManager::RegisterPlugin(
1101     const ConstString &name, const char *description,
1102     ObjectContainerCreateInstance create_callback,
1103     ObjectFileGetModuleSpecifications get_module_specifications) {
1104   if (create_callback) {
1105     ObjectContainerInstance instance;
1106     assert((bool)name);
1107     instance.name = name;
1108     if (description && description[0])
1109       instance.description = description;
1110     instance.create_callback = create_callback;
1111     instance.get_module_specifications = get_module_specifications;
1112     std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
1113     GetObjectContainerInstances().push_back(instance);
1114   }
1115   return false;
1116 }
1117 
1118 bool PluginManager::UnregisterPlugin(
1119     ObjectContainerCreateInstance create_callback) {
1120   if (create_callback) {
1121     std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
1122     ObjectContainerInstances &instances = GetObjectContainerInstances();
1123 
1124     ObjectContainerInstances::iterator pos, end = instances.end();
1125     for (pos = instances.begin(); pos != end; ++pos) {
1126       if (pos->create_callback == create_callback) {
1127         instances.erase(pos);
1128         return true;
1129       }
1130     }
1131   }
1132   return false;
1133 }
1134 
1135 ObjectContainerCreateInstance
1136 PluginManager::GetObjectContainerCreateCallbackAtIndex(uint32_t idx) {
1137   std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
1138   ObjectContainerInstances &instances = GetObjectContainerInstances();
1139   if (idx < instances.size())
1140     return instances[idx].create_callback;
1141   return nullptr;
1142 }
1143 
1144 ObjectContainerCreateInstance
1145 PluginManager::GetObjectContainerCreateCallbackForPluginName(
1146     const ConstString &name) {
1147   if (name) {
1148     std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
1149     ObjectContainerInstances &instances = GetObjectContainerInstances();
1150 
1151     ObjectContainerInstances::iterator pos, end = instances.end();
1152     for (pos = instances.begin(); pos != end; ++pos) {
1153       if (name == pos->name)
1154         return pos->create_callback;
1155     }
1156   }
1157   return nullptr;
1158 }
1159 
1160 ObjectFileGetModuleSpecifications
1161 PluginManager::GetObjectContainerGetModuleSpecificationsCallbackAtIndex(
1162     uint32_t idx) {
1163   std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
1164   ObjectContainerInstances &instances = GetObjectContainerInstances();
1165   if (idx < instances.size())
1166     return instances[idx].get_module_specifications;
1167   return nullptr;
1168 }
1169 
1170 #pragma mark LogChannel
1171 
1172 struct LogInstance {
1173   LogInstance() : name(), description(), create_callback(nullptr) {}
1174 
1175   ConstString name;
1176   std::string description;
1177   LogChannelCreateInstance create_callback;
1178 };
1179 
1180 typedef std::vector<LogInstance> LogInstances;
1181 
1182 static std::recursive_mutex &GetLogMutex() {
1183   static std::recursive_mutex g_instances_mutex;
1184   return g_instances_mutex;
1185 }
1186 
1187 static LogInstances &GetLogInstances() {
1188   static LogInstances g_instances;
1189   return g_instances;
1190 }
1191 
1192 bool PluginManager::RegisterPlugin(const ConstString &name,
1193                                    const char *description,
1194                                    LogChannelCreateInstance create_callback) {
1195   if (create_callback) {
1196     LogInstance instance;
1197     assert((bool)name);
1198     instance.name = name;
1199     if (description && description[0])
1200       instance.description = description;
1201     instance.create_callback = create_callback;
1202     std::lock_guard<std::recursive_mutex> gard(GetLogMutex());
1203     GetLogInstances().push_back(instance);
1204   }
1205   return false;
1206 }
1207 
1208 bool PluginManager::UnregisterPlugin(LogChannelCreateInstance create_callback) {
1209   if (create_callback) {
1210     std::lock_guard<std::recursive_mutex> gard(GetLogMutex());
1211     LogInstances &instances = GetLogInstances();
1212 
1213     LogInstances::iterator pos, end = instances.end();
1214     for (pos = instances.begin(); pos != end; ++pos) {
1215       if (pos->create_callback == create_callback) {
1216         instances.erase(pos);
1217         return true;
1218       }
1219     }
1220   }
1221   return false;
1222 }
1223 
1224 const char *PluginManager::GetLogChannelCreateNameAtIndex(uint32_t idx) {
1225   std::lock_guard<std::recursive_mutex> gard(GetLogMutex());
1226   LogInstances &instances = GetLogInstances();
1227   if (idx < instances.size())
1228     return instances[idx].name.GetCString();
1229   return nullptr;
1230 }
1231 
1232 LogChannelCreateInstance
1233 PluginManager::GetLogChannelCreateCallbackAtIndex(uint32_t idx) {
1234   std::lock_guard<std::recursive_mutex> gard(GetLogMutex());
1235   LogInstances &instances = GetLogInstances();
1236   if (idx < instances.size())
1237     return instances[idx].create_callback;
1238   return nullptr;
1239 }
1240 
1241 LogChannelCreateInstance
1242 PluginManager::GetLogChannelCreateCallbackForPluginName(
1243     const ConstString &name) {
1244   if (name) {
1245     std::lock_guard<std::recursive_mutex> gard(GetLogMutex());
1246     LogInstances &instances = GetLogInstances();
1247 
1248     LogInstances::iterator pos, end = instances.end();
1249     for (pos = instances.begin(); pos != end; ++pos) {
1250       if (name == pos->name)
1251         return pos->create_callback;
1252     }
1253   }
1254   return nullptr;
1255 }
1256 
1257 #pragma mark Platform
1258 
1259 struct PlatformInstance {
1260   PlatformInstance()
1261       : name(), description(), create_callback(nullptr),
1262         debugger_init_callback(nullptr) {}
1263 
1264   ConstString name;
1265   std::string description;
1266   PlatformCreateInstance create_callback;
1267   DebuggerInitializeCallback debugger_init_callback;
1268 };
1269 
1270 typedef std::vector<PlatformInstance> PlatformInstances;
1271 
1272 static std::recursive_mutex &GetPlatformInstancesMutex() {
1273   static std::recursive_mutex g_platform_instances_mutex;
1274   return g_platform_instances_mutex;
1275 }
1276 
1277 static PlatformInstances &GetPlatformInstances() {
1278   static PlatformInstances g_platform_instances;
1279   return g_platform_instances;
1280 }
1281 
1282 bool PluginManager::RegisterPlugin(
1283     const ConstString &name, const char *description,
1284     PlatformCreateInstance create_callback,
1285     DebuggerInitializeCallback debugger_init_callback) {
1286   if (create_callback) {
1287     std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1288 
1289     PlatformInstance instance;
1290     assert((bool)name);
1291     instance.name = name;
1292     if (description && description[0])
1293       instance.description = description;
1294     instance.create_callback = create_callback;
1295     instance.debugger_init_callback = debugger_init_callback;
1296     GetPlatformInstances().push_back(instance);
1297     return true;
1298   }
1299   return false;
1300 }
1301 
1302 const char *PluginManager::GetPlatformPluginNameAtIndex(uint32_t idx) {
1303   std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1304   PlatformInstances &instances = GetPlatformInstances();
1305   if (idx < instances.size())
1306     return instances[idx].name.GetCString();
1307   return nullptr;
1308 }
1309 
1310 const char *PluginManager::GetPlatformPluginDescriptionAtIndex(uint32_t idx) {
1311   std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1312   PlatformInstances &instances = GetPlatformInstances();
1313   if (idx < instances.size())
1314     return instances[idx].description.c_str();
1315   return nullptr;
1316 }
1317 
1318 bool PluginManager::UnregisterPlugin(PlatformCreateInstance create_callback) {
1319   if (create_callback) {
1320     std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1321     PlatformInstances &instances = GetPlatformInstances();
1322 
1323     PlatformInstances::iterator pos, end = instances.end();
1324     for (pos = instances.begin(); pos != end; ++pos) {
1325       if (pos->create_callback == create_callback) {
1326         instances.erase(pos);
1327         return true;
1328       }
1329     }
1330   }
1331   return false;
1332 }
1333 
1334 PlatformCreateInstance
1335 PluginManager::GetPlatformCreateCallbackAtIndex(uint32_t idx) {
1336   std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1337   PlatformInstances &instances = GetPlatformInstances();
1338   if (idx < instances.size())
1339     return instances[idx].create_callback;
1340   return nullptr;
1341 }
1342 
1343 PlatformCreateInstance
1344 PluginManager::GetPlatformCreateCallbackForPluginName(const ConstString &name) {
1345   if (name) {
1346     std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1347     PlatformInstances &instances = GetPlatformInstances();
1348 
1349     PlatformInstances::iterator pos, end = instances.end();
1350     for (pos = instances.begin(); pos != end; ++pos) {
1351       if (name == pos->name)
1352         return pos->create_callback;
1353     }
1354   }
1355   return nullptr;
1356 }
1357 
1358 size_t PluginManager::AutoCompletePlatformName(llvm::StringRef name,
1359                                                StringList &matches) {
1360   if (name.empty())
1361     return matches.GetSize();
1362 
1363   std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1364   PlatformInstances &instances = GetPlatformInstances();
1365   llvm::StringRef name_sref(name);
1366 
1367   PlatformInstances::iterator pos, end = instances.end();
1368   for (pos = instances.begin(); pos != end; ++pos) {
1369     llvm::StringRef plugin_name(pos->name.GetCString());
1370     if (plugin_name.startswith(name_sref))
1371       matches.AppendString(plugin_name.data());
1372   }
1373   return matches.GetSize();
1374 }
1375 
1376 #pragma mark Process
1377 
1378 struct ProcessInstance {
1379   ProcessInstance()
1380       : name(), description(), create_callback(nullptr),
1381         debugger_init_callback(nullptr) {}
1382 
1383   ConstString name;
1384   std::string description;
1385   ProcessCreateInstance create_callback;
1386   DebuggerInitializeCallback debugger_init_callback;
1387 };
1388 
1389 typedef std::vector<ProcessInstance> ProcessInstances;
1390 
1391 static std::recursive_mutex &GetProcessMutex() {
1392   static std::recursive_mutex g_instances_mutex;
1393   return g_instances_mutex;
1394 }
1395 
1396 static ProcessInstances &GetProcessInstances() {
1397   static ProcessInstances g_instances;
1398   return g_instances;
1399 }
1400 
1401 bool PluginManager::RegisterPlugin(
1402     const ConstString &name, const char *description,
1403     ProcessCreateInstance create_callback,
1404     DebuggerInitializeCallback debugger_init_callback) {
1405   if (create_callback) {
1406     ProcessInstance instance;
1407     assert((bool)name);
1408     instance.name = name;
1409     if (description && description[0])
1410       instance.description = description;
1411     instance.create_callback = create_callback;
1412     instance.debugger_init_callback = debugger_init_callback;
1413     std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
1414     GetProcessInstances().push_back(instance);
1415   }
1416   return false;
1417 }
1418 
1419 const char *PluginManager::GetProcessPluginNameAtIndex(uint32_t idx) {
1420   std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
1421   ProcessInstances &instances = GetProcessInstances();
1422   if (idx < instances.size())
1423     return instances[idx].name.GetCString();
1424   return nullptr;
1425 }
1426 
1427 const char *PluginManager::GetProcessPluginDescriptionAtIndex(uint32_t idx) {
1428   std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
1429   ProcessInstances &instances = GetProcessInstances();
1430   if (idx < instances.size())
1431     return instances[idx].description.c_str();
1432   return nullptr;
1433 }
1434 
1435 bool PluginManager::UnregisterPlugin(ProcessCreateInstance create_callback) {
1436   if (create_callback) {
1437     std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
1438     ProcessInstances &instances = GetProcessInstances();
1439 
1440     ProcessInstances::iterator pos, end = instances.end();
1441     for (pos = instances.begin(); pos != end; ++pos) {
1442       if (pos->create_callback == create_callback) {
1443         instances.erase(pos);
1444         return true;
1445       }
1446     }
1447   }
1448   return false;
1449 }
1450 
1451 ProcessCreateInstance
1452 PluginManager::GetProcessCreateCallbackAtIndex(uint32_t idx) {
1453   std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
1454   ProcessInstances &instances = GetProcessInstances();
1455   if (idx < instances.size())
1456     return instances[idx].create_callback;
1457   return nullptr;
1458 }
1459 
1460 ProcessCreateInstance
1461 PluginManager::GetProcessCreateCallbackForPluginName(const ConstString &name) {
1462   if (name) {
1463     std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
1464     ProcessInstances &instances = GetProcessInstances();
1465 
1466     ProcessInstances::iterator pos, end = instances.end();
1467     for (pos = instances.begin(); pos != end; ++pos) {
1468       if (name == pos->name)
1469         return pos->create_callback;
1470     }
1471   }
1472   return nullptr;
1473 }
1474 
1475 #pragma mark ScriptInterpreter
1476 
1477 struct ScriptInterpreterInstance {
1478   ScriptInterpreterInstance()
1479       : name(), language(lldb::eScriptLanguageNone), description(),
1480         create_callback(nullptr) {}
1481 
1482   ConstString name;
1483   lldb::ScriptLanguage language;
1484   std::string description;
1485   ScriptInterpreterCreateInstance create_callback;
1486 };
1487 
1488 typedef std::vector<ScriptInterpreterInstance> ScriptInterpreterInstances;
1489 
1490 static std::recursive_mutex &GetScriptInterpreterMutex() {
1491   static std::recursive_mutex g_instances_mutex;
1492   return g_instances_mutex;
1493 }
1494 
1495 static ScriptInterpreterInstances &GetScriptInterpreterInstances() {
1496   static ScriptInterpreterInstances g_instances;
1497   return g_instances;
1498 }
1499 
1500 bool PluginManager::RegisterPlugin(
1501     const ConstString &name, const char *description,
1502     lldb::ScriptLanguage script_language,
1503     ScriptInterpreterCreateInstance create_callback) {
1504   if (!create_callback)
1505     return false;
1506   ScriptInterpreterInstance instance;
1507   assert((bool)name);
1508   instance.name = name;
1509   if (description && description[0])
1510     instance.description = description;
1511   instance.create_callback = create_callback;
1512   instance.language = script_language;
1513   std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
1514   GetScriptInterpreterInstances().push_back(instance);
1515   return false;
1516 }
1517 
1518 bool PluginManager::UnregisterPlugin(
1519     ScriptInterpreterCreateInstance create_callback) {
1520   if (!create_callback)
1521     return false;
1522   std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
1523   ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
1524 
1525   ScriptInterpreterInstances::iterator pos, end = instances.end();
1526   for (pos = instances.begin(); pos != end; ++pos) {
1527     if (pos->create_callback != create_callback)
1528       continue;
1529 
1530     instances.erase(pos);
1531     return true;
1532   }
1533   return false;
1534 }
1535 
1536 ScriptInterpreterCreateInstance
1537 PluginManager::GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx) {
1538   std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
1539   ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
1540   if (idx < instances.size())
1541     return instances[idx].create_callback;
1542   return nullptr;
1543 }
1544 
1545 lldb::ScriptInterpreterSP PluginManager::GetScriptInterpreterForLanguage(
1546     lldb::ScriptLanguage script_lang, CommandInterpreter &interpreter) {
1547   std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
1548   ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
1549 
1550   ScriptInterpreterInstances::iterator pos, end = instances.end();
1551   ScriptInterpreterCreateInstance none_instance = nullptr;
1552   for (pos = instances.begin(); pos != end; ++pos) {
1553     if (pos->language == lldb::eScriptLanguageNone)
1554       none_instance = pos->create_callback;
1555 
1556     if (script_lang == pos->language)
1557       return pos->create_callback(interpreter);
1558   }
1559 
1560   // If we didn't find one, return the ScriptInterpreter for the null language.
1561   assert(none_instance != nullptr);
1562   return none_instance(interpreter);
1563 }
1564 
1565 #pragma mark -
1566 #pragma mark StructuredDataPlugin
1567 
1568 // -----------------------------------------------------------------------------
1569 // StructuredDataPlugin
1570 // -----------------------------------------------------------------------------
1571 
1572 struct StructuredDataPluginInstance {
1573   StructuredDataPluginInstance()
1574       : name(), description(), create_callback(nullptr),
1575         debugger_init_callback(nullptr), filter_callback(nullptr) {}
1576 
1577   ConstString name;
1578   std::string description;
1579   StructuredDataPluginCreateInstance create_callback;
1580   DebuggerInitializeCallback debugger_init_callback;
1581   StructuredDataFilterLaunchInfo filter_callback;
1582 };
1583 
1584 typedef std::vector<StructuredDataPluginInstance> StructuredDataPluginInstances;
1585 
1586 static std::recursive_mutex &GetStructuredDataPluginMutex() {
1587   static std::recursive_mutex g_instances_mutex;
1588   return g_instances_mutex;
1589 }
1590 
1591 static StructuredDataPluginInstances &GetStructuredDataPluginInstances() {
1592   static StructuredDataPluginInstances g_instances;
1593   return g_instances;
1594 }
1595 
1596 bool PluginManager::RegisterPlugin(
1597     const ConstString &name, const char *description,
1598     StructuredDataPluginCreateInstance create_callback,
1599     DebuggerInitializeCallback debugger_init_callback,
1600     StructuredDataFilterLaunchInfo filter_callback) {
1601   if (create_callback) {
1602     StructuredDataPluginInstance instance;
1603     assert((bool)name);
1604     instance.name = name;
1605     if (description && description[0])
1606       instance.description = description;
1607     instance.create_callback = create_callback;
1608     instance.debugger_init_callback = debugger_init_callback;
1609     instance.filter_callback = filter_callback;
1610     std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
1611     GetStructuredDataPluginInstances().push_back(instance);
1612   }
1613   return false;
1614 }
1615 
1616 bool PluginManager::UnregisterPlugin(
1617     StructuredDataPluginCreateInstance create_callback) {
1618   if (create_callback) {
1619     std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
1620     StructuredDataPluginInstances &instances =
1621         GetStructuredDataPluginInstances();
1622 
1623     StructuredDataPluginInstances::iterator pos, end = instances.end();
1624     for (pos = instances.begin(); pos != end; ++pos) {
1625       if (pos->create_callback == create_callback) {
1626         instances.erase(pos);
1627         return true;
1628       }
1629     }
1630   }
1631   return false;
1632 }
1633 
1634 StructuredDataPluginCreateInstance
1635 PluginManager::GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx) {
1636   std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
1637   StructuredDataPluginInstances &instances = GetStructuredDataPluginInstances();
1638   if (idx < instances.size())
1639     return instances[idx].create_callback;
1640   return nullptr;
1641 }
1642 
1643 StructuredDataPluginCreateInstance
1644 PluginManager::GetStructuredDataPluginCreateCallbackForPluginName(
1645     const ConstString &name) {
1646   if (name) {
1647     std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
1648     StructuredDataPluginInstances &instances =
1649         GetStructuredDataPluginInstances();
1650 
1651     StructuredDataPluginInstances::iterator pos, end = instances.end();
1652     for (pos = instances.begin(); pos != end; ++pos) {
1653       if (name == pos->name)
1654         return pos->create_callback;
1655     }
1656   }
1657   return nullptr;
1658 }
1659 
1660 StructuredDataFilterLaunchInfo
1661 PluginManager::GetStructuredDataFilterCallbackAtIndex(
1662     uint32_t idx, bool &iteration_complete) {
1663   std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
1664   StructuredDataPluginInstances &instances = GetStructuredDataPluginInstances();
1665   if (idx < instances.size()) {
1666     iteration_complete = false;
1667     return instances[idx].filter_callback;
1668   } else {
1669     iteration_complete = true;
1670   }
1671   return nullptr;
1672 }
1673 
1674 #pragma mark SymbolFile
1675 
1676 struct SymbolFileInstance {
1677   SymbolFileInstance()
1678       : name(), description(), create_callback(nullptr),
1679         debugger_init_callback(nullptr) {}
1680 
1681   ConstString name;
1682   std::string description;
1683   SymbolFileCreateInstance create_callback;
1684   DebuggerInitializeCallback debugger_init_callback;
1685 };
1686 
1687 typedef std::vector<SymbolFileInstance> SymbolFileInstances;
1688 
1689 static std::recursive_mutex &GetSymbolFileMutex() {
1690   static std::recursive_mutex g_instances_mutex;
1691   return g_instances_mutex;
1692 }
1693 
1694 static SymbolFileInstances &GetSymbolFileInstances() {
1695   static SymbolFileInstances g_instances;
1696   return g_instances;
1697 }
1698 
1699 bool PluginManager::RegisterPlugin(
1700     const ConstString &name, const char *description,
1701     SymbolFileCreateInstance create_callback,
1702     DebuggerInitializeCallback debugger_init_callback) {
1703   if (create_callback) {
1704     SymbolFileInstance instance;
1705     assert((bool)name);
1706     instance.name = name;
1707     if (description && description[0])
1708       instance.description = description;
1709     instance.create_callback = create_callback;
1710     instance.debugger_init_callback = debugger_init_callback;
1711     std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
1712     GetSymbolFileInstances().push_back(instance);
1713   }
1714   return false;
1715 }
1716 
1717 bool PluginManager::UnregisterPlugin(SymbolFileCreateInstance create_callback) {
1718   if (create_callback) {
1719     std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
1720     SymbolFileInstances &instances = GetSymbolFileInstances();
1721 
1722     SymbolFileInstances::iterator pos, end = instances.end();
1723     for (pos = instances.begin(); pos != end; ++pos) {
1724       if (pos->create_callback == create_callback) {
1725         instances.erase(pos);
1726         return true;
1727       }
1728     }
1729   }
1730   return false;
1731 }
1732 
1733 SymbolFileCreateInstance
1734 PluginManager::GetSymbolFileCreateCallbackAtIndex(uint32_t idx) {
1735   std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
1736   SymbolFileInstances &instances = GetSymbolFileInstances();
1737   if (idx < instances.size())
1738     return instances[idx].create_callback;
1739   return nullptr;
1740 }
1741 
1742 SymbolFileCreateInstance
1743 PluginManager::GetSymbolFileCreateCallbackForPluginName(
1744     const ConstString &name) {
1745   if (name) {
1746     std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
1747     SymbolFileInstances &instances = GetSymbolFileInstances();
1748 
1749     SymbolFileInstances::iterator pos, end = instances.end();
1750     for (pos = instances.begin(); pos != end; ++pos) {
1751       if (name == pos->name)
1752         return pos->create_callback;
1753     }
1754   }
1755   return nullptr;
1756 }
1757 
1758 #pragma mark SymbolVendor
1759 
1760 struct SymbolVendorInstance {
1761   SymbolVendorInstance() : name(), description(), create_callback(nullptr) {}
1762 
1763   ConstString name;
1764   std::string description;
1765   SymbolVendorCreateInstance create_callback;
1766 };
1767 
1768 typedef std::vector<SymbolVendorInstance> SymbolVendorInstances;
1769 
1770 static std::recursive_mutex &GetSymbolVendorMutex() {
1771   static std::recursive_mutex g_instances_mutex;
1772   return g_instances_mutex;
1773 }
1774 
1775 static SymbolVendorInstances &GetSymbolVendorInstances() {
1776   static SymbolVendorInstances g_instances;
1777   return g_instances;
1778 }
1779 
1780 bool PluginManager::RegisterPlugin(const ConstString &name,
1781                                    const char *description,
1782                                    SymbolVendorCreateInstance create_callback) {
1783   if (create_callback) {
1784     SymbolVendorInstance instance;
1785     assert((bool)name);
1786     instance.name = name;
1787     if (description && description[0])
1788       instance.description = description;
1789     instance.create_callback = create_callback;
1790     std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
1791     GetSymbolVendorInstances().push_back(instance);
1792   }
1793   return false;
1794 }
1795 
1796 bool PluginManager::UnregisterPlugin(
1797     SymbolVendorCreateInstance create_callback) {
1798   if (create_callback) {
1799     std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
1800     SymbolVendorInstances &instances = GetSymbolVendorInstances();
1801 
1802     SymbolVendorInstances::iterator pos, end = instances.end();
1803     for (pos = instances.begin(); pos != end; ++pos) {
1804       if (pos->create_callback == create_callback) {
1805         instances.erase(pos);
1806         return true;
1807       }
1808     }
1809   }
1810   return false;
1811 }
1812 
1813 SymbolVendorCreateInstance
1814 PluginManager::GetSymbolVendorCreateCallbackAtIndex(uint32_t idx) {
1815   std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
1816   SymbolVendorInstances &instances = GetSymbolVendorInstances();
1817   if (idx < instances.size())
1818     return instances[idx].create_callback;
1819   return nullptr;
1820 }
1821 
1822 SymbolVendorCreateInstance
1823 PluginManager::GetSymbolVendorCreateCallbackForPluginName(
1824     const ConstString &name) {
1825   if (name) {
1826     std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
1827     SymbolVendorInstances &instances = GetSymbolVendorInstances();
1828 
1829     SymbolVendorInstances::iterator pos, end = instances.end();
1830     for (pos = instances.begin(); pos != end; ++pos) {
1831       if (name == pos->name)
1832         return pos->create_callback;
1833     }
1834   }
1835   return nullptr;
1836 }
1837 
1838 #pragma mark UnwindAssembly
1839 
1840 struct UnwindAssemblyInstance {
1841   UnwindAssemblyInstance() : name(), description(), create_callback(nullptr) {}
1842 
1843   ConstString name;
1844   std::string description;
1845   UnwindAssemblyCreateInstance create_callback;
1846 };
1847 
1848 typedef std::vector<UnwindAssemblyInstance> UnwindAssemblyInstances;
1849 
1850 static std::recursive_mutex &GetUnwindAssemblyMutex() {
1851   static std::recursive_mutex g_instances_mutex;
1852   return g_instances_mutex;
1853 }
1854 
1855 static UnwindAssemblyInstances &GetUnwindAssemblyInstances() {
1856   static UnwindAssemblyInstances g_instances;
1857   return g_instances;
1858 }
1859 
1860 bool PluginManager::RegisterPlugin(
1861     const ConstString &name, const char *description,
1862     UnwindAssemblyCreateInstance create_callback) {
1863   if (create_callback) {
1864     UnwindAssemblyInstance instance;
1865     assert((bool)name);
1866     instance.name = name;
1867     if (description && description[0])
1868       instance.description = description;
1869     instance.create_callback = create_callback;
1870     std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
1871     GetUnwindAssemblyInstances().push_back(instance);
1872   }
1873   return false;
1874 }
1875 
1876 bool PluginManager::UnregisterPlugin(
1877     UnwindAssemblyCreateInstance create_callback) {
1878   if (create_callback) {
1879     std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
1880     UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances();
1881 
1882     UnwindAssemblyInstances::iterator pos, end = instances.end();
1883     for (pos = instances.begin(); pos != end; ++pos) {
1884       if (pos->create_callback == create_callback) {
1885         instances.erase(pos);
1886         return true;
1887       }
1888     }
1889   }
1890   return false;
1891 }
1892 
1893 UnwindAssemblyCreateInstance
1894 PluginManager::GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx) {
1895   std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
1896   UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances();
1897   if (idx < instances.size())
1898     return instances[idx].create_callback;
1899   return nullptr;
1900 }
1901 
1902 UnwindAssemblyCreateInstance
1903 PluginManager::GetUnwindAssemblyCreateCallbackForPluginName(
1904     const ConstString &name) {
1905   if (name) {
1906     std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
1907     UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances();
1908 
1909     UnwindAssemblyInstances::iterator pos, end = instances.end();
1910     for (pos = instances.begin(); pos != end; ++pos) {
1911       if (name == pos->name)
1912         return pos->create_callback;
1913     }
1914   }
1915   return nullptr;
1916 }
1917 
1918 #pragma mark MemoryHistory
1919 
1920 struct MemoryHistoryInstance {
1921   MemoryHistoryInstance() : name(), description(), create_callback(nullptr) {}
1922 
1923   ConstString name;
1924   std::string description;
1925   MemoryHistoryCreateInstance create_callback;
1926 };
1927 
1928 typedef std::vector<MemoryHistoryInstance> MemoryHistoryInstances;
1929 
1930 static std::recursive_mutex &GetMemoryHistoryMutex() {
1931   static std::recursive_mutex g_instances_mutex;
1932   return g_instances_mutex;
1933 }
1934 
1935 static MemoryHistoryInstances &GetMemoryHistoryInstances() {
1936   static MemoryHistoryInstances g_instances;
1937   return g_instances;
1938 }
1939 
1940 bool PluginManager::RegisterPlugin(
1941     const ConstString &name, const char *description,
1942     MemoryHistoryCreateInstance create_callback) {
1943   if (create_callback) {
1944     MemoryHistoryInstance instance;
1945     assert((bool)name);
1946     instance.name = name;
1947     if (description && description[0])
1948       instance.description = description;
1949     instance.create_callback = create_callback;
1950     std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
1951     GetMemoryHistoryInstances().push_back(instance);
1952   }
1953   return false;
1954 }
1955 
1956 bool PluginManager::UnregisterPlugin(
1957     MemoryHistoryCreateInstance create_callback) {
1958   if (create_callback) {
1959     std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
1960     MemoryHistoryInstances &instances = GetMemoryHistoryInstances();
1961 
1962     MemoryHistoryInstances::iterator pos, end = instances.end();
1963     for (pos = instances.begin(); pos != end; ++pos) {
1964       if (pos->create_callback == create_callback) {
1965         instances.erase(pos);
1966         return true;
1967       }
1968     }
1969   }
1970   return false;
1971 }
1972 
1973 MemoryHistoryCreateInstance
1974 PluginManager::GetMemoryHistoryCreateCallbackAtIndex(uint32_t idx) {
1975   std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
1976   MemoryHistoryInstances &instances = GetMemoryHistoryInstances();
1977   if (idx < instances.size())
1978     return instances[idx].create_callback;
1979   return nullptr;
1980 }
1981 
1982 MemoryHistoryCreateInstance
1983 PluginManager::GetMemoryHistoryCreateCallbackForPluginName(
1984     const ConstString &name) {
1985   if (name) {
1986     std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
1987     MemoryHistoryInstances &instances = GetMemoryHistoryInstances();
1988 
1989     MemoryHistoryInstances::iterator pos, end = instances.end();
1990     for (pos = instances.begin(); pos != end; ++pos) {
1991       if (name == pos->name)
1992         return pos->create_callback;
1993     }
1994   }
1995   return nullptr;
1996 }
1997 
1998 #pragma mark InstrumentationRuntime
1999 
2000 struct InstrumentationRuntimeInstance {
2001   InstrumentationRuntimeInstance()
2002       : name(), description(), create_callback(nullptr) {}
2003 
2004   ConstString name;
2005   std::string description;
2006   InstrumentationRuntimeCreateInstance create_callback;
2007   InstrumentationRuntimeGetType get_type_callback;
2008 };
2009 
2010 typedef std::vector<InstrumentationRuntimeInstance>
2011     InstrumentationRuntimeInstances;
2012 
2013 static std::recursive_mutex &GetInstrumentationRuntimeMutex() {
2014   static std::recursive_mutex g_instances_mutex;
2015   return g_instances_mutex;
2016 }
2017 
2018 static InstrumentationRuntimeInstances &GetInstrumentationRuntimeInstances() {
2019   static InstrumentationRuntimeInstances g_instances;
2020   return g_instances;
2021 }
2022 
2023 bool PluginManager::RegisterPlugin(
2024     const ConstString &name, const char *description,
2025     InstrumentationRuntimeCreateInstance create_callback,
2026     InstrumentationRuntimeGetType get_type_callback) {
2027   if (create_callback) {
2028     InstrumentationRuntimeInstance instance;
2029     assert((bool)name);
2030     instance.name = name;
2031     if (description && description[0])
2032       instance.description = description;
2033     instance.create_callback = create_callback;
2034     instance.get_type_callback = get_type_callback;
2035     std::lock_guard<std::recursive_mutex> guard(
2036         GetInstrumentationRuntimeMutex());
2037     GetInstrumentationRuntimeInstances().push_back(instance);
2038   }
2039   return false;
2040 }
2041 
2042 bool PluginManager::UnregisterPlugin(
2043     InstrumentationRuntimeCreateInstance create_callback) {
2044   if (create_callback) {
2045     std::lock_guard<std::recursive_mutex> guard(
2046         GetInstrumentationRuntimeMutex());
2047     InstrumentationRuntimeInstances &instances =
2048         GetInstrumentationRuntimeInstances();
2049 
2050     InstrumentationRuntimeInstances::iterator pos, end = instances.end();
2051     for (pos = instances.begin(); pos != end; ++pos) {
2052       if (pos->create_callback == create_callback) {
2053         instances.erase(pos);
2054         return true;
2055       }
2056     }
2057   }
2058   return false;
2059 }
2060 
2061 InstrumentationRuntimeGetType
2062 PluginManager::GetInstrumentationRuntimeGetTypeCallbackAtIndex(uint32_t idx) {
2063   std::lock_guard<std::recursive_mutex> guard(GetInstrumentationRuntimeMutex());
2064   InstrumentationRuntimeInstances &instances =
2065       GetInstrumentationRuntimeInstances();
2066   if (idx < instances.size())
2067     return instances[idx].get_type_callback;
2068   return nullptr;
2069 }
2070 
2071 InstrumentationRuntimeCreateInstance
2072 PluginManager::GetInstrumentationRuntimeCreateCallbackAtIndex(uint32_t idx) {
2073   std::lock_guard<std::recursive_mutex> guard(GetInstrumentationRuntimeMutex());
2074   InstrumentationRuntimeInstances &instances =
2075       GetInstrumentationRuntimeInstances();
2076   if (idx < instances.size())
2077     return instances[idx].create_callback;
2078   return nullptr;
2079 }
2080 
2081 InstrumentationRuntimeCreateInstance
2082 PluginManager::GetInstrumentationRuntimeCreateCallbackForPluginName(
2083     const ConstString &name) {
2084   if (name) {
2085     std::lock_guard<std::recursive_mutex> guard(
2086         GetInstrumentationRuntimeMutex());
2087     InstrumentationRuntimeInstances &instances =
2088         GetInstrumentationRuntimeInstances();
2089 
2090     InstrumentationRuntimeInstances::iterator pos, end = instances.end();
2091     for (pos = instances.begin(); pos != end; ++pos) {
2092       if (name == pos->name)
2093         return pos->create_callback;
2094     }
2095   }
2096   return nullptr;
2097 }
2098 
2099 #pragma mark TypeSystem
2100 
2101 struct TypeSystemInstance {
2102   TypeSystemInstance() : name(), description(), create_callback(nullptr) {}
2103 
2104   ConstString name;
2105   std::string description;
2106   TypeSystemCreateInstance create_callback;
2107   TypeSystemEnumerateSupportedLanguages enumerate_callback;
2108 };
2109 
2110 typedef std::vector<TypeSystemInstance> TypeSystemInstances;
2111 
2112 static std::recursive_mutex &GetTypeSystemMutex() {
2113   static std::recursive_mutex g_instances_mutex;
2114   return g_instances_mutex;
2115 }
2116 
2117 static TypeSystemInstances &GetTypeSystemInstances() {
2118   static TypeSystemInstances g_instances;
2119   return g_instances;
2120 }
2121 
2122 bool PluginManager::RegisterPlugin(const ConstString &name,
2123                                    const char *description,
2124                                    TypeSystemCreateInstance create_callback,
2125                                    TypeSystemEnumerateSupportedLanguages
2126                                        enumerate_supported_languages_callback) {
2127   if (create_callback) {
2128     TypeSystemInstance instance;
2129     assert((bool)name);
2130     instance.name = name;
2131     if (description && description[0])
2132       instance.description = description;
2133     instance.create_callback = create_callback;
2134     instance.enumerate_callback = enumerate_supported_languages_callback;
2135     std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
2136     GetTypeSystemInstances().push_back(instance);
2137   }
2138   return false;
2139 }
2140 
2141 bool PluginManager::UnregisterPlugin(TypeSystemCreateInstance create_callback) {
2142   if (create_callback) {
2143     std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
2144     TypeSystemInstances &instances = GetTypeSystemInstances();
2145 
2146     TypeSystemInstances::iterator pos, end = instances.end();
2147     for (pos = instances.begin(); pos != end; ++pos) {
2148       if (pos->create_callback == create_callback) {
2149         instances.erase(pos);
2150         return true;
2151       }
2152     }
2153   }
2154   return false;
2155 }
2156 
2157 TypeSystemCreateInstance
2158 PluginManager::GetTypeSystemCreateCallbackAtIndex(uint32_t idx) {
2159   std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
2160   TypeSystemInstances &instances = GetTypeSystemInstances();
2161   if (idx < instances.size())
2162     return instances[idx].create_callback;
2163   return nullptr;
2164 }
2165 
2166 TypeSystemCreateInstance
2167 PluginManager::GetTypeSystemCreateCallbackForPluginName(
2168     const ConstString &name) {
2169   if (name) {
2170     std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
2171     TypeSystemInstances &instances = GetTypeSystemInstances();
2172 
2173     TypeSystemInstances::iterator pos, end = instances.end();
2174     for (pos = instances.begin(); pos != end; ++pos) {
2175       if (name == pos->name)
2176         return pos->create_callback;
2177     }
2178   }
2179   return nullptr;
2180 }
2181 
2182 TypeSystemEnumerateSupportedLanguages
2183 PluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(
2184     uint32_t idx) {
2185   std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
2186   TypeSystemInstances &instances = GetTypeSystemInstances();
2187   if (idx < instances.size())
2188     return instances[idx].enumerate_callback;
2189   return nullptr;
2190 }
2191 
2192 TypeSystemEnumerateSupportedLanguages
2193 PluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackForPluginName(
2194     const ConstString &name) {
2195   if (name) {
2196     std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
2197     TypeSystemInstances &instances = GetTypeSystemInstances();
2198 
2199     TypeSystemInstances::iterator pos, end = instances.end();
2200     for (pos = instances.begin(); pos != end; ++pos) {
2201       if (name == pos->name)
2202         return pos->enumerate_callback;
2203     }
2204   }
2205   return nullptr;
2206 }
2207 
2208 #pragma mark REPL
2209 
2210 struct REPLInstance {
2211   REPLInstance() : name(), description(), create_callback(nullptr) {}
2212 
2213   ConstString name;
2214   std::string description;
2215   REPLCreateInstance create_callback;
2216   REPLEnumerateSupportedLanguages enumerate_languages_callback;
2217 };
2218 
2219 typedef std::vector<REPLInstance> REPLInstances;
2220 
2221 static std::recursive_mutex &GetREPLMutex() {
2222   static std::recursive_mutex g_instances_mutex;
2223   return g_instances_mutex;
2224 }
2225 
2226 static REPLInstances &GetREPLInstances() {
2227   static REPLInstances g_instances;
2228   return g_instances;
2229 }
2230 
2231 bool PluginManager::RegisterPlugin(
2232     const ConstString &name, const char *description,
2233     REPLCreateInstance create_callback,
2234     REPLEnumerateSupportedLanguages enumerate_languages_callback) {
2235   if (create_callback) {
2236     REPLInstance instance;
2237     assert((bool)name);
2238     instance.name = name;
2239     if (description && description[0])
2240       instance.description = description;
2241     instance.create_callback = create_callback;
2242     instance.enumerate_languages_callback = enumerate_languages_callback;
2243     std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
2244     GetREPLInstances().push_back(instance);
2245   }
2246   return false;
2247 }
2248 
2249 bool PluginManager::UnregisterPlugin(REPLCreateInstance create_callback) {
2250   if (create_callback) {
2251     std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
2252     REPLInstances &instances = GetREPLInstances();
2253 
2254     REPLInstances::iterator pos, end = instances.end();
2255     for (pos = instances.begin(); pos != end; ++pos) {
2256       if (pos->create_callback == create_callback) {
2257         instances.erase(pos);
2258         return true;
2259       }
2260     }
2261   }
2262   return false;
2263 }
2264 
2265 REPLCreateInstance PluginManager::GetREPLCreateCallbackAtIndex(uint32_t idx) {
2266   std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
2267   REPLInstances &instances = GetREPLInstances();
2268   if (idx < instances.size())
2269     return instances[idx].create_callback;
2270   return nullptr;
2271 }
2272 
2273 REPLCreateInstance
2274 PluginManager::GetREPLCreateCallbackForPluginName(const ConstString &name) {
2275   if (name) {
2276     std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
2277     REPLInstances &instances = GetREPLInstances();
2278 
2279     REPLInstances::iterator pos, end = instances.end();
2280     for (pos = instances.begin(); pos != end; ++pos) {
2281       if (name == pos->name)
2282         return pos->create_callback;
2283     }
2284   }
2285   return nullptr;
2286 }
2287 
2288 REPLEnumerateSupportedLanguages
2289 PluginManager::GetREPLEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx) {
2290   std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
2291   REPLInstances &instances = GetREPLInstances();
2292   if (idx < instances.size())
2293     return instances[idx].enumerate_languages_callback;
2294   return nullptr;
2295 }
2296 
2297 REPLEnumerateSupportedLanguages
2298 PluginManager::GetREPLSystemEnumerateSupportedLanguagesCallbackForPluginName(
2299     const ConstString &name) {
2300   if (name) {
2301     std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
2302     REPLInstances &instances = GetREPLInstances();
2303 
2304     REPLInstances::iterator pos, end = instances.end();
2305     for (pos = instances.begin(); pos != end; ++pos) {
2306       if (name == pos->name)
2307         return pos->enumerate_languages_callback;
2308     }
2309   }
2310   return nullptr;
2311 }
2312 
2313 #pragma mark PluginManager
2314 
2315 void PluginManager::DebuggerInitialize(Debugger &debugger) {
2316   // Initialize the DynamicLoader plugins
2317   {
2318     std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
2319     DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
2320 
2321     DynamicLoaderInstances::iterator pos, end = instances.end();
2322     for (pos = instances.begin(); pos != end; ++pos) {
2323       if (pos->debugger_init_callback)
2324         pos->debugger_init_callback(debugger);
2325     }
2326   }
2327 
2328   // Initialize the JITLoader plugins
2329   {
2330     std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
2331     JITLoaderInstances &instances = GetJITLoaderInstances();
2332 
2333     JITLoaderInstances::iterator pos, end = instances.end();
2334     for (pos = instances.begin(); pos != end; ++pos) {
2335       if (pos->debugger_init_callback)
2336         pos->debugger_init_callback(debugger);
2337     }
2338   }
2339 
2340   // Initialize the Platform plugins
2341   {
2342     std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
2343     PlatformInstances &instances = GetPlatformInstances();
2344 
2345     PlatformInstances::iterator pos, end = instances.end();
2346     for (pos = instances.begin(); pos != end; ++pos) {
2347       if (pos->debugger_init_callback)
2348         pos->debugger_init_callback(debugger);
2349     }
2350   }
2351 
2352   // Initialize the Process plugins
2353   {
2354     std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
2355     ProcessInstances &instances = GetProcessInstances();
2356 
2357     ProcessInstances::iterator pos, end = instances.end();
2358     for (pos = instances.begin(); pos != end; ++pos) {
2359       if (pos->debugger_init_callback)
2360         pos->debugger_init_callback(debugger);
2361     }
2362   }
2363 
2364   // Initialize the SymbolFile plugins
2365   {
2366     std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
2367     for (auto &sym_file : GetSymbolFileInstances()) {
2368       if (sym_file.debugger_init_callback)
2369         sym_file.debugger_init_callback(debugger);
2370     }
2371   }
2372 
2373   // Initialize the OperatingSystem plugins
2374   {
2375     std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
2376     for (auto &os : GetOperatingSystemInstances()) {
2377       if (os.debugger_init_callback)
2378         os.debugger_init_callback(debugger);
2379     }
2380   }
2381 
2382   // Initialize the StructuredDataPlugin plugins
2383   {
2384     std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
2385     for (auto &plugin : GetStructuredDataPluginInstances()) {
2386       if (plugin.debugger_init_callback)
2387         plugin.debugger_init_callback(debugger);
2388     }
2389   }
2390 }
2391 
2392 // This is the preferred new way to register plugin specific settings.  e.g.
2393 // This will put a plugin's settings under e.g.
2394 // "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".
2395 static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPlugins(
2396     Debugger &debugger, const ConstString &plugin_type_name,
2397     const ConstString &plugin_type_desc, bool can_create) {
2398   lldb::OptionValuePropertiesSP parent_properties_sp(
2399       debugger.GetValueProperties());
2400   if (parent_properties_sp) {
2401     static ConstString g_property_name("plugin");
2402 
2403     OptionValuePropertiesSP plugin_properties_sp =
2404         parent_properties_sp->GetSubProperty(nullptr, g_property_name);
2405     if (!plugin_properties_sp && can_create) {
2406       plugin_properties_sp.reset(new OptionValueProperties(g_property_name));
2407       parent_properties_sp->AppendProperty(
2408           g_property_name, ConstString("Settings specify to plugins."), true,
2409           plugin_properties_sp);
2410     }
2411 
2412     if (plugin_properties_sp) {
2413       lldb::OptionValuePropertiesSP plugin_type_properties_sp =
2414           plugin_properties_sp->GetSubProperty(nullptr, plugin_type_name);
2415       if (!plugin_type_properties_sp && can_create) {
2416         plugin_type_properties_sp.reset(
2417             new OptionValueProperties(plugin_type_name));
2418         plugin_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
2419                                              true, plugin_type_properties_sp);
2420       }
2421       return plugin_type_properties_sp;
2422     }
2423   }
2424   return lldb::OptionValuePropertiesSP();
2425 }
2426 
2427 // This is deprecated way to register plugin specific settings.  e.g.
2428 // "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME"
2429 // and Platform generic settings would be under "platform.SETTINGNAME".
2430 static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle(
2431     Debugger &debugger, const ConstString &plugin_type_name,
2432     const ConstString &plugin_type_desc, bool can_create) {
2433   static ConstString g_property_name("plugin");
2434   lldb::OptionValuePropertiesSP parent_properties_sp(
2435       debugger.GetValueProperties());
2436   if (parent_properties_sp) {
2437     OptionValuePropertiesSP plugin_properties_sp =
2438         parent_properties_sp->GetSubProperty(nullptr, plugin_type_name);
2439     if (!plugin_properties_sp && can_create) {
2440       plugin_properties_sp.reset(new OptionValueProperties(plugin_type_name));
2441       parent_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
2442                                            true, plugin_properties_sp);
2443     }
2444 
2445     if (plugin_properties_sp) {
2446       lldb::OptionValuePropertiesSP plugin_type_properties_sp =
2447           plugin_properties_sp->GetSubProperty(nullptr, g_property_name);
2448       if (!plugin_type_properties_sp && can_create) {
2449         plugin_type_properties_sp.reset(
2450             new OptionValueProperties(g_property_name));
2451         plugin_properties_sp->AppendProperty(
2452             g_property_name, ConstString("Settings specific to plugins"), true,
2453             plugin_type_properties_sp);
2454       }
2455       return plugin_type_properties_sp;
2456     }
2457   }
2458   return lldb::OptionValuePropertiesSP();
2459 }
2460 
2461 namespace {
2462 
2463 typedef lldb::OptionValuePropertiesSP
2464 GetDebuggerPropertyForPluginsPtr(Debugger &, const ConstString &,
2465                                  const ConstString &, bool can_create);
2466 
2467 lldb::OptionValuePropertiesSP
2468 GetSettingForPlugin(Debugger &debugger, const ConstString &setting_name,
2469                     const ConstString &plugin_type_name,
2470                     GetDebuggerPropertyForPluginsPtr get_debugger_property =
2471                         GetDebuggerPropertyForPlugins) {
2472   lldb::OptionValuePropertiesSP properties_sp;
2473   lldb::OptionValuePropertiesSP plugin_type_properties_sp(get_debugger_property(
2474       debugger, plugin_type_name,
2475       ConstString(), // not creating to so we don't need the description
2476       false));
2477   if (plugin_type_properties_sp)
2478     properties_sp =
2479         plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
2480   return properties_sp;
2481 }
2482 
2483 bool CreateSettingForPlugin(
2484     Debugger &debugger, const ConstString &plugin_type_name,
2485     const ConstString &plugin_type_desc,
2486     const lldb::OptionValuePropertiesSP &properties_sp,
2487     const ConstString &description, bool is_global_property,
2488     GetDebuggerPropertyForPluginsPtr get_debugger_property =
2489         GetDebuggerPropertyForPlugins) {
2490   if (properties_sp) {
2491     lldb::OptionValuePropertiesSP plugin_type_properties_sp(
2492         get_debugger_property(debugger, plugin_type_name, plugin_type_desc,
2493                               true));
2494     if (plugin_type_properties_sp) {
2495       plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
2496                                                 description, is_global_property,
2497                                                 properties_sp);
2498       return true;
2499     }
2500   }
2501   return false;
2502 }
2503 
2504 const char *kDynamicLoaderPluginName("dynamic-loader");
2505 const char *kPlatformPluginName("platform");
2506 const char *kProcessPluginName("process");
2507 const char *kSymbolFilePluginName("symbol-file");
2508 const char *kJITLoaderPluginName("jit-loader");
2509 const char *kStructuredDataPluginName("structured-data");
2510 
2511 } // anonymous namespace
2512 
2513 lldb::OptionValuePropertiesSP PluginManager::GetSettingForDynamicLoaderPlugin(
2514     Debugger &debugger, const ConstString &setting_name) {
2515   return GetSettingForPlugin(debugger, setting_name,
2516                              ConstString(kDynamicLoaderPluginName));
2517 }
2518 
2519 bool PluginManager::CreateSettingForDynamicLoaderPlugin(
2520     Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
2521     const ConstString &description, bool is_global_property) {
2522   return CreateSettingForPlugin(
2523       debugger, ConstString(kDynamicLoaderPluginName),
2524       ConstString("Settings for dynamic loader plug-ins"), properties_sp,
2525       description, is_global_property);
2526 }
2527 
2528 lldb::OptionValuePropertiesSP
2529 PluginManager::GetSettingForPlatformPlugin(Debugger &debugger,
2530                                            const ConstString &setting_name) {
2531   return GetSettingForPlugin(debugger, setting_name,
2532                              ConstString(kPlatformPluginName),
2533                              GetDebuggerPropertyForPluginsOldStyle);
2534 }
2535 
2536 bool PluginManager::CreateSettingForPlatformPlugin(
2537     Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
2538     const ConstString &description, bool is_global_property) {
2539   return CreateSettingForPlugin(debugger, ConstString(kPlatformPluginName),
2540                                 ConstString("Settings for platform plug-ins"),
2541                                 properties_sp, description, is_global_property,
2542                                 GetDebuggerPropertyForPluginsOldStyle);
2543 }
2544 
2545 lldb::OptionValuePropertiesSP
2546 PluginManager::GetSettingForProcessPlugin(Debugger &debugger,
2547                                           const ConstString &setting_name) {
2548   return GetSettingForPlugin(debugger, setting_name,
2549                              ConstString(kProcessPluginName));
2550 }
2551 
2552 bool PluginManager::CreateSettingForProcessPlugin(
2553     Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
2554     const ConstString &description, bool is_global_property) {
2555   return CreateSettingForPlugin(debugger, ConstString(kProcessPluginName),
2556                                 ConstString("Settings for process plug-ins"),
2557                                 properties_sp, description, is_global_property);
2558 }
2559 
2560 lldb::OptionValuePropertiesSP
2561 PluginManager::GetSettingForSymbolFilePlugin(Debugger &debugger,
2562                                              const ConstString &setting_name) {
2563   return GetSettingForPlugin(debugger, setting_name,
2564                              ConstString(kSymbolFilePluginName));
2565 }
2566 
2567 bool PluginManager::CreateSettingForSymbolFilePlugin(
2568     Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
2569     const ConstString &description, bool is_global_property) {
2570   return CreateSettingForPlugin(
2571       debugger, ConstString(kSymbolFilePluginName),
2572       ConstString("Settings for symbol file plug-ins"), properties_sp,
2573       description, is_global_property);
2574 }
2575 
2576 lldb::OptionValuePropertiesSP
2577 PluginManager::GetSettingForJITLoaderPlugin(Debugger &debugger,
2578                                             const ConstString &setting_name) {
2579   return GetSettingForPlugin(debugger, setting_name,
2580                              ConstString(kJITLoaderPluginName));
2581 }
2582 
2583 bool PluginManager::CreateSettingForJITLoaderPlugin(
2584     Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
2585     const ConstString &description, bool is_global_property) {
2586   return CreateSettingForPlugin(debugger, ConstString(kJITLoaderPluginName),
2587                                 ConstString("Settings for JIT loader plug-ins"),
2588                                 properties_sp, description, is_global_property);
2589 }
2590 
2591 static const char *kOperatingSystemPluginName("os");
2592 
2593 lldb::OptionValuePropertiesSP PluginManager::GetSettingForOperatingSystemPlugin(
2594     Debugger &debugger, const ConstString &setting_name) {
2595   lldb::OptionValuePropertiesSP properties_sp;
2596   lldb::OptionValuePropertiesSP plugin_type_properties_sp(
2597       GetDebuggerPropertyForPlugins(
2598           debugger, ConstString(kOperatingSystemPluginName),
2599           ConstString(), // not creating to so we don't need the description
2600           false));
2601   if (plugin_type_properties_sp)
2602     properties_sp =
2603         plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
2604   return properties_sp;
2605 }
2606 
2607 bool PluginManager::CreateSettingForOperatingSystemPlugin(
2608     Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
2609     const ConstString &description, bool is_global_property) {
2610   if (properties_sp) {
2611     lldb::OptionValuePropertiesSP plugin_type_properties_sp(
2612         GetDebuggerPropertyForPlugins(
2613             debugger, ConstString(kOperatingSystemPluginName),
2614             ConstString("Settings for operating system plug-ins"), true));
2615     if (plugin_type_properties_sp) {
2616       plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
2617                                                 description, is_global_property,
2618                                                 properties_sp);
2619       return true;
2620     }
2621   }
2622   return false;
2623 }
2624 
2625 lldb::OptionValuePropertiesSP PluginManager::GetSettingForStructuredDataPlugin(
2626     Debugger &debugger, const ConstString &setting_name) {
2627   return GetSettingForPlugin(debugger, setting_name,
2628                              ConstString(kStructuredDataPluginName));
2629 }
2630 
2631 bool PluginManager::CreateSettingForStructuredDataPlugin(
2632     Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
2633     const ConstString &description, bool is_global_property) {
2634   return CreateSettingForPlugin(
2635       debugger, ConstString(kStructuredDataPluginName),
2636       ConstString("Settings for structured data plug-ins"), properties_sp,
2637       description, is_global_property);
2638 }
2639