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 &
GetPluginMapMutex()52 GetPluginMapMutex ()
53 {
54 static Mutex g_plugin_map_mutex (Mutex::eMutexTypeRecursive);
55 return g_plugin_map_mutex;
56 }
57
58 static PluginTerminateMap &
GetPluginMap()59 GetPluginMap ()
60 {
61 static PluginTerminateMap g_plugin_map;
62 return g_plugin_map;
63 }
64
65 static bool
PluginIsLoaded(const FileSpec & plugin_file_spec)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
SetPluginInfo(const FileSpec & plugin_file_spec,const PluginInfo & plugin_info)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
LoadPluginCallback(void * baton,FileSpec::FileType file_type,const FileSpec & file_spec)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
Initialize()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
Terminate()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 {
ABIInstanceABIInstance229 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 &
GetABIInstancesMutex()244 GetABIInstancesMutex ()
245 {
246 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
247 return g_instances_mutex;
248 }
249
250 static ABIInstances &
GetABIInstances()251 GetABIInstances ()
252 {
253 static ABIInstances g_instances;
254 return g_instances;
255 }
256
257 bool
RegisterPlugin(const ConstString & name,const char * description,ABICreateInstance create_callback)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
UnregisterPlugin(ABICreateInstance create_callback)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
GetABICreateCallbackAtIndex(uint32_t idx)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
GetABICreateCallbackForPluginName(const ConstString & name)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 {
DisassemblerInstanceDisassemblerInstance335 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 &
GetDisassemblerMutex()350 GetDisassemblerMutex ()
351 {
352 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
353 return g_instances_mutex;
354 }
355
356 static DisassemblerInstances &
GetDisassemblerInstances()357 GetDisassemblerInstances ()
358 {
359 static DisassemblerInstances g_instances;
360 return g_instances;
361 }
362
363 bool
RegisterPlugin(const ConstString & name,const char * description,DisassemblerCreateInstance create_callback)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
UnregisterPlugin(DisassemblerCreateInstance create_callback)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
GetDisassemblerCreateCallbackAtIndex(uint32_t idx)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
GetDisassemblerCreateCallbackForPluginName(const ConstString & name)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 {
DynamicLoaderInstanceDynamicLoaderInstance442 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 &
GetDynamicLoaderMutex()460 GetDynamicLoaderMutex ()
461 {
462 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
463 return g_instances_mutex;
464 }
465
466 static DynamicLoaderInstances &
GetDynamicLoaderInstances()467 GetDynamicLoaderInstances ()
468 {
469 static DynamicLoaderInstances g_instances;
470 return g_instances;
471 }
472
473
474 bool
RegisterPlugin(const ConstString & name,const char * description,DynamicLoaderCreateInstance create_callback,DebuggerInitializeCallback debugger_init_callback)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
UnregisterPlugin(DynamicLoaderCreateInstance create_callback)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
GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx)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
GetDynamicLoaderCreateCallbackForPluginName(const ConstString & name)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 {
EmulateInstructionInstanceEmulateInstructionInstance552 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 &
GetEmulateInstructionMutex()567 GetEmulateInstructionMutex ()
568 {
569 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
570 return g_instances_mutex;
571 }
572
573 static EmulateInstructionInstances &
GetEmulateInstructionInstances()574 GetEmulateInstructionInstances ()
575 {
576 static EmulateInstructionInstances g_instances;
577 return g_instances;
578 }
579
580
581 bool
RegisterPlugin(const ConstString & name,const char * description,EmulateInstructionCreateInstance create_callback)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
UnregisterPlugin(EmulateInstructionCreateInstance create_callback)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
GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx)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
GetEmulateInstructionCreateCallbackForPluginName(const ConstString & name)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 {
OperatingSystemInstanceOperatingSystemInstance656 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 &
GetOperatingSystemMutex()671 GetOperatingSystemMutex ()
672 {
673 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
674 return g_instances_mutex;
675 }
676
677 static OperatingSystemInstances &
GetOperatingSystemInstances()678 GetOperatingSystemInstances ()
679 {
680 static OperatingSystemInstances g_instances;
681 return g_instances;
682 }
683
684 bool
RegisterPlugin(const ConstString & name,const char * description,OperatingSystemCreateInstance create_callback)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
UnregisterPlugin(OperatingSystemCreateInstance create_callback)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
GetOperatingSystemCreateCallbackAtIndex(uint32_t idx)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
GetOperatingSystemCreateCallbackForPluginName(const ConstString & name)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 {
LanguageRuntimeInstanceLanguageRuntimeInstance758 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 &
GetLanguageRuntimeMutex()773 GetLanguageRuntimeMutex ()
774 {
775 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
776 return g_instances_mutex;
777 }
778
779 static LanguageRuntimeInstances &
GetLanguageRuntimeInstances()780 GetLanguageRuntimeInstances ()
781 {
782 static LanguageRuntimeInstances g_instances;
783 return g_instances;
784 }
785
786 bool
RegisterPlugin(const ConstString & name,const char * description,LanguageRuntimeCreateInstance create_callback)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
UnregisterPlugin(LanguageRuntimeCreateInstance create_callback)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
GetLanguageRuntimeCreateCallbackAtIndex(uint32_t idx)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
GetLanguageRuntimeCreateCallbackForPluginName(const ConstString & name)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 {
SystemRuntimeInstanceSystemRuntimeInstance862 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 &
GetSystemRuntimeMutex()877 GetSystemRuntimeMutex ()
878 {
879 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
880 return g_instances_mutex;
881 }
882
883 static SystemRuntimeInstances &
GetSystemRuntimeInstances()884 GetSystemRuntimeInstances ()
885 {
886 static SystemRuntimeInstances g_instances;
887 return g_instances;
888 }
889
890 bool
RegisterPlugin(const ConstString & name,const char * description,SystemRuntimeCreateInstance create_callback)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
UnregisterPlugin(SystemRuntimeCreateInstance create_callback)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
GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx)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
GetSystemRuntimeCreateCallbackForPluginName(const ConstString & name)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 {
ObjectFileInstanceObjectFileInstance966 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 &
GetObjectFileMutex()985 GetObjectFileMutex ()
986 {
987 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
988 return g_instances_mutex;
989 }
990
991 static ObjectFileInstances &
GetObjectFileInstances()992 GetObjectFileInstances ()
993 {
994 static ObjectFileInstances g_instances;
995 return g_instances;
996 }
997
998
999 bool
RegisterPlugin(const ConstString & name,const char * description,ObjectFileCreateInstance create_callback,ObjectFileCreateMemoryInstance create_memory_callback,ObjectFileGetModuleSpecifications get_module_specifications)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
UnregisterPlugin(ObjectFileCreateInstance create_callback)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
GetObjectFileCreateCallbackAtIndex(uint32_t idx)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
GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx)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
GetObjectFileGetModuleSpecificationsCallbackAtIndex(uint32_t idx)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
GetObjectFileCreateCallbackForPluginName(const ConstString & name)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
GetObjectFileCreateMemoryCallbackForPluginName(const ConstString & name)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 {
ObjectContainerInstanceObjectContainerInstance1117 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 &
GetObjectContainerMutex()1135 GetObjectContainerMutex ()
1136 {
1137 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1138 return g_instances_mutex;
1139 }
1140
1141 static ObjectContainerInstances &
GetObjectContainerInstances()1142 GetObjectContainerInstances ()
1143 {
1144 static ObjectContainerInstances g_instances;
1145 return g_instances;
1146 }
1147
1148 bool
RegisterPlugin(const ConstString & name,const char * description,ObjectContainerCreateInstance create_callback,ObjectFileGetModuleSpecifications get_module_specifications)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
UnregisterPlugin(ObjectContainerCreateInstance create_callback)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
GetObjectContainerCreateCallbackAtIndex(uint32_t idx)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
GetObjectContainerCreateCallbackForPluginName(const ConstString & name)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
GetObjectContainerGetModuleSpecificationsCallbackAtIndex(uint32_t idx)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 {
LogInstanceLogInstance1232 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 &
GetLogMutex()1247 GetLogMutex ()
1248 {
1249 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1250 return g_instances_mutex;
1251 }
1252
1253 static LogInstances &
GetLogInstances()1254 GetLogInstances ()
1255 {
1256 static LogInstances g_instances;
1257 return g_instances;
1258 }
1259
1260
1261
1262 bool
RegisterPlugin(const ConstString & name,const char * description,LogChannelCreateInstance create_callback)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
UnregisterPlugin(LogChannelCreateInstance create_callback)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 *
GetLogChannelCreateNameAtIndex(uint32_t idx)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
GetLogChannelCreateCallbackAtIndex(uint32_t idx)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
GetLogChannelCreateCallbackForPluginName(const ConstString & name)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 {
PlatformInstancePlatformInstance1348 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 &
GetPlatformInstancesMutex()1365 GetPlatformInstancesMutex ()
1366 {
1367 static Mutex g_platform_instances_mutex (Mutex::eMutexTypeRecursive);
1368 return g_platform_instances_mutex;
1369 }
1370
1371 static PlatformInstances &
GetPlatformInstances()1372 GetPlatformInstances ()
1373 {
1374 static PlatformInstances g_platform_instances;
1375 return g_platform_instances;
1376 }
1377
1378
1379 bool
RegisterPlugin(const ConstString & name,const char * description,PlatformCreateInstance create_callback,DebuggerInitializeCallback debugger_init_callback)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 *
GetPlatformPluginNameAtIndex(uint32_t idx)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 *
GetPlatformPluginDescriptionAtIndex(uint32_t idx)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
UnregisterPlugin(PlatformCreateInstance create_callback)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
GetPlatformCreateCallbackAtIndex(uint32_t idx)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
GetPlatformCreateCallbackForPluginName(const ConstString & name)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
AutoCompletePlatformName(const char * name,StringList & matches)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 {
ProcessInstanceProcessInstance1495 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 &
GetProcessMutex()1512 GetProcessMutex ()
1513 {
1514 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1515 return g_instances_mutex;
1516 }
1517
1518 static ProcessInstances &
GetProcessInstances()1519 GetProcessInstances ()
1520 {
1521 static ProcessInstances g_instances;
1522 return g_instances;
1523 }
1524
1525
1526 bool
RegisterPlugin(const ConstString & name,const char * description,ProcessCreateInstance create_callback,DebuggerInitializeCallback debugger_init_callback)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 *
GetProcessPluginNameAtIndex(uint32_t idx)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 *
GetProcessPluginDescriptionAtIndex(uint32_t idx)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
UnregisterPlugin(ProcessCreateInstance create_callback)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
GetProcessCreateCallbackAtIndex(uint32_t idx)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
GetProcessCreateCallbackForPluginName(const ConstString & name)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 {
SymbolFileInstanceSymbolFileInstance1621 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 &
GetSymbolFileMutex()1636 GetSymbolFileMutex ()
1637 {
1638 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1639 return g_instances_mutex;
1640 }
1641
1642 static SymbolFileInstances &
GetSymbolFileInstances()1643 GetSymbolFileInstances ()
1644 {
1645 static SymbolFileInstances g_instances;
1646 return g_instances;
1647 }
1648
1649
1650 bool
RegisterPlugin(const ConstString & name,const char * description,SymbolFileCreateInstance create_callback)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
UnregisterPlugin(SymbolFileCreateInstance create_callback)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
GetSymbolFileCreateCallbackAtIndex(uint32_t idx)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
GetSymbolFileCreateCallbackForPluginName(const ConstString & name)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 {
SymbolVendorInstanceSymbolVendorInstance1727 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 &
GetSymbolVendorMutex()1742 GetSymbolVendorMutex ()
1743 {
1744 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1745 return g_instances_mutex;
1746 }
1747
1748 static SymbolVendorInstances &
GetSymbolVendorInstances()1749 GetSymbolVendorInstances ()
1750 {
1751 static SymbolVendorInstances g_instances;
1752 return g_instances;
1753 }
1754
1755 bool
RegisterPlugin(const ConstString & name,const char * description,SymbolVendorCreateInstance create_callback)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
UnregisterPlugin(SymbolVendorCreateInstance create_callback)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
GetSymbolVendorCreateCallbackAtIndex(uint32_t idx)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
GetSymbolVendorCreateCallbackForPluginName(const ConstString & name)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 {
UnwindAssemblyInstanceUnwindAssemblyInstance1832 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 &
GetUnwindAssemblyMutex()1847 GetUnwindAssemblyMutex ()
1848 {
1849 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
1850 return g_instances_mutex;
1851 }
1852
1853 static UnwindAssemblyInstances &
GetUnwindAssemblyInstances()1854 GetUnwindAssemblyInstances ()
1855 {
1856 static UnwindAssemblyInstances g_instances;
1857 return g_instances;
1858 }
1859
1860 bool
RegisterPlugin(const ConstString & name,const char * description,UnwindAssemblyCreateInstance create_callback)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
UnregisterPlugin(UnwindAssemblyCreateInstance create_callback)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
GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx)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
GetUnwindAssemblyCreateCallbackForPluginName(const ConstString & name)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
DebuggerInitialize(Debugger & debugger)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
GetDebuggerPropertyForPlugins(Debugger & debugger,const ConstString & plugin_type_name,const ConstString & plugin_type_desc,bool can_create)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
GetDebuggerPropertyForPluginsOldStyle(Debugger & debugger,const ConstString & plugin_type_name,const ConstString & plugin_type_desc,bool can_create)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
GetSettingForDynamicLoaderPlugin(Debugger & debugger,const ConstString & setting_name)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
CreateSettingForDynamicLoaderPlugin(Debugger & debugger,const lldb::OptionValuePropertiesSP & properties_sp,const ConstString & description,bool is_global_property)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
GetSettingForPlatformPlugin(Debugger & debugger,const ConstString & setting_name)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
CreateSettingForPlatformPlugin(Debugger & debugger,const lldb::OptionValuePropertiesSP & properties_sp,const ConstString & description,bool is_global_property)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
GetSettingForProcessPlugin(Debugger & debugger,const ConstString & setting_name)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
CreateSettingForProcessPlugin(Debugger & debugger,const lldb::OptionValuePropertiesSP & properties_sp,const ConstString & description,bool is_global_property)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