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/lldb-python.h"
11 
12 #include "lldb/Core/PluginManager.h"
13 
14 #include <limits.h>
15 
16 #include <string>
17 #include <vector>
18 
19 #include "lldb/Core/Debugger.h"
20 #include "lldb/Core/Error.h"
21 #include "lldb/Host/FileSpec.h"
22 #include "lldb/Host/Host.h"
23 #include "lldb/Host/Mutex.h"
24 #include "lldb/Interpreter/OptionValueProperties.h"
25 
26 #include "llvm/ADT/StringRef.h"
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 
31 enum PluginAction
32 {
33     ePluginRegisterInstance,
34     ePluginUnregisterInstance,
35     ePluginGetInstanceAtIndex
36 };
37 
38 
39 typedef bool (*PluginInitCallback) (void);
40 typedef void (*PluginTermCallback) (void);
41 
42 struct PluginInfo
43 {
44     void *plugin_handle;
45     PluginInitCallback plugin_init_callback;
46     PluginTermCallback plugin_term_callback;
47 };
48 
49 typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;
50 
51 static Mutex &
52 GetPluginMapMutex ()
53 {
54     static Mutex g_plugin_map_mutex (Mutex::eMutexTypeRecursive);
55     return g_plugin_map_mutex;
56 }
57 
58 static PluginTerminateMap &
59 GetPluginMap ()
60 {
61     static PluginTerminateMap g_plugin_map;
62     return g_plugin_map;
63 }
64 
65 static bool
66 PluginIsLoaded (const FileSpec &plugin_file_spec)
67 {
68     Mutex::Locker locker (GetPluginMapMutex ());
69     PluginTerminateMap &plugin_map = GetPluginMap ();
70     return plugin_map.find (plugin_file_spec) != plugin_map.end();
71 }
72 
73 static void
74 SetPluginInfo (const FileSpec &plugin_file_spec, const PluginInfo &plugin_info)
75 {
76     Mutex::Locker locker (GetPluginMapMutex ());
77     PluginTerminateMap &plugin_map = GetPluginMap ();
78     assert (plugin_map.find (plugin_file_spec) == plugin_map.end());
79     plugin_map[plugin_file_spec] = plugin_info;
80 }
81 
82 
83 static FileSpec::EnumerateDirectoryResult
84 LoadPluginCallback
85 (
86     void *baton,
87     FileSpec::FileType file_type,
88     const FileSpec &file_spec
89 )
90 {
91 //    PluginManager *plugin_manager = (PluginManager *)baton;
92     Error error;
93 
94     // If we have a regular file, a symbolic link or unknown file type, try
95     // and process the file. We must handle unknown as sometimes the directory
96     // enumeration might be enumerating a file system that doesn't have correct
97     // file type information.
98     if (file_type == FileSpec::eFileTypeRegular         ||
99         file_type == FileSpec::eFileTypeSymbolicLink    ||
100         file_type == FileSpec::eFileTypeUnknown          )
101     {
102         FileSpec plugin_file_spec (file_spec);
103         plugin_file_spec.ResolvePath();
104 
105         if (PluginIsLoaded (plugin_file_spec))
106             return FileSpec::eEnumerateDirectoryResultNext;
107         else
108         {
109             PluginInfo plugin_info = { NULL, NULL, NULL };
110             uint32_t flags = Host::eDynamicLibraryOpenOptionLazy |
111                              Host::eDynamicLibraryOpenOptionLocal |
112                              Host::eDynamicLibraryOpenOptionLimitGetSymbol;
113 
114             plugin_info.plugin_handle = Host::DynamicLibraryOpen (plugin_file_spec, flags, error);
115             if (plugin_info.plugin_handle)
116             {
117                 bool success = false;
118                 plugin_info.plugin_init_callback = (PluginInitCallback)Host::DynamicLibraryGetSymbol (plugin_info.plugin_handle, "LLDBPluginInitialize", error);
119                 if (plugin_info.plugin_init_callback)
120                 {
121                     // Call the plug-in "bool LLDBPluginInitialize(void)" function
122                     success = plugin_info.plugin_init_callback();
123                 }
124 
125                 if (success)
126                 {
127                     // It is ok for the "LLDBPluginTerminate" symbol to be NULL
128                     plugin_info.plugin_term_callback = (PluginTermCallback)Host::DynamicLibraryGetSymbol (plugin_info.plugin_handle, "LLDBPluginTerminate", error);
129                 }
130                 else
131                 {
132                     // The initialize function returned FALSE which means the
133                     // plug-in might not be compatible, or might be too new or
134                     // too old, or might not want to run on this machine.
135                     Host::DynamicLibraryClose (plugin_info.plugin_handle);
136                     plugin_info.plugin_handle = NULL;
137                     plugin_info.plugin_init_callback = NULL;
138                 }
139 
140                 // Regardless of success or failure, cache the plug-in load
141                 // in our plug-in info so we don't try to load it again and
142                 // again.
143                 SetPluginInfo (plugin_file_spec, plugin_info);
144 
145                 return FileSpec::eEnumerateDirectoryResultNext;
146             }
147         }
148     }
149 
150     if (file_type == FileSpec::eFileTypeUnknown     ||
151         file_type == FileSpec::eFileTypeDirectory   ||
152         file_type == FileSpec::eFileTypeSymbolicLink )
153     {
154         // Try and recurse into anything that a directory or symbolic link.
155         // We must also do this for unknown as sometimes the directory enumeration
156         // might be enurating a file system that doesn't have correct file type
157         // information.
158         return FileSpec::eEnumerateDirectoryResultEnter;
159     }
160 
161     return FileSpec::eEnumerateDirectoryResultNext;
162 }
163 
164 
165 void
166 PluginManager::Initialize ()
167 {
168 #if 1
169     FileSpec dir_spec;
170     const bool find_directories = true;
171     const bool find_files = true;
172     const bool find_other = true;
173     char dir_path[PATH_MAX];
174     if (Host::GetLLDBPath (ePathTypeLLDBSystemPlugins, dir_spec))
175     {
176         if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path)))
177         {
178             FileSpec::EnumerateDirectory (dir_path,
179                                           find_directories,
180                                           find_files,
181                                           find_other,
182                                           LoadPluginCallback,
183                                           NULL);
184         }
185     }
186 
187     if (Host::GetLLDBPath (ePathTypeLLDBUserPlugins, dir_spec))
188     {
189         if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path)))
190         {
191             FileSpec::EnumerateDirectory (dir_path,
192                                           find_directories,
193                                           find_files,
194                                           find_other,
195                                           LoadPluginCallback,
196                                           NULL);
197         }
198     }
199 #endif
200 }
201 
202 void
203 PluginManager::Terminate ()
204 {
205     Mutex::Locker locker (GetPluginMapMutex ());
206     PluginTerminateMap &plugin_map = GetPluginMap ();
207 
208     PluginTerminateMap::const_iterator pos, end = plugin_map.end();
209     for (pos = plugin_map.begin(); pos != end; ++pos)
210     {
211         // Call the plug-in "void LLDBPluginTerminate (void)" function if there
212         // is one (if the symbol was not NULL).
213         if (pos->second.plugin_handle)
214         {
215             if (pos->second.plugin_term_callback)
216                 pos->second.plugin_term_callback();
217             Host::DynamicLibraryClose (pos->second.plugin_handle);
218         }
219     }
220     plugin_map.clear();
221 }
222 
223 
224 #pragma mark ABI
225 
226 
227 struct ABIInstance
228 {
229     ABIInstance() :
230         name(),
231         description(),
232         create_callback(NULL)
233     {
234     }
235 
236     ConstString name;
237     std::string description;
238     ABICreateInstance create_callback;
239 };
240 
241 typedef std::vector<ABIInstance> ABIInstances;
242 
243 static Mutex &
244 GetABIInstancesMutex ()
245 {
246     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
247     return g_instances_mutex;
248 }
249 
250 static ABIInstances &
251 GetABIInstances ()
252 {
253     static ABIInstances g_instances;
254     return g_instances;
255 }
256 
257 bool
258 PluginManager::RegisterPlugin
259 (
260     const ConstString &name,
261     const char *description,
262     ABICreateInstance create_callback
263 )
264 {
265     if (create_callback)
266     {
267         ABIInstance instance;
268         assert ((bool)name);
269         instance.name = name;
270         if (description && description[0])
271             instance.description = description;
272         instance.create_callback = create_callback;
273         Mutex::Locker locker (GetABIInstancesMutex ());
274         GetABIInstances ().push_back (instance);
275         return true;
276     }
277     return false;
278 }
279 
280 bool
281 PluginManager::UnregisterPlugin (ABICreateInstance create_callback)
282 {
283     if (create_callback)
284     {
285         Mutex::Locker locker (GetABIInstancesMutex ());
286         ABIInstances &instances = GetABIInstances ();
287 
288         ABIInstances::iterator pos, end = instances.end();
289         for (pos = instances.begin(); pos != end; ++ pos)
290         {
291             if (pos->create_callback == create_callback)
292             {
293                 instances.erase(pos);
294                 return true;
295             }
296         }
297     }
298     return false;
299 }
300 
301 ABICreateInstance
302 PluginManager::GetABICreateCallbackAtIndex (uint32_t idx)
303 {
304     Mutex::Locker locker (GetABIInstancesMutex ());
305     ABIInstances &instances = GetABIInstances ();
306     if (idx < instances.size())
307         return instances[idx].create_callback;
308     return NULL;
309 }
310 
311 ABICreateInstance
312 PluginManager::GetABICreateCallbackForPluginName (const ConstString &name)
313 {
314     if (name)
315     {
316         Mutex::Locker locker (GetABIInstancesMutex ());
317         ABIInstances &instances = GetABIInstances ();
318 
319         ABIInstances::iterator pos, end = instances.end();
320         for (pos = instances.begin(); pos != end; ++ pos)
321         {
322             if (name == pos->name)
323                 return pos->create_callback;
324         }
325     }
326     return NULL;
327 }
328 
329 
330 #pragma mark Disassembler
331 
332 
333 struct DisassemblerInstance
334 {
335     DisassemblerInstance() :
336         name(),
337         description(),
338         create_callback(NULL)
339     {
340     }
341 
342     ConstString name;
343     std::string description;
344     DisassemblerCreateInstance create_callback;
345 };
346 
347 typedef std::vector<DisassemblerInstance> DisassemblerInstances;
348 
349 static Mutex &
350 GetDisassemblerMutex ()
351 {
352     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
353     return g_instances_mutex;
354 }
355 
356 static DisassemblerInstances &
357 GetDisassemblerInstances ()
358 {
359     static DisassemblerInstances g_instances;
360     return g_instances;
361 }
362 
363 bool
364 PluginManager::RegisterPlugin
365 (
366     const ConstString &name,
367     const char *description,
368     DisassemblerCreateInstance create_callback
369 )
370 {
371     if (create_callback)
372     {
373         DisassemblerInstance instance;
374         assert ((bool)name);
375         instance.name = name;
376         if (description && description[0])
377             instance.description = description;
378         instance.create_callback = create_callback;
379         Mutex::Locker locker (GetDisassemblerMutex ());
380         GetDisassemblerInstances ().push_back (instance);
381         return true;
382     }
383     return false;
384 }
385 
386 bool
387 PluginManager::UnregisterPlugin (DisassemblerCreateInstance create_callback)
388 {
389     if (create_callback)
390     {
391         Mutex::Locker locker (GetDisassemblerMutex ());
392         DisassemblerInstances &instances = GetDisassemblerInstances ();
393 
394         DisassemblerInstances::iterator pos, end = instances.end();
395         for (pos = instances.begin(); pos != end; ++ pos)
396         {
397             if (pos->create_callback == create_callback)
398             {
399                 instances.erase(pos);
400                 return true;
401             }
402         }
403     }
404     return false;
405 }
406 
407 DisassemblerCreateInstance
408 PluginManager::GetDisassemblerCreateCallbackAtIndex (uint32_t idx)
409 {
410     Mutex::Locker locker (GetDisassemblerMutex ());
411     DisassemblerInstances &instances = GetDisassemblerInstances ();
412     if (idx < instances.size())
413         return instances[idx].create_callback;
414     return NULL;
415 }
416 
417 DisassemblerCreateInstance
418 PluginManager::GetDisassemblerCreateCallbackForPluginName (const ConstString &name)
419 {
420     if (name)
421     {
422         Mutex::Locker locker (GetDisassemblerMutex ());
423         DisassemblerInstances &instances = GetDisassemblerInstances ();
424 
425         DisassemblerInstances::iterator pos, end = instances.end();
426         for (pos = instances.begin(); pos != end; ++ pos)
427         {
428             if (name == pos->name)
429                 return pos->create_callback;
430         }
431     }
432     return NULL;
433 }
434 
435 
436 
437 #pragma mark DynamicLoader
438 
439 
440 struct DynamicLoaderInstance
441 {
442     DynamicLoaderInstance() :
443         name(),
444         description(),
445         create_callback(NULL),
446         debugger_init_callback (NULL)
447     {
448     }
449 
450     ConstString name;
451     std::string description;
452     DynamicLoaderCreateInstance create_callback;
453     DebuggerInitializeCallback debugger_init_callback;
454 };
455 
456 typedef std::vector<DynamicLoaderInstance> DynamicLoaderInstances;
457 
458 
459 static Mutex &
460 GetDynamicLoaderMutex ()
461 {
462     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
463     return g_instances_mutex;
464 }
465 
466 static DynamicLoaderInstances &
467 GetDynamicLoaderInstances ()
468 {
469     static DynamicLoaderInstances g_instances;
470     return g_instances;
471 }
472 
473 
474 bool
475 PluginManager::RegisterPlugin
476 (
477     const ConstString &name,
478     const char *description,
479     DynamicLoaderCreateInstance create_callback,
480     DebuggerInitializeCallback debugger_init_callback
481 )
482 {
483     if (create_callback)
484     {
485         DynamicLoaderInstance instance;
486         assert ((bool)name);
487         instance.name = name;
488         if (description && description[0])
489             instance.description = description;
490         instance.create_callback = create_callback;
491         instance.debugger_init_callback = debugger_init_callback;
492         Mutex::Locker locker (GetDynamicLoaderMutex ());
493         GetDynamicLoaderInstances ().push_back (instance);
494     }
495     return false;
496 }
497 
498 bool
499 PluginManager::UnregisterPlugin (DynamicLoaderCreateInstance create_callback)
500 {
501     if (create_callback)
502     {
503         Mutex::Locker locker (GetDynamicLoaderMutex ());
504         DynamicLoaderInstances &instances = GetDynamicLoaderInstances ();
505 
506         DynamicLoaderInstances::iterator pos, end = instances.end();
507         for (pos = instances.begin(); pos != end; ++ pos)
508         {
509             if (pos->create_callback == create_callback)
510             {
511                 instances.erase(pos);
512                 return true;
513             }
514         }
515     }
516     return false;
517 }
518 
519 DynamicLoaderCreateInstance
520 PluginManager::GetDynamicLoaderCreateCallbackAtIndex (uint32_t idx)
521 {
522     Mutex::Locker locker (GetDynamicLoaderMutex ());
523     DynamicLoaderInstances &instances = GetDynamicLoaderInstances ();
524     if (idx < instances.size())
525         return instances[idx].create_callback;
526     return NULL;
527 }
528 
529 DynamicLoaderCreateInstance
530 PluginManager::GetDynamicLoaderCreateCallbackForPluginName (const ConstString &name)
531 {
532     if (name)
533     {
534         Mutex::Locker locker (GetDynamicLoaderMutex ());
535         DynamicLoaderInstances &instances = GetDynamicLoaderInstances ();
536 
537         DynamicLoaderInstances::iterator pos, end = instances.end();
538         for (pos = instances.begin(); pos != end; ++ pos)
539         {
540             if (name == pos->name)
541                 return pos->create_callback;
542         }
543     }
544     return NULL;
545 }
546 
547 #pragma mark EmulateInstruction
548 
549 
550 struct EmulateInstructionInstance
551 {
552     EmulateInstructionInstance() :
553     name(),
554     description(),
555     create_callback(NULL)
556     {
557     }
558 
559     ConstString name;
560     std::string description;
561     EmulateInstructionCreateInstance create_callback;
562 };
563 
564 typedef std::vector<EmulateInstructionInstance> EmulateInstructionInstances;
565 
566 static Mutex &
567 GetEmulateInstructionMutex ()
568 {
569     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
570     return g_instances_mutex;
571 }
572 
573 static EmulateInstructionInstances &
574 GetEmulateInstructionInstances ()
575 {
576     static EmulateInstructionInstances g_instances;
577     return g_instances;
578 }
579 
580 
581 bool
582 PluginManager::RegisterPlugin
583 (
584     const ConstString &name,
585     const char *description,
586     EmulateInstructionCreateInstance create_callback
587 )
588 {
589     if (create_callback)
590     {
591         EmulateInstructionInstance instance;
592         assert ((bool)name);
593         instance.name = name;
594         if (description && description[0])
595             instance.description = description;
596         instance.create_callback = create_callback;
597         Mutex::Locker locker (GetEmulateInstructionMutex ());
598         GetEmulateInstructionInstances ().push_back (instance);
599     }
600     return false;
601 }
602 
603 bool
604 PluginManager::UnregisterPlugin (EmulateInstructionCreateInstance create_callback)
605 {
606     if (create_callback)
607     {
608         Mutex::Locker locker (GetEmulateInstructionMutex ());
609         EmulateInstructionInstances &instances = GetEmulateInstructionInstances ();
610 
611         EmulateInstructionInstances::iterator pos, end = instances.end();
612         for (pos = instances.begin(); pos != end; ++ pos)
613         {
614             if (pos->create_callback == create_callback)
615             {
616                 instances.erase(pos);
617                 return true;
618             }
619         }
620     }
621     return false;
622 }
623 
624 EmulateInstructionCreateInstance
625 PluginManager::GetEmulateInstructionCreateCallbackAtIndex (uint32_t idx)
626 {
627     Mutex::Locker locker (GetEmulateInstructionMutex ());
628     EmulateInstructionInstances &instances = GetEmulateInstructionInstances ();
629     if (idx < instances.size())
630         return instances[idx].create_callback;
631     return NULL;
632 }
633 
634 EmulateInstructionCreateInstance
635 PluginManager::GetEmulateInstructionCreateCallbackForPluginName (const ConstString &name)
636 {
637     if (name)
638     {
639         Mutex::Locker locker (GetEmulateInstructionMutex ());
640         EmulateInstructionInstances &instances = GetEmulateInstructionInstances ();
641 
642         EmulateInstructionInstances::iterator pos, end = instances.end();
643         for (pos = instances.begin(); pos != end; ++ pos)
644         {
645             if (name == pos->name)
646                 return pos->create_callback;
647         }
648     }
649     return NULL;
650 }
651 #pragma mark OperatingSystem
652 
653 
654 struct OperatingSystemInstance
655 {
656     OperatingSystemInstance() :
657         name(),
658         description(),
659         create_callback(NULL)
660     {
661     }
662 
663     ConstString name;
664     std::string description;
665     OperatingSystemCreateInstance create_callback;
666 };
667 
668 typedef std::vector<OperatingSystemInstance> OperatingSystemInstances;
669 
670 static Mutex &
671 GetOperatingSystemMutex ()
672 {
673     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
674     return g_instances_mutex;
675 }
676 
677 static OperatingSystemInstances &
678 GetOperatingSystemInstances ()
679 {
680     static OperatingSystemInstances g_instances;
681     return g_instances;
682 }
683 
684 bool
685 PluginManager::RegisterPlugin (const ConstString &name,
686                                const char *description,
687                                OperatingSystemCreateInstance create_callback)
688 {
689     if (create_callback)
690     {
691         OperatingSystemInstance instance;
692         assert ((bool)name);
693         instance.name = name;
694         if (description && description[0])
695             instance.description = description;
696         instance.create_callback = create_callback;
697         Mutex::Locker locker (GetOperatingSystemMutex ());
698         GetOperatingSystemInstances ().push_back (instance);
699     }
700     return false;
701 }
702 
703 bool
704 PluginManager::UnregisterPlugin (OperatingSystemCreateInstance create_callback)
705 {
706     if (create_callback)
707     {
708         Mutex::Locker locker (GetOperatingSystemMutex ());
709         OperatingSystemInstances &instances = GetOperatingSystemInstances ();
710 
711         OperatingSystemInstances::iterator pos, end = instances.end();
712         for (pos = instances.begin(); pos != end; ++ pos)
713         {
714             if (pos->create_callback == create_callback)
715             {
716                 instances.erase(pos);
717                 return true;
718             }
719         }
720     }
721     return false;
722 }
723 
724 OperatingSystemCreateInstance
725 PluginManager::GetOperatingSystemCreateCallbackAtIndex (uint32_t idx)
726 {
727     Mutex::Locker locker (GetOperatingSystemMutex ());
728     OperatingSystemInstances &instances = GetOperatingSystemInstances ();
729     if (idx < instances.size())
730         return instances[idx].create_callback;
731     return NULL;
732 }
733 
734 OperatingSystemCreateInstance
735 PluginManager::GetOperatingSystemCreateCallbackForPluginName (const ConstString &name)
736 {
737     if (name)
738     {
739         Mutex::Locker locker (GetOperatingSystemMutex ());
740         OperatingSystemInstances &instances = GetOperatingSystemInstances ();
741 
742         OperatingSystemInstances::iterator pos, end = instances.end();
743         for (pos = instances.begin(); pos != end; ++ pos)
744         {
745             if (name == pos->name)
746                 return pos->create_callback;
747         }
748     }
749     return NULL;
750 }
751 
752 
753 #pragma mark LanguageRuntime
754 
755 
756 struct LanguageRuntimeInstance
757 {
758     LanguageRuntimeInstance() :
759         name(),
760         description(),
761         create_callback(NULL)
762     {
763     }
764 
765     ConstString name;
766     std::string description;
767     LanguageRuntimeCreateInstance create_callback;
768 };
769 
770 typedef std::vector<LanguageRuntimeInstance> LanguageRuntimeInstances;
771 
772 static Mutex &
773 GetLanguageRuntimeMutex ()
774 {
775     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
776     return g_instances_mutex;
777 }
778 
779 static LanguageRuntimeInstances &
780 GetLanguageRuntimeInstances ()
781 {
782     static LanguageRuntimeInstances g_instances;
783     return g_instances;
784 }
785 
786 bool
787 PluginManager::RegisterPlugin
788 (
789     const ConstString &name,
790     const char *description,
791     LanguageRuntimeCreateInstance create_callback
792 )
793 {
794     if (create_callback)
795     {
796         LanguageRuntimeInstance instance;
797         assert ((bool)name);
798         instance.name = name;
799         if (description && description[0])
800             instance.description = description;
801         instance.create_callback = create_callback;
802         Mutex::Locker locker (GetLanguageRuntimeMutex ());
803         GetLanguageRuntimeInstances ().push_back (instance);
804     }
805     return false;
806 }
807 
808 bool
809 PluginManager::UnregisterPlugin (LanguageRuntimeCreateInstance create_callback)
810 {
811     if (create_callback)
812     {
813         Mutex::Locker locker (GetLanguageRuntimeMutex ());
814         LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances ();
815 
816         LanguageRuntimeInstances::iterator pos, end = instances.end();
817         for (pos = instances.begin(); pos != end; ++ pos)
818         {
819             if (pos->create_callback == create_callback)
820             {
821                 instances.erase(pos);
822                 return true;
823             }
824         }
825     }
826     return false;
827 }
828 
829 LanguageRuntimeCreateInstance
830 PluginManager::GetLanguageRuntimeCreateCallbackAtIndex (uint32_t idx)
831 {
832     Mutex::Locker locker (GetLanguageRuntimeMutex ());
833     LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances ();
834     if (idx < instances.size())
835         return instances[idx].create_callback;
836     return NULL;
837 }
838 
839 LanguageRuntimeCreateInstance
840 PluginManager::GetLanguageRuntimeCreateCallbackForPluginName (const ConstString &name)
841 {
842     if (name)
843     {
844         Mutex::Locker locker (GetLanguageRuntimeMutex ());
845         LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances ();
846 
847         LanguageRuntimeInstances::iterator pos, end = instances.end();
848         for (pos = instances.begin(); pos != end; ++ pos)
849         {
850             if (name == pos->name)
851                 return pos->create_callback;
852         }
853     }
854     return NULL;
855 }
856 
857 #pragma mark SystemRuntime
858 
859 
860 struct SystemRuntimeInstance
861 {
862     SystemRuntimeInstance() :
863         name(),
864         description(),
865         create_callback(NULL)
866     {
867     }
868 
869     ConstString name;
870     std::string description;
871     SystemRuntimeCreateInstance create_callback;
872 };
873 
874 typedef std::vector<SystemRuntimeInstance> SystemRuntimeInstances;
875 
876 static Mutex &
877 GetSystemRuntimeMutex ()
878 {
879     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
880     return g_instances_mutex;
881 }
882 
883 static SystemRuntimeInstances &
884 GetSystemRuntimeInstances ()
885 {
886     static SystemRuntimeInstances g_instances;
887     return g_instances;
888 }
889 
890 bool
891 PluginManager::RegisterPlugin
892 (
893     const ConstString &name,
894     const char *description,
895     SystemRuntimeCreateInstance create_callback
896 )
897 {
898     if (create_callback)
899     {
900         SystemRuntimeInstance instance;
901         assert ((bool)name);
902         instance.name = name;
903         if (description && description[0])
904             instance.description = description;
905         instance.create_callback = create_callback;
906         Mutex::Locker locker (GetSystemRuntimeMutex ());
907         GetSystemRuntimeInstances ().push_back (instance);
908     }
909     return false;
910 }
911 
912 bool
913 PluginManager::UnregisterPlugin (SystemRuntimeCreateInstance create_callback)
914 {
915     if (create_callback)
916     {
917         Mutex::Locker locker (GetSystemRuntimeMutex ());
918         SystemRuntimeInstances &instances = GetSystemRuntimeInstances ();
919 
920         SystemRuntimeInstances::iterator pos, end = instances.end();
921         for (pos = instances.begin(); pos != end; ++ pos)
922         {
923             if (pos->create_callback == create_callback)
924             {
925                 instances.erase(pos);
926                 return true;
927             }
928         }
929     }
930     return false;
931 }
932 
933 SystemRuntimeCreateInstance
934 PluginManager::GetSystemRuntimeCreateCallbackAtIndex (uint32_t idx)
935 {
936     Mutex::Locker locker (GetSystemRuntimeMutex ());
937     SystemRuntimeInstances &instances = GetSystemRuntimeInstances ();
938     if (idx < instances.size())
939         return instances[idx].create_callback;
940     return NULL;
941 }
942 
943 SystemRuntimeCreateInstance
944 PluginManager::GetSystemRuntimeCreateCallbackForPluginName (const ConstString &name)
945 {
946     if (name)
947     {
948         Mutex::Locker locker (GetSystemRuntimeMutex ());
949         SystemRuntimeInstances &instances = GetSystemRuntimeInstances ();
950 
951         SystemRuntimeInstances::iterator pos, end = instances.end();
952         for (pos = instances.begin(); pos != end; ++ pos)
953         {
954             if (name == pos->name)
955                 return pos->create_callback;
956         }
957     }
958     return NULL;
959 }
960 
961 
962 #pragma mark ObjectFile
963 
964 struct ObjectFileInstance
965 {
966     ObjectFileInstance() :
967         name(),
968         description(),
969         create_callback(NULL),
970         create_memory_callback (NULL),
971         get_module_specifications (NULL)
972     {
973     }
974 
975     ConstString name;
976     std::string description;
977     ObjectFileCreateInstance create_callback;
978     ObjectFileCreateMemoryInstance create_memory_callback;
979     ObjectFileGetModuleSpecifications get_module_specifications;
980 };
981 
982 typedef std::vector<ObjectFileInstance> ObjectFileInstances;
983 
984 static Mutex &
985 GetObjectFileMutex ()
986 {
987     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
988     return g_instances_mutex;
989 }
990 
991 static ObjectFileInstances &
992 GetObjectFileInstances ()
993 {
994     static ObjectFileInstances g_instances;
995     return g_instances;
996 }
997 
998 
999 bool
1000 PluginManager::RegisterPlugin (const ConstString &name,
1001                                const char *description,
1002                                ObjectFileCreateInstance create_callback,
1003                                ObjectFileCreateMemoryInstance create_memory_callback,
1004                                ObjectFileGetModuleSpecifications get_module_specifications)
1005 {
1006     if (create_callback)
1007     {
1008         ObjectFileInstance instance;
1009         assert ((bool)name);
1010         instance.name = name;
1011         if (description && description[0])
1012             instance.description = description;
1013         instance.create_callback = create_callback;
1014         instance.create_memory_callback = create_memory_callback;
1015         instance.get_module_specifications = get_module_specifications;
1016         Mutex::Locker locker (GetObjectFileMutex ());
1017         GetObjectFileInstances ().push_back (instance);
1018     }
1019     return false;
1020 }
1021 
1022 bool
1023 PluginManager::UnregisterPlugin (ObjectFileCreateInstance create_callback)
1024 {
1025     if (create_callback)
1026     {
1027         Mutex::Locker locker (GetObjectFileMutex ());
1028         ObjectFileInstances &instances = GetObjectFileInstances ();
1029 
1030         ObjectFileInstances::iterator pos, end = instances.end();
1031         for (pos = instances.begin(); pos != end; ++ pos)
1032         {
1033             if (pos->create_callback == create_callback)
1034             {
1035                 instances.erase(pos);
1036                 return true;
1037             }
1038         }
1039     }
1040     return false;
1041 }
1042 
1043 ObjectFileCreateInstance
1044 PluginManager::GetObjectFileCreateCallbackAtIndex (uint32_t idx)
1045 {
1046     Mutex::Locker locker (GetObjectFileMutex ());
1047     ObjectFileInstances &instances = GetObjectFileInstances ();
1048     if (idx < instances.size())
1049         return instances[idx].create_callback;
1050     return NULL;
1051 }
1052 
1053 
1054 ObjectFileCreateMemoryInstance
1055 PluginManager::GetObjectFileCreateMemoryCallbackAtIndex (uint32_t idx)
1056 {
1057     Mutex::Locker locker (GetObjectFileMutex ());
1058     ObjectFileInstances &instances = GetObjectFileInstances ();
1059     if (idx < instances.size())
1060         return instances[idx].create_memory_callback;
1061     return NULL;
1062 }
1063 
1064 ObjectFileGetModuleSpecifications
1065 PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex (uint32_t idx)
1066 {
1067     Mutex::Locker locker (GetObjectFileMutex ());
1068     ObjectFileInstances &instances = GetObjectFileInstances ();
1069     if (idx < instances.size())
1070         return instances[idx].get_module_specifications;
1071     return NULL;
1072 }
1073 
1074 ObjectFileCreateInstance
1075 PluginManager::GetObjectFileCreateCallbackForPluginName (const ConstString &name)
1076 {
1077     if (name)
1078     {
1079         Mutex::Locker locker (GetObjectFileMutex ());
1080         ObjectFileInstances &instances = GetObjectFileInstances ();
1081 
1082         ObjectFileInstances::iterator pos, end = instances.end();
1083         for (pos = instances.begin(); pos != end; ++ pos)
1084         {
1085             if (name == pos->name)
1086                 return pos->create_callback;
1087         }
1088     }
1089     return NULL;
1090 }
1091 
1092 
1093 ObjectFileCreateMemoryInstance
1094 PluginManager::GetObjectFileCreateMemoryCallbackForPluginName (const ConstString &name)
1095 {
1096     if (name)
1097     {
1098         Mutex::Locker locker (GetObjectFileMutex ());
1099         ObjectFileInstances &instances = GetObjectFileInstances ();
1100 
1101         ObjectFileInstances::iterator pos, end = instances.end();
1102         for (pos = instances.begin(); pos != end; ++ pos)
1103         {
1104             if (name == pos->name)
1105                 return pos->create_memory_callback;
1106         }
1107     }
1108     return NULL;
1109 }
1110 
1111 
1112 
1113 #pragma mark ObjectContainer
1114 
1115 struct ObjectContainerInstance
1116 {
1117     ObjectContainerInstance() :
1118         name(),
1119         description(),
1120         create_callback (NULL),
1121         get_module_specifications (NULL)
1122     {
1123     }
1124 
1125     ConstString name;
1126     std::string description;
1127     ObjectContainerCreateInstance create_callback;
1128     ObjectFileGetModuleSpecifications get_module_specifications;
1129 
1130 };
1131 
1132 typedef std::vector<ObjectContainerInstance> ObjectContainerInstances;
1133 
1134 static Mutex &
1135 GetObjectContainerMutex ()
1136 {
1137     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1138     return g_instances_mutex;
1139 }
1140 
1141 static ObjectContainerInstances &
1142 GetObjectContainerInstances ()
1143 {
1144     static ObjectContainerInstances g_instances;
1145     return g_instances;
1146 }
1147 
1148 bool
1149 PluginManager::RegisterPlugin (const ConstString &name,
1150                                const char *description,
1151                                ObjectContainerCreateInstance create_callback,
1152                                ObjectFileGetModuleSpecifications get_module_specifications)
1153 {
1154     if (create_callback)
1155     {
1156         ObjectContainerInstance instance;
1157         assert ((bool)name);
1158         instance.name = name;
1159         if (description && description[0])
1160             instance.description = description;
1161         instance.create_callback = create_callback;
1162         instance.get_module_specifications = get_module_specifications;
1163         Mutex::Locker locker (GetObjectContainerMutex ());
1164         GetObjectContainerInstances ().push_back (instance);
1165     }
1166     return false;
1167 }
1168 
1169 bool
1170 PluginManager::UnregisterPlugin (ObjectContainerCreateInstance create_callback)
1171 {
1172     if (create_callback)
1173     {
1174         Mutex::Locker locker (GetObjectContainerMutex ());
1175         ObjectContainerInstances &instances = GetObjectContainerInstances ();
1176 
1177         ObjectContainerInstances::iterator pos, end = instances.end();
1178         for (pos = instances.begin(); pos != end; ++ pos)
1179         {
1180             if (pos->create_callback == create_callback)
1181             {
1182                 instances.erase(pos);
1183                 return true;
1184             }
1185         }
1186     }
1187     return false;
1188 }
1189 
1190 ObjectContainerCreateInstance
1191 PluginManager::GetObjectContainerCreateCallbackAtIndex (uint32_t idx)
1192 {
1193     Mutex::Locker locker (GetObjectContainerMutex ());
1194     ObjectContainerInstances &instances = GetObjectContainerInstances ();
1195     if (idx < instances.size())
1196         return instances[idx].create_callback;
1197     return NULL;
1198 }
1199 
1200 ObjectContainerCreateInstance
1201 PluginManager::GetObjectContainerCreateCallbackForPluginName (const ConstString &name)
1202 {
1203     if (name)
1204     {
1205         Mutex::Locker locker (GetObjectContainerMutex ());
1206         ObjectContainerInstances &instances = GetObjectContainerInstances ();
1207 
1208         ObjectContainerInstances::iterator pos, end = instances.end();
1209         for (pos = instances.begin(); pos != end; ++ pos)
1210         {
1211             if (name == pos->name)
1212                 return pos->create_callback;
1213         }
1214     }
1215     return NULL;
1216 }
1217 
1218 ObjectFileGetModuleSpecifications
1219 PluginManager::GetObjectContainerGetModuleSpecificationsCallbackAtIndex (uint32_t idx)
1220 {
1221     Mutex::Locker locker (GetObjectContainerMutex ());
1222     ObjectContainerInstances &instances = GetObjectContainerInstances ();
1223     if (idx < instances.size())
1224         return instances[idx].get_module_specifications;
1225     return NULL;
1226 }
1227 
1228 #pragma mark LogChannel
1229 
1230 struct LogInstance
1231 {
1232     LogInstance() :
1233         name(),
1234         description(),
1235         create_callback(NULL)
1236     {
1237     }
1238 
1239     ConstString name;
1240     std::string description;
1241     LogChannelCreateInstance create_callback;
1242 };
1243 
1244 typedef std::vector<LogInstance> LogInstances;
1245 
1246 static Mutex &
1247 GetLogMutex ()
1248 {
1249     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1250     return g_instances_mutex;
1251 }
1252 
1253 static LogInstances &
1254 GetLogInstances ()
1255 {
1256     static LogInstances g_instances;
1257     return g_instances;
1258 }
1259 
1260 
1261 
1262 bool
1263 PluginManager::RegisterPlugin
1264 (
1265     const ConstString &name,
1266     const char *description,
1267     LogChannelCreateInstance create_callback
1268 )
1269 {
1270     if (create_callback)
1271     {
1272         LogInstance instance;
1273         assert ((bool)name);
1274         instance.name = name;
1275         if (description && description[0])
1276             instance.description = description;
1277         instance.create_callback = create_callback;
1278         Mutex::Locker locker (GetLogMutex ());
1279         GetLogInstances ().push_back (instance);
1280     }
1281     return false;
1282 }
1283 
1284 bool
1285 PluginManager::UnregisterPlugin (LogChannelCreateInstance create_callback)
1286 {
1287     if (create_callback)
1288     {
1289         Mutex::Locker locker (GetLogMutex ());
1290         LogInstances &instances = GetLogInstances ();
1291 
1292         LogInstances::iterator pos, end = instances.end();
1293         for (pos = instances.begin(); pos != end; ++ pos)
1294         {
1295             if (pos->create_callback == create_callback)
1296             {
1297                 instances.erase(pos);
1298                 return true;
1299             }
1300         }
1301     }
1302     return false;
1303 }
1304 
1305 const char *
1306 PluginManager::GetLogChannelCreateNameAtIndex (uint32_t idx)
1307 {
1308     Mutex::Locker locker (GetLogMutex ());
1309     LogInstances &instances = GetLogInstances ();
1310     if (idx < instances.size())
1311         return instances[idx].name.GetCString();
1312     return NULL;
1313 }
1314 
1315 
1316 LogChannelCreateInstance
1317 PluginManager::GetLogChannelCreateCallbackAtIndex (uint32_t idx)
1318 {
1319     Mutex::Locker locker (GetLogMutex ());
1320     LogInstances &instances = GetLogInstances ();
1321     if (idx < instances.size())
1322         return instances[idx].create_callback;
1323     return NULL;
1324 }
1325 
1326 LogChannelCreateInstance
1327 PluginManager::GetLogChannelCreateCallbackForPluginName (const ConstString &name)
1328 {
1329     if (name)
1330     {
1331         Mutex::Locker locker (GetLogMutex ());
1332         LogInstances &instances = GetLogInstances ();
1333 
1334         LogInstances::iterator pos, end = instances.end();
1335         for (pos = instances.begin(); pos != end; ++ pos)
1336         {
1337             if (name == pos->name)
1338                 return pos->create_callback;
1339         }
1340     }
1341     return NULL;
1342 }
1343 
1344 #pragma mark Platform
1345 
1346 struct PlatformInstance
1347 {
1348     PlatformInstance() :
1349         name(),
1350         description(),
1351         create_callback(NULL),
1352         debugger_init_callback (NULL)
1353     {
1354     }
1355 
1356     ConstString name;
1357     std::string description;
1358     PlatformCreateInstance create_callback;
1359     DebuggerInitializeCallback debugger_init_callback;
1360 };
1361 
1362 typedef std::vector<PlatformInstance> PlatformInstances;
1363 
1364 static Mutex &
1365 GetPlatformInstancesMutex ()
1366 {
1367     static Mutex g_platform_instances_mutex (Mutex::eMutexTypeRecursive);
1368     return g_platform_instances_mutex;
1369 }
1370 
1371 static PlatformInstances &
1372 GetPlatformInstances ()
1373 {
1374     static PlatformInstances g_platform_instances;
1375     return g_platform_instances;
1376 }
1377 
1378 
1379 bool
1380 PluginManager::RegisterPlugin (const ConstString &name,
1381                                const char *description,
1382                                PlatformCreateInstance create_callback,
1383                                DebuggerInitializeCallback debugger_init_callback)
1384 {
1385     if (create_callback)
1386     {
1387         Mutex::Locker locker (GetPlatformInstancesMutex ());
1388 
1389         PlatformInstance instance;
1390         assert ((bool)name);
1391         instance.name = name;
1392         if (description && description[0])
1393             instance.description = description;
1394         instance.create_callback = create_callback;
1395         instance.debugger_init_callback = debugger_init_callback;
1396         GetPlatformInstances ().push_back (instance);
1397         return true;
1398     }
1399     return false;
1400 }
1401 
1402 
1403 const char *
1404 PluginManager::GetPlatformPluginNameAtIndex (uint32_t idx)
1405 {
1406     Mutex::Locker locker (GetPlatformInstancesMutex ());
1407     PlatformInstances &instances = GetPlatformInstances ();
1408     if (idx < instances.size())
1409         return instances[idx].name.GetCString();
1410     return NULL;
1411 }
1412 
1413 const char *
1414 PluginManager::GetPlatformPluginDescriptionAtIndex (uint32_t idx)
1415 {
1416     Mutex::Locker locker (GetPlatformInstancesMutex ());
1417     PlatformInstances &instances = GetPlatformInstances ();
1418     if (idx < instances.size())
1419         return instances[idx].description.c_str();
1420     return NULL;
1421 }
1422 
1423 bool
1424 PluginManager::UnregisterPlugin (PlatformCreateInstance create_callback)
1425 {
1426     if (create_callback)
1427     {
1428         Mutex::Locker locker (GetPlatformInstancesMutex ());
1429         PlatformInstances &instances = GetPlatformInstances ();
1430 
1431         PlatformInstances::iterator pos, end = instances.end();
1432         for (pos = instances.begin(); pos != end; ++ pos)
1433         {
1434             if (pos->create_callback == create_callback)
1435             {
1436                 instances.erase(pos);
1437                 return true;
1438             }
1439         }
1440     }
1441     return false;
1442 }
1443 
1444 PlatformCreateInstance
1445 PluginManager::GetPlatformCreateCallbackAtIndex (uint32_t idx)
1446 {
1447     Mutex::Locker locker (GetPlatformInstancesMutex ());
1448     PlatformInstances &instances = GetPlatformInstances ();
1449     if (idx < instances.size())
1450         return instances[idx].create_callback;
1451     return NULL;
1452 }
1453 
1454 PlatformCreateInstance
1455 PluginManager::GetPlatformCreateCallbackForPluginName (const ConstString &name)
1456 {
1457     if (name)
1458     {
1459         Mutex::Locker locker (GetPlatformInstancesMutex ());
1460         PlatformInstances &instances = GetPlatformInstances ();
1461 
1462         PlatformInstances::iterator pos, end = instances.end();
1463         for (pos = instances.begin(); pos != end; ++ pos)
1464         {
1465             if (name == pos->name)
1466                 return pos->create_callback;
1467         }
1468     }
1469     return NULL;
1470 }
1471 
1472 size_t
1473 PluginManager::AutoCompletePlatformName (const char *name, StringList &matches)
1474 {
1475     if (name)
1476     {
1477         Mutex::Locker locker (GetPlatformInstancesMutex ());
1478         PlatformInstances &instances = GetPlatformInstances ();
1479         llvm::StringRef name_sref(name);
1480 
1481         PlatformInstances::iterator pos, end = instances.end();
1482         for (pos = instances.begin(); pos != end; ++ pos)
1483         {
1484             llvm::StringRef plugin_name (pos->name.GetCString());
1485             if (plugin_name.startswith(name_sref))
1486                 matches.AppendString (plugin_name.data());
1487         }
1488     }
1489     return matches.GetSize();
1490 }
1491 #pragma mark Process
1492 
1493 struct ProcessInstance
1494 {
1495     ProcessInstance() :
1496         name(),
1497         description(),
1498         create_callback(NULL),
1499         debugger_init_callback(NULL)
1500     {
1501     }
1502 
1503     ConstString name;
1504     std::string description;
1505     ProcessCreateInstance create_callback;
1506     DebuggerInitializeCallback debugger_init_callback;
1507 };
1508 
1509 typedef std::vector<ProcessInstance> ProcessInstances;
1510 
1511 static Mutex &
1512 GetProcessMutex ()
1513 {
1514     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1515     return g_instances_mutex;
1516 }
1517 
1518 static ProcessInstances &
1519 GetProcessInstances ()
1520 {
1521     static ProcessInstances g_instances;
1522     return g_instances;
1523 }
1524 
1525 
1526 bool
1527 PluginManager::RegisterPlugin (const ConstString &name,
1528                                const char *description,
1529                                ProcessCreateInstance create_callback,
1530                                DebuggerInitializeCallback debugger_init_callback)
1531 {
1532     if (create_callback)
1533     {
1534         ProcessInstance instance;
1535         assert ((bool)name);
1536         instance.name = name;
1537         if (description && description[0])
1538             instance.description = description;
1539         instance.create_callback = create_callback;
1540         instance.debugger_init_callback = debugger_init_callback;
1541         Mutex::Locker locker (GetProcessMutex ());
1542         GetProcessInstances ().push_back (instance);
1543     }
1544     return false;
1545 }
1546 
1547 const char *
1548 PluginManager::GetProcessPluginNameAtIndex (uint32_t idx)
1549 {
1550     Mutex::Locker locker (GetProcessMutex ());
1551     ProcessInstances &instances = GetProcessInstances ();
1552     if (idx < instances.size())
1553         return instances[idx].name.GetCString();
1554     return NULL;
1555 }
1556 
1557 const char *
1558 PluginManager::GetProcessPluginDescriptionAtIndex (uint32_t idx)
1559 {
1560     Mutex::Locker locker (GetProcessMutex ());
1561     ProcessInstances &instances = GetProcessInstances ();
1562     if (idx < instances.size())
1563         return instances[idx].description.c_str();
1564     return NULL;
1565 }
1566 
1567 bool
1568 PluginManager::UnregisterPlugin (ProcessCreateInstance create_callback)
1569 {
1570     if (create_callback)
1571     {
1572         Mutex::Locker locker (GetProcessMutex ());
1573         ProcessInstances &instances = GetProcessInstances ();
1574 
1575         ProcessInstances::iterator pos, end = instances.end();
1576         for (pos = instances.begin(); pos != end; ++ pos)
1577         {
1578             if (pos->create_callback == create_callback)
1579             {
1580                 instances.erase(pos);
1581                 return true;
1582             }
1583         }
1584     }
1585     return false;
1586 }
1587 
1588 ProcessCreateInstance
1589 PluginManager::GetProcessCreateCallbackAtIndex (uint32_t idx)
1590 {
1591     Mutex::Locker locker (GetProcessMutex ());
1592     ProcessInstances &instances = GetProcessInstances ();
1593     if (idx < instances.size())
1594         return instances[idx].create_callback;
1595     return NULL;
1596 }
1597 
1598 
1599 ProcessCreateInstance
1600 PluginManager::GetProcessCreateCallbackForPluginName (const ConstString &name)
1601 {
1602     if (name)
1603     {
1604         Mutex::Locker locker (GetProcessMutex ());
1605         ProcessInstances &instances = GetProcessInstances ();
1606 
1607         ProcessInstances::iterator pos, end = instances.end();
1608         for (pos = instances.begin(); pos != end; ++ pos)
1609         {
1610             if (name == pos->name)
1611                 return pos->create_callback;
1612         }
1613     }
1614     return NULL;
1615 }
1616 
1617 #pragma mark SymbolFile
1618 
1619 struct SymbolFileInstance
1620 {
1621     SymbolFileInstance() :
1622         name(),
1623         description(),
1624         create_callback(NULL)
1625     {
1626     }
1627 
1628     ConstString name;
1629     std::string description;
1630     SymbolFileCreateInstance create_callback;
1631 };
1632 
1633 typedef std::vector<SymbolFileInstance> SymbolFileInstances;
1634 
1635 static Mutex &
1636 GetSymbolFileMutex ()
1637 {
1638     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1639     return g_instances_mutex;
1640 }
1641 
1642 static SymbolFileInstances &
1643 GetSymbolFileInstances ()
1644 {
1645     static SymbolFileInstances g_instances;
1646     return g_instances;
1647 }
1648 
1649 
1650 bool
1651 PluginManager::RegisterPlugin
1652 (
1653     const ConstString &name,
1654     const char *description,
1655     SymbolFileCreateInstance create_callback
1656 )
1657 {
1658     if (create_callback)
1659     {
1660         SymbolFileInstance instance;
1661         assert ((bool)name);
1662         instance.name = name;
1663         if (description && description[0])
1664             instance.description = description;
1665         instance.create_callback = create_callback;
1666         Mutex::Locker locker (GetSymbolFileMutex ());
1667         GetSymbolFileInstances ().push_back (instance);
1668     }
1669     return false;
1670 }
1671 
1672 bool
1673 PluginManager::UnregisterPlugin (SymbolFileCreateInstance create_callback)
1674 {
1675     if (create_callback)
1676     {
1677         Mutex::Locker locker (GetSymbolFileMutex ());
1678         SymbolFileInstances &instances = GetSymbolFileInstances ();
1679 
1680         SymbolFileInstances::iterator pos, end = instances.end();
1681         for (pos = instances.begin(); pos != end; ++ pos)
1682         {
1683             if (pos->create_callback == create_callback)
1684             {
1685                 instances.erase(pos);
1686                 return true;
1687             }
1688         }
1689     }
1690     return false;
1691 }
1692 
1693 SymbolFileCreateInstance
1694 PluginManager::GetSymbolFileCreateCallbackAtIndex (uint32_t idx)
1695 {
1696     Mutex::Locker locker (GetSymbolFileMutex ());
1697     SymbolFileInstances &instances = GetSymbolFileInstances ();
1698     if (idx < instances.size())
1699         return instances[idx].create_callback;
1700     return NULL;
1701 }
1702 
1703 SymbolFileCreateInstance
1704 PluginManager::GetSymbolFileCreateCallbackForPluginName (const ConstString &name)
1705 {
1706     if (name)
1707     {
1708         Mutex::Locker locker (GetSymbolFileMutex ());
1709         SymbolFileInstances &instances = GetSymbolFileInstances ();
1710 
1711         SymbolFileInstances::iterator pos, end = instances.end();
1712         for (pos = instances.begin(); pos != end; ++ pos)
1713         {
1714             if (name == pos->name)
1715                 return pos->create_callback;
1716         }
1717     }
1718     return NULL;
1719 }
1720 
1721 
1722 
1723 #pragma mark SymbolVendor
1724 
1725 struct SymbolVendorInstance
1726 {
1727     SymbolVendorInstance() :
1728         name(),
1729         description(),
1730         create_callback(NULL)
1731     {
1732     }
1733 
1734     ConstString name;
1735     std::string description;
1736     SymbolVendorCreateInstance create_callback;
1737 };
1738 
1739 typedef std::vector<SymbolVendorInstance> SymbolVendorInstances;
1740 
1741 static Mutex &
1742 GetSymbolVendorMutex ()
1743 {
1744     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1745     return g_instances_mutex;
1746 }
1747 
1748 static SymbolVendorInstances &
1749 GetSymbolVendorInstances ()
1750 {
1751     static SymbolVendorInstances g_instances;
1752     return g_instances;
1753 }
1754 
1755 bool
1756 PluginManager::RegisterPlugin
1757 (
1758     const ConstString &name,
1759     const char *description,
1760     SymbolVendorCreateInstance create_callback
1761 )
1762 {
1763     if (create_callback)
1764     {
1765         SymbolVendorInstance instance;
1766         assert ((bool)name);
1767         instance.name = name;
1768         if (description && description[0])
1769             instance.description = description;
1770         instance.create_callback = create_callback;
1771         Mutex::Locker locker (GetSymbolVendorMutex ());
1772         GetSymbolVendorInstances ().push_back (instance);
1773     }
1774     return false;
1775 }
1776 
1777 bool
1778 PluginManager::UnregisterPlugin (SymbolVendorCreateInstance create_callback)
1779 {
1780     if (create_callback)
1781     {
1782         Mutex::Locker locker (GetSymbolVendorMutex ());
1783         SymbolVendorInstances &instances = GetSymbolVendorInstances ();
1784 
1785         SymbolVendorInstances::iterator pos, end = instances.end();
1786         for (pos = instances.begin(); pos != end; ++ pos)
1787         {
1788             if (pos->create_callback == create_callback)
1789             {
1790                 instances.erase(pos);
1791                 return true;
1792             }
1793         }
1794     }
1795     return false;
1796 }
1797 
1798 SymbolVendorCreateInstance
1799 PluginManager::GetSymbolVendorCreateCallbackAtIndex (uint32_t idx)
1800 {
1801     Mutex::Locker locker (GetSymbolVendorMutex ());
1802     SymbolVendorInstances &instances = GetSymbolVendorInstances ();
1803     if (idx < instances.size())
1804         return instances[idx].create_callback;
1805     return NULL;
1806 }
1807 
1808 
1809 SymbolVendorCreateInstance
1810 PluginManager::GetSymbolVendorCreateCallbackForPluginName (const ConstString &name)
1811 {
1812     if (name)
1813     {
1814         Mutex::Locker locker (GetSymbolVendorMutex ());
1815         SymbolVendorInstances &instances = GetSymbolVendorInstances ();
1816 
1817         SymbolVendorInstances::iterator pos, end = instances.end();
1818         for (pos = instances.begin(); pos != end; ++ pos)
1819         {
1820             if (name == pos->name)
1821                 return pos->create_callback;
1822         }
1823     }
1824     return NULL;
1825 }
1826 
1827 
1828 #pragma mark UnwindAssembly
1829 
1830 struct UnwindAssemblyInstance
1831 {
1832     UnwindAssemblyInstance() :
1833         name(),
1834         description(),
1835         create_callback(NULL)
1836     {
1837     }
1838 
1839     ConstString name;
1840     std::string description;
1841     UnwindAssemblyCreateInstance create_callback;
1842 };
1843 
1844 typedef std::vector<UnwindAssemblyInstance> UnwindAssemblyInstances;
1845 
1846 static Mutex &
1847 GetUnwindAssemblyMutex ()
1848 {
1849     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1850     return g_instances_mutex;
1851 }
1852 
1853 static UnwindAssemblyInstances &
1854 GetUnwindAssemblyInstances ()
1855 {
1856     static UnwindAssemblyInstances g_instances;
1857     return g_instances;
1858 }
1859 
1860 bool
1861 PluginManager::RegisterPlugin
1862 (
1863     const ConstString &name,
1864     const char *description,
1865     UnwindAssemblyCreateInstance create_callback
1866 )
1867 {
1868     if (create_callback)
1869     {
1870         UnwindAssemblyInstance instance;
1871         assert ((bool)name);
1872         instance.name = name;
1873         if (description && description[0])
1874             instance.description = description;
1875         instance.create_callback = create_callback;
1876         Mutex::Locker locker (GetUnwindAssemblyMutex ());
1877         GetUnwindAssemblyInstances ().push_back (instance);
1878     }
1879     return false;
1880 }
1881 
1882 bool
1883 PluginManager::UnregisterPlugin (UnwindAssemblyCreateInstance create_callback)
1884 {
1885     if (create_callback)
1886     {
1887         Mutex::Locker locker (GetUnwindAssemblyMutex ());
1888         UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances ();
1889 
1890         UnwindAssemblyInstances::iterator pos, end = instances.end();
1891         for (pos = instances.begin(); pos != end; ++ pos)
1892         {
1893             if (pos->create_callback == create_callback)
1894             {
1895                 instances.erase(pos);
1896                 return true;
1897             }
1898         }
1899     }
1900     return false;
1901 }
1902 
1903 UnwindAssemblyCreateInstance
1904 PluginManager::GetUnwindAssemblyCreateCallbackAtIndex (uint32_t idx)
1905 {
1906     Mutex::Locker locker (GetUnwindAssemblyMutex ());
1907     UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances ();
1908     if (idx < instances.size())
1909         return instances[idx].create_callback;
1910     return NULL;
1911 }
1912 
1913 
1914 UnwindAssemblyCreateInstance
1915 PluginManager::GetUnwindAssemblyCreateCallbackForPluginName (const ConstString &name)
1916 {
1917     if (name)
1918     {
1919         Mutex::Locker locker (GetUnwindAssemblyMutex ());
1920         UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances ();
1921 
1922         UnwindAssemblyInstances::iterator pos, end = instances.end();
1923         for (pos = instances.begin(); pos != end; ++ pos)
1924         {
1925             if (name == pos->name)
1926                 return pos->create_callback;
1927         }
1928     }
1929     return NULL;
1930 }
1931 
1932 void
1933 PluginManager::DebuggerInitialize (Debugger &debugger)
1934 {
1935     // Initialize the DynamicLoader plugins
1936     {
1937         Mutex::Locker locker (GetDynamicLoaderMutex ());
1938         DynamicLoaderInstances &instances = GetDynamicLoaderInstances ();
1939 
1940         DynamicLoaderInstances::iterator pos, end = instances.end();
1941         for (pos = instances.begin(); pos != end; ++ pos)
1942         {
1943             if (pos->debugger_init_callback)
1944                 pos->debugger_init_callback (debugger);
1945         }
1946     }
1947 
1948     // Initialize the Platform plugins
1949     {
1950         Mutex::Locker locker (GetPlatformInstancesMutex ());
1951         PlatformInstances &instances = GetPlatformInstances ();
1952 
1953         PlatformInstances::iterator pos, end = instances.end();
1954         for (pos = instances.begin(); pos != end; ++ pos)
1955         {
1956             if (pos->debugger_init_callback)
1957                 pos->debugger_init_callback (debugger);
1958         }
1959     }
1960 
1961     // Initialize the Process plugins
1962     {
1963         Mutex::Locker locker (GetProcessMutex());
1964         ProcessInstances &instances = GetProcessInstances();
1965 
1966         ProcessInstances::iterator pos, end = instances.end();
1967         for (pos = instances.begin(); pos != end; ++ pos)
1968         {
1969             if (pos->debugger_init_callback)
1970                 pos->debugger_init_callback (debugger);
1971         }
1972     }
1973 
1974 }
1975 
1976 // This is the preferred new way to register plugin specific settings.  e.g.
1977 // This will put a plugin's settings under e.g. "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".
1978 static lldb::OptionValuePropertiesSP
1979 GetDebuggerPropertyForPlugins (Debugger &debugger,
1980                                        const ConstString &plugin_type_name,
1981                                        const ConstString &plugin_type_desc,
1982                                        bool can_create)
1983 {
1984     lldb::OptionValuePropertiesSP parent_properties_sp (debugger.GetValueProperties());
1985     if (parent_properties_sp)
1986     {
1987         static ConstString g_property_name("plugin");
1988 
1989         OptionValuePropertiesSP plugin_properties_sp = parent_properties_sp->GetSubProperty (NULL, g_property_name);
1990         if (!plugin_properties_sp && can_create)
1991         {
1992             plugin_properties_sp.reset (new OptionValueProperties (g_property_name));
1993             parent_properties_sp->AppendProperty (g_property_name,
1994                                                   ConstString("Settings specify to plugins."),
1995                                                   true,
1996                                                   plugin_properties_sp);
1997         }
1998 
1999         if (plugin_properties_sp)
2000         {
2001             lldb::OptionValuePropertiesSP plugin_type_properties_sp = plugin_properties_sp->GetSubProperty (NULL, plugin_type_name);
2002             if (!plugin_type_properties_sp && can_create)
2003             {
2004                 plugin_type_properties_sp.reset (new OptionValueProperties (plugin_type_name));
2005                 plugin_properties_sp->AppendProperty (plugin_type_name,
2006                                                       plugin_type_desc,
2007                                                       true,
2008                                                       plugin_type_properties_sp);
2009             }
2010             return plugin_type_properties_sp;
2011         }
2012     }
2013     return lldb::OptionValuePropertiesSP();
2014 }
2015 
2016 // This is deprecated way to register plugin specific settings.  e.g.
2017 // "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME"
2018 // and Platform generic settings would be under "platform.SETTINGNAME".
2019 static lldb::OptionValuePropertiesSP
2020 GetDebuggerPropertyForPluginsOldStyle (Debugger &debugger,
2021                                        const ConstString &plugin_type_name,
2022                                        const ConstString &plugin_type_desc,
2023                                        bool can_create)
2024 {
2025     static ConstString g_property_name("plugin");
2026     lldb::OptionValuePropertiesSP parent_properties_sp (debugger.GetValueProperties());
2027     if (parent_properties_sp)
2028     {
2029         OptionValuePropertiesSP plugin_properties_sp = parent_properties_sp->GetSubProperty (NULL, plugin_type_name);
2030         if (!plugin_properties_sp && can_create)
2031         {
2032             plugin_properties_sp.reset (new OptionValueProperties (plugin_type_name));
2033             parent_properties_sp->AppendProperty (plugin_type_name,
2034                                                   plugin_type_desc,
2035                                                   true,
2036                                                   plugin_properties_sp);
2037         }
2038 
2039         if (plugin_properties_sp)
2040         {
2041             lldb::OptionValuePropertiesSP plugin_type_properties_sp = plugin_properties_sp->GetSubProperty (NULL, g_property_name);
2042             if (!plugin_type_properties_sp && can_create)
2043             {
2044                 plugin_type_properties_sp.reset (new OptionValueProperties (g_property_name));
2045                 plugin_properties_sp->AppendProperty (g_property_name,
2046                                                       ConstString("Settings specific to plugins"),
2047                                                       true,
2048                                                       plugin_type_properties_sp);
2049             }
2050             return plugin_type_properties_sp;
2051         }
2052     }
2053     return lldb::OptionValuePropertiesSP();
2054 }
2055 
2056 
2057 lldb::OptionValuePropertiesSP
2058 PluginManager::GetSettingForDynamicLoaderPlugin (Debugger &debugger, const ConstString &setting_name)
2059 {
2060     lldb::OptionValuePropertiesSP properties_sp;
2061     lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPlugins (debugger,
2062                                                                                             ConstString("dynamic-loader"),
2063                                                                                             ConstString(), // not creating to so we don't need the description
2064                                                                                             false));
2065     if (plugin_type_properties_sp)
2066         properties_sp = plugin_type_properties_sp->GetSubProperty (NULL, setting_name);
2067     return properties_sp;
2068 }
2069 
2070 bool
2071 PluginManager::CreateSettingForDynamicLoaderPlugin (Debugger &debugger,
2072                                                     const lldb::OptionValuePropertiesSP &properties_sp,
2073                                                     const ConstString &description,
2074                                                     bool is_global_property)
2075 {
2076     if (properties_sp)
2077     {
2078         lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPlugins (debugger,
2079                                                                                                 ConstString("dynamic-loader"),
2080                                                                                                 ConstString("Settings for dynamic loader plug-ins"),
2081                                                                                                 true));
2082         if (plugin_type_properties_sp)
2083         {
2084             plugin_type_properties_sp->AppendProperty (properties_sp->GetName(),
2085                                                        description,
2086                                                        is_global_property,
2087                                                        properties_sp);
2088             return true;
2089         }
2090     }
2091     return false;
2092 }
2093 
2094 
2095 lldb::OptionValuePropertiesSP
2096 PluginManager::GetSettingForPlatformPlugin (Debugger &debugger, const ConstString &setting_name)
2097 {
2098     lldb::OptionValuePropertiesSP properties_sp;
2099     lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPluginsOldStyle (debugger,
2100                                                                                                     ConstString("platform"),
2101                                                                                                     ConstString(), // not creating to so we don't need the description
2102                                                                                                     false));
2103     if (plugin_type_properties_sp)
2104         properties_sp = plugin_type_properties_sp->GetSubProperty (NULL, setting_name);
2105     return properties_sp;
2106 }
2107 
2108 bool
2109 PluginManager::CreateSettingForPlatformPlugin (Debugger &debugger,
2110                                                     const lldb::OptionValuePropertiesSP &properties_sp,
2111                                                     const ConstString &description,
2112                                                     bool is_global_property)
2113 {
2114     if (properties_sp)
2115     {
2116         lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPluginsOldStyle (debugger,
2117                                                                                                         ConstString("platform"),
2118                                                                                                         ConstString("Settings for platform plug-ins"),
2119                                                                                                         true));
2120         if (plugin_type_properties_sp)
2121         {
2122             plugin_type_properties_sp->AppendProperty (properties_sp->GetName(),
2123                                                        description,
2124                                                        is_global_property,
2125                                                        properties_sp);
2126             return true;
2127         }
2128     }
2129     return false;
2130 }
2131 
2132 
2133 lldb::OptionValuePropertiesSP
2134 PluginManager::GetSettingForProcessPlugin (Debugger &debugger, const ConstString &setting_name)
2135 {
2136     lldb::OptionValuePropertiesSP properties_sp;
2137     lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPlugins (debugger,
2138                                                                                             ConstString("process"),
2139                                                                                             ConstString(), // not creating to so we don't need the description
2140                                                                                             false));
2141     if (plugin_type_properties_sp)
2142         properties_sp = plugin_type_properties_sp->GetSubProperty (NULL, setting_name);
2143     return properties_sp;
2144 }
2145 
2146 bool
2147 PluginManager::CreateSettingForProcessPlugin (Debugger &debugger,
2148                                               const lldb::OptionValuePropertiesSP &properties_sp,
2149                                               const ConstString &description,
2150                                               bool is_global_property)
2151 {
2152     if (properties_sp)
2153     {
2154         lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPlugins (debugger,
2155                                                                                                 ConstString("process"),
2156                                                                                                 ConstString("Settings for process plug-ins"),
2157                                                                                                 true));
2158         if (plugin_type_properties_sp)
2159         {
2160             plugin_type_properties_sp->AppendProperty (properties_sp->GetName(),
2161                                                        description,
2162                                                        is_global_property,
2163                                                        properties_sp);
2164             return true;
2165         }
2166     }
2167     return false;
2168 }
2169 
2170