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 ObjectFile 858 859 struct ObjectFileInstance 860 { 861 ObjectFileInstance() : 862 name(), 863 description(), 864 create_callback(NULL), 865 create_memory_callback (NULL), 866 get_module_specifications (NULL) 867 { 868 } 869 870 ConstString name; 871 std::string description; 872 ObjectFileCreateInstance create_callback; 873 ObjectFileCreateMemoryInstance create_memory_callback; 874 ObjectFileGetModuleSpecifications get_module_specifications; 875 }; 876 877 typedef std::vector<ObjectFileInstance> ObjectFileInstances; 878 879 static Mutex & 880 GetObjectFileMutex () 881 { 882 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive); 883 return g_instances_mutex; 884 } 885 886 static ObjectFileInstances & 887 GetObjectFileInstances () 888 { 889 static ObjectFileInstances g_instances; 890 return g_instances; 891 } 892 893 894 bool 895 PluginManager::RegisterPlugin (const ConstString &name, 896 const char *description, 897 ObjectFileCreateInstance create_callback, 898 ObjectFileCreateMemoryInstance create_memory_callback, 899 ObjectFileGetModuleSpecifications get_module_specifications) 900 { 901 if (create_callback) 902 { 903 ObjectFileInstance instance; 904 assert ((bool)name); 905 instance.name = name; 906 if (description && description[0]) 907 instance.description = description; 908 instance.create_callback = create_callback; 909 instance.create_memory_callback = create_memory_callback; 910 instance.get_module_specifications = get_module_specifications; 911 Mutex::Locker locker (GetObjectFileMutex ()); 912 GetObjectFileInstances ().push_back (instance); 913 } 914 return false; 915 } 916 917 bool 918 PluginManager::UnregisterPlugin (ObjectFileCreateInstance create_callback) 919 { 920 if (create_callback) 921 { 922 Mutex::Locker locker (GetObjectFileMutex ()); 923 ObjectFileInstances &instances = GetObjectFileInstances (); 924 925 ObjectFileInstances::iterator pos, end = instances.end(); 926 for (pos = instances.begin(); pos != end; ++ pos) 927 { 928 if (pos->create_callback == create_callback) 929 { 930 instances.erase(pos); 931 return true; 932 } 933 } 934 } 935 return false; 936 } 937 938 ObjectFileCreateInstance 939 PluginManager::GetObjectFileCreateCallbackAtIndex (uint32_t idx) 940 { 941 Mutex::Locker locker (GetObjectFileMutex ()); 942 ObjectFileInstances &instances = GetObjectFileInstances (); 943 if (idx < instances.size()) 944 return instances[idx].create_callback; 945 return NULL; 946 } 947 948 949 ObjectFileCreateMemoryInstance 950 PluginManager::GetObjectFileCreateMemoryCallbackAtIndex (uint32_t idx) 951 { 952 Mutex::Locker locker (GetObjectFileMutex ()); 953 ObjectFileInstances &instances = GetObjectFileInstances (); 954 if (idx < instances.size()) 955 return instances[idx].create_memory_callback; 956 return NULL; 957 } 958 959 ObjectFileGetModuleSpecifications 960 PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex (uint32_t idx) 961 { 962 Mutex::Locker locker (GetObjectFileMutex ()); 963 ObjectFileInstances &instances = GetObjectFileInstances (); 964 if (idx < instances.size()) 965 return instances[idx].get_module_specifications; 966 return NULL; 967 } 968 969 ObjectFileCreateInstance 970 PluginManager::GetObjectFileCreateCallbackForPluginName (const ConstString &name) 971 { 972 if (name) 973 { 974 Mutex::Locker locker (GetObjectFileMutex ()); 975 ObjectFileInstances &instances = GetObjectFileInstances (); 976 977 ObjectFileInstances::iterator pos, end = instances.end(); 978 for (pos = instances.begin(); pos != end; ++ pos) 979 { 980 if (name == pos->name) 981 return pos->create_callback; 982 } 983 } 984 return NULL; 985 } 986 987 988 ObjectFileCreateMemoryInstance 989 PluginManager::GetObjectFileCreateMemoryCallbackForPluginName (const ConstString &name) 990 { 991 if (name) 992 { 993 Mutex::Locker locker (GetObjectFileMutex ()); 994 ObjectFileInstances &instances = GetObjectFileInstances (); 995 996 ObjectFileInstances::iterator pos, end = instances.end(); 997 for (pos = instances.begin(); pos != end; ++ pos) 998 { 999 if (name == pos->name) 1000 return pos->create_memory_callback; 1001 } 1002 } 1003 return NULL; 1004 } 1005 1006 1007 1008 #pragma mark ObjectContainer 1009 1010 struct ObjectContainerInstance 1011 { 1012 ObjectContainerInstance() : 1013 name(), 1014 description(), 1015 create_callback (NULL), 1016 get_module_specifications (NULL) 1017 { 1018 } 1019 1020 ConstString name; 1021 std::string description; 1022 ObjectContainerCreateInstance create_callback; 1023 ObjectFileGetModuleSpecifications get_module_specifications; 1024 1025 }; 1026 1027 typedef std::vector<ObjectContainerInstance> ObjectContainerInstances; 1028 1029 static Mutex & 1030 GetObjectContainerMutex () 1031 { 1032 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive); 1033 return g_instances_mutex; 1034 } 1035 1036 static ObjectContainerInstances & 1037 GetObjectContainerInstances () 1038 { 1039 static ObjectContainerInstances g_instances; 1040 return g_instances; 1041 } 1042 1043 bool 1044 PluginManager::RegisterPlugin (const ConstString &name, 1045 const char *description, 1046 ObjectContainerCreateInstance create_callback, 1047 ObjectFileGetModuleSpecifications get_module_specifications) 1048 { 1049 if (create_callback) 1050 { 1051 ObjectContainerInstance instance; 1052 assert ((bool)name); 1053 instance.name = name; 1054 if (description && description[0]) 1055 instance.description = description; 1056 instance.create_callback = create_callback; 1057 instance.get_module_specifications = get_module_specifications; 1058 Mutex::Locker locker (GetObjectContainerMutex ()); 1059 GetObjectContainerInstances ().push_back (instance); 1060 } 1061 return false; 1062 } 1063 1064 bool 1065 PluginManager::UnregisterPlugin (ObjectContainerCreateInstance create_callback) 1066 { 1067 if (create_callback) 1068 { 1069 Mutex::Locker locker (GetObjectContainerMutex ()); 1070 ObjectContainerInstances &instances = GetObjectContainerInstances (); 1071 1072 ObjectContainerInstances::iterator pos, end = instances.end(); 1073 for (pos = instances.begin(); pos != end; ++ pos) 1074 { 1075 if (pos->create_callback == create_callback) 1076 { 1077 instances.erase(pos); 1078 return true; 1079 } 1080 } 1081 } 1082 return false; 1083 } 1084 1085 ObjectContainerCreateInstance 1086 PluginManager::GetObjectContainerCreateCallbackAtIndex (uint32_t idx) 1087 { 1088 Mutex::Locker locker (GetObjectContainerMutex ()); 1089 ObjectContainerInstances &instances = GetObjectContainerInstances (); 1090 if (idx < instances.size()) 1091 return instances[idx].create_callback; 1092 return NULL; 1093 } 1094 1095 ObjectContainerCreateInstance 1096 PluginManager::GetObjectContainerCreateCallbackForPluginName (const ConstString &name) 1097 { 1098 if (name) 1099 { 1100 Mutex::Locker locker (GetObjectContainerMutex ()); 1101 ObjectContainerInstances &instances = GetObjectContainerInstances (); 1102 1103 ObjectContainerInstances::iterator pos, end = instances.end(); 1104 for (pos = instances.begin(); pos != end; ++ pos) 1105 { 1106 if (name == pos->name) 1107 return pos->create_callback; 1108 } 1109 } 1110 return NULL; 1111 } 1112 1113 ObjectFileGetModuleSpecifications 1114 PluginManager::GetObjectContainerGetModuleSpecificationsCallbackAtIndex (uint32_t idx) 1115 { 1116 Mutex::Locker locker (GetObjectContainerMutex ()); 1117 ObjectContainerInstances &instances = GetObjectContainerInstances (); 1118 if (idx < instances.size()) 1119 return instances[idx].get_module_specifications; 1120 return NULL; 1121 } 1122 1123 #pragma mark LogChannel 1124 1125 struct LogInstance 1126 { 1127 LogInstance() : 1128 name(), 1129 description(), 1130 create_callback(NULL) 1131 { 1132 } 1133 1134 ConstString name; 1135 std::string description; 1136 LogChannelCreateInstance create_callback; 1137 }; 1138 1139 typedef std::vector<LogInstance> LogInstances; 1140 1141 static Mutex & 1142 GetLogMutex () 1143 { 1144 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive); 1145 return g_instances_mutex; 1146 } 1147 1148 static LogInstances & 1149 GetLogInstances () 1150 { 1151 static LogInstances g_instances; 1152 return g_instances; 1153 } 1154 1155 1156 1157 bool 1158 PluginManager::RegisterPlugin 1159 ( 1160 const ConstString &name, 1161 const char *description, 1162 LogChannelCreateInstance create_callback 1163 ) 1164 { 1165 if (create_callback) 1166 { 1167 LogInstance instance; 1168 assert ((bool)name); 1169 instance.name = name; 1170 if (description && description[0]) 1171 instance.description = description; 1172 instance.create_callback = create_callback; 1173 Mutex::Locker locker (GetLogMutex ()); 1174 GetLogInstances ().push_back (instance); 1175 } 1176 return false; 1177 } 1178 1179 bool 1180 PluginManager::UnregisterPlugin (LogChannelCreateInstance create_callback) 1181 { 1182 if (create_callback) 1183 { 1184 Mutex::Locker locker (GetLogMutex ()); 1185 LogInstances &instances = GetLogInstances (); 1186 1187 LogInstances::iterator pos, end = instances.end(); 1188 for (pos = instances.begin(); pos != end; ++ pos) 1189 { 1190 if (pos->create_callback == create_callback) 1191 { 1192 instances.erase(pos); 1193 return true; 1194 } 1195 } 1196 } 1197 return false; 1198 } 1199 1200 const char * 1201 PluginManager::GetLogChannelCreateNameAtIndex (uint32_t idx) 1202 { 1203 Mutex::Locker locker (GetLogMutex ()); 1204 LogInstances &instances = GetLogInstances (); 1205 if (idx < instances.size()) 1206 return instances[idx].name.GetCString(); 1207 return NULL; 1208 } 1209 1210 1211 LogChannelCreateInstance 1212 PluginManager::GetLogChannelCreateCallbackAtIndex (uint32_t idx) 1213 { 1214 Mutex::Locker locker (GetLogMutex ()); 1215 LogInstances &instances = GetLogInstances (); 1216 if (idx < instances.size()) 1217 return instances[idx].create_callback; 1218 return NULL; 1219 } 1220 1221 LogChannelCreateInstance 1222 PluginManager::GetLogChannelCreateCallbackForPluginName (const ConstString &name) 1223 { 1224 if (name) 1225 { 1226 Mutex::Locker locker (GetLogMutex ()); 1227 LogInstances &instances = GetLogInstances (); 1228 1229 LogInstances::iterator pos, end = instances.end(); 1230 for (pos = instances.begin(); pos != end; ++ pos) 1231 { 1232 if (name == pos->name) 1233 return pos->create_callback; 1234 } 1235 } 1236 return NULL; 1237 } 1238 1239 #pragma mark Platform 1240 1241 struct PlatformInstance 1242 { 1243 PlatformInstance() : 1244 name(), 1245 description(), 1246 create_callback(NULL), 1247 debugger_init_callback (NULL) 1248 { 1249 } 1250 1251 ConstString name; 1252 std::string description; 1253 PlatformCreateInstance create_callback; 1254 DebuggerInitializeCallback debugger_init_callback; 1255 }; 1256 1257 typedef std::vector<PlatformInstance> PlatformInstances; 1258 1259 static Mutex & 1260 GetPlatformInstancesMutex () 1261 { 1262 static Mutex g_platform_instances_mutex (Mutex::eMutexTypeRecursive); 1263 return g_platform_instances_mutex; 1264 } 1265 1266 static PlatformInstances & 1267 GetPlatformInstances () 1268 { 1269 static PlatformInstances g_platform_instances; 1270 return g_platform_instances; 1271 } 1272 1273 1274 bool 1275 PluginManager::RegisterPlugin (const ConstString &name, 1276 const char *description, 1277 PlatformCreateInstance create_callback, 1278 DebuggerInitializeCallback debugger_init_callback) 1279 { 1280 if (create_callback) 1281 { 1282 Mutex::Locker locker (GetPlatformInstancesMutex ()); 1283 1284 PlatformInstance instance; 1285 assert ((bool)name); 1286 instance.name = name; 1287 if (description && description[0]) 1288 instance.description = description; 1289 instance.create_callback = create_callback; 1290 instance.debugger_init_callback = debugger_init_callback; 1291 GetPlatformInstances ().push_back (instance); 1292 return true; 1293 } 1294 return false; 1295 } 1296 1297 1298 const char * 1299 PluginManager::GetPlatformPluginNameAtIndex (uint32_t idx) 1300 { 1301 Mutex::Locker locker (GetPlatformInstancesMutex ()); 1302 PlatformInstances &instances = GetPlatformInstances (); 1303 if (idx < instances.size()) 1304 return instances[idx].name.GetCString(); 1305 return NULL; 1306 } 1307 1308 const char * 1309 PluginManager::GetPlatformPluginDescriptionAtIndex (uint32_t idx) 1310 { 1311 Mutex::Locker locker (GetPlatformInstancesMutex ()); 1312 PlatformInstances &instances = GetPlatformInstances (); 1313 if (idx < instances.size()) 1314 return instances[idx].description.c_str(); 1315 return NULL; 1316 } 1317 1318 bool 1319 PluginManager::UnregisterPlugin (PlatformCreateInstance create_callback) 1320 { 1321 if (create_callback) 1322 { 1323 Mutex::Locker locker (GetPlatformInstancesMutex ()); 1324 PlatformInstances &instances = GetPlatformInstances (); 1325 1326 PlatformInstances::iterator pos, end = instances.end(); 1327 for (pos = instances.begin(); pos != end; ++ pos) 1328 { 1329 if (pos->create_callback == create_callback) 1330 { 1331 instances.erase(pos); 1332 return true; 1333 } 1334 } 1335 } 1336 return false; 1337 } 1338 1339 PlatformCreateInstance 1340 PluginManager::GetPlatformCreateCallbackAtIndex (uint32_t idx) 1341 { 1342 Mutex::Locker locker (GetPlatformInstancesMutex ()); 1343 PlatformInstances &instances = GetPlatformInstances (); 1344 if (idx < instances.size()) 1345 return instances[idx].create_callback; 1346 return NULL; 1347 } 1348 1349 PlatformCreateInstance 1350 PluginManager::GetPlatformCreateCallbackForPluginName (const ConstString &name) 1351 { 1352 if (name) 1353 { 1354 Mutex::Locker locker (GetPlatformInstancesMutex ()); 1355 PlatformInstances &instances = GetPlatformInstances (); 1356 1357 PlatformInstances::iterator pos, end = instances.end(); 1358 for (pos = instances.begin(); pos != end; ++ pos) 1359 { 1360 if (name == pos->name) 1361 return pos->create_callback; 1362 } 1363 } 1364 return NULL; 1365 } 1366 1367 size_t 1368 PluginManager::AutoCompletePlatformName (const char *name, StringList &matches) 1369 { 1370 if (name) 1371 { 1372 Mutex::Locker locker (GetPlatformInstancesMutex ()); 1373 PlatformInstances &instances = GetPlatformInstances (); 1374 llvm::StringRef name_sref(name); 1375 1376 PlatformInstances::iterator pos, end = instances.end(); 1377 for (pos = instances.begin(); pos != end; ++ pos) 1378 { 1379 llvm::StringRef plugin_name (pos->name.GetCString()); 1380 if (plugin_name.startswith(name_sref)) 1381 matches.AppendString (plugin_name.data()); 1382 } 1383 } 1384 return matches.GetSize(); 1385 } 1386 #pragma mark Process 1387 1388 struct ProcessInstance 1389 { 1390 ProcessInstance() : 1391 name(), 1392 description(), 1393 create_callback(NULL), 1394 debugger_init_callback(NULL) 1395 { 1396 } 1397 1398 ConstString name; 1399 std::string description; 1400 ProcessCreateInstance create_callback; 1401 DebuggerInitializeCallback debugger_init_callback; 1402 }; 1403 1404 typedef std::vector<ProcessInstance> ProcessInstances; 1405 1406 static Mutex & 1407 GetProcessMutex () 1408 { 1409 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive); 1410 return g_instances_mutex; 1411 } 1412 1413 static ProcessInstances & 1414 GetProcessInstances () 1415 { 1416 static ProcessInstances g_instances; 1417 return g_instances; 1418 } 1419 1420 1421 bool 1422 PluginManager::RegisterPlugin (const ConstString &name, 1423 const char *description, 1424 ProcessCreateInstance create_callback, 1425 DebuggerInitializeCallback debugger_init_callback) 1426 { 1427 if (create_callback) 1428 { 1429 ProcessInstance instance; 1430 assert ((bool)name); 1431 instance.name = name; 1432 if (description && description[0]) 1433 instance.description = description; 1434 instance.create_callback = create_callback; 1435 instance.debugger_init_callback = debugger_init_callback; 1436 Mutex::Locker locker (GetProcessMutex ()); 1437 GetProcessInstances ().push_back (instance); 1438 } 1439 return false; 1440 } 1441 1442 const char * 1443 PluginManager::GetProcessPluginNameAtIndex (uint32_t idx) 1444 { 1445 Mutex::Locker locker (GetProcessMutex ()); 1446 ProcessInstances &instances = GetProcessInstances (); 1447 if (idx < instances.size()) 1448 return instances[idx].name.GetCString(); 1449 return NULL; 1450 } 1451 1452 const char * 1453 PluginManager::GetProcessPluginDescriptionAtIndex (uint32_t idx) 1454 { 1455 Mutex::Locker locker (GetProcessMutex ()); 1456 ProcessInstances &instances = GetProcessInstances (); 1457 if (idx < instances.size()) 1458 return instances[idx].description.c_str(); 1459 return NULL; 1460 } 1461 1462 bool 1463 PluginManager::UnregisterPlugin (ProcessCreateInstance create_callback) 1464 { 1465 if (create_callback) 1466 { 1467 Mutex::Locker locker (GetProcessMutex ()); 1468 ProcessInstances &instances = GetProcessInstances (); 1469 1470 ProcessInstances::iterator pos, end = instances.end(); 1471 for (pos = instances.begin(); pos != end; ++ pos) 1472 { 1473 if (pos->create_callback == create_callback) 1474 { 1475 instances.erase(pos); 1476 return true; 1477 } 1478 } 1479 } 1480 return false; 1481 } 1482 1483 ProcessCreateInstance 1484 PluginManager::GetProcessCreateCallbackAtIndex (uint32_t idx) 1485 { 1486 Mutex::Locker locker (GetProcessMutex ()); 1487 ProcessInstances &instances = GetProcessInstances (); 1488 if (idx < instances.size()) 1489 return instances[idx].create_callback; 1490 return NULL; 1491 } 1492 1493 1494 ProcessCreateInstance 1495 PluginManager::GetProcessCreateCallbackForPluginName (const ConstString &name) 1496 { 1497 if (name) 1498 { 1499 Mutex::Locker locker (GetProcessMutex ()); 1500 ProcessInstances &instances = GetProcessInstances (); 1501 1502 ProcessInstances::iterator pos, end = instances.end(); 1503 for (pos = instances.begin(); pos != end; ++ pos) 1504 { 1505 if (name == pos->name) 1506 return pos->create_callback; 1507 } 1508 } 1509 return NULL; 1510 } 1511 1512 #pragma mark SymbolFile 1513 1514 struct SymbolFileInstance 1515 { 1516 SymbolFileInstance() : 1517 name(), 1518 description(), 1519 create_callback(NULL) 1520 { 1521 } 1522 1523 ConstString name; 1524 std::string description; 1525 SymbolFileCreateInstance create_callback; 1526 }; 1527 1528 typedef std::vector<SymbolFileInstance> SymbolFileInstances; 1529 1530 static Mutex & 1531 GetSymbolFileMutex () 1532 { 1533 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive); 1534 return g_instances_mutex; 1535 } 1536 1537 static SymbolFileInstances & 1538 GetSymbolFileInstances () 1539 { 1540 static SymbolFileInstances g_instances; 1541 return g_instances; 1542 } 1543 1544 1545 bool 1546 PluginManager::RegisterPlugin 1547 ( 1548 const ConstString &name, 1549 const char *description, 1550 SymbolFileCreateInstance create_callback 1551 ) 1552 { 1553 if (create_callback) 1554 { 1555 SymbolFileInstance instance; 1556 assert ((bool)name); 1557 instance.name = name; 1558 if (description && description[0]) 1559 instance.description = description; 1560 instance.create_callback = create_callback; 1561 Mutex::Locker locker (GetSymbolFileMutex ()); 1562 GetSymbolFileInstances ().push_back (instance); 1563 } 1564 return false; 1565 } 1566 1567 bool 1568 PluginManager::UnregisterPlugin (SymbolFileCreateInstance create_callback) 1569 { 1570 if (create_callback) 1571 { 1572 Mutex::Locker locker (GetSymbolFileMutex ()); 1573 SymbolFileInstances &instances = GetSymbolFileInstances (); 1574 1575 SymbolFileInstances::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 SymbolFileCreateInstance 1589 PluginManager::GetSymbolFileCreateCallbackAtIndex (uint32_t idx) 1590 { 1591 Mutex::Locker locker (GetSymbolFileMutex ()); 1592 SymbolFileInstances &instances = GetSymbolFileInstances (); 1593 if (idx < instances.size()) 1594 return instances[idx].create_callback; 1595 return NULL; 1596 } 1597 1598 SymbolFileCreateInstance 1599 PluginManager::GetSymbolFileCreateCallbackForPluginName (const ConstString &name) 1600 { 1601 if (name) 1602 { 1603 Mutex::Locker locker (GetSymbolFileMutex ()); 1604 SymbolFileInstances &instances = GetSymbolFileInstances (); 1605 1606 SymbolFileInstances::iterator pos, end = instances.end(); 1607 for (pos = instances.begin(); pos != end; ++ pos) 1608 { 1609 if (name == pos->name) 1610 return pos->create_callback; 1611 } 1612 } 1613 return NULL; 1614 } 1615 1616 1617 1618 #pragma mark SymbolVendor 1619 1620 struct SymbolVendorInstance 1621 { 1622 SymbolVendorInstance() : 1623 name(), 1624 description(), 1625 create_callback(NULL) 1626 { 1627 } 1628 1629 ConstString name; 1630 std::string description; 1631 SymbolVendorCreateInstance create_callback; 1632 }; 1633 1634 typedef std::vector<SymbolVendorInstance> SymbolVendorInstances; 1635 1636 static Mutex & 1637 GetSymbolVendorMutex () 1638 { 1639 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive); 1640 return g_instances_mutex; 1641 } 1642 1643 static SymbolVendorInstances & 1644 GetSymbolVendorInstances () 1645 { 1646 static SymbolVendorInstances g_instances; 1647 return g_instances; 1648 } 1649 1650 bool 1651 PluginManager::RegisterPlugin 1652 ( 1653 const ConstString &name, 1654 const char *description, 1655 SymbolVendorCreateInstance create_callback 1656 ) 1657 { 1658 if (create_callback) 1659 { 1660 SymbolVendorInstance 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 (GetSymbolVendorMutex ()); 1667 GetSymbolVendorInstances ().push_back (instance); 1668 } 1669 return false; 1670 } 1671 1672 bool 1673 PluginManager::UnregisterPlugin (SymbolVendorCreateInstance create_callback) 1674 { 1675 if (create_callback) 1676 { 1677 Mutex::Locker locker (GetSymbolVendorMutex ()); 1678 SymbolVendorInstances &instances = GetSymbolVendorInstances (); 1679 1680 SymbolVendorInstances::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 SymbolVendorCreateInstance 1694 PluginManager::GetSymbolVendorCreateCallbackAtIndex (uint32_t idx) 1695 { 1696 Mutex::Locker locker (GetSymbolVendorMutex ()); 1697 SymbolVendorInstances &instances = GetSymbolVendorInstances (); 1698 if (idx < instances.size()) 1699 return instances[idx].create_callback; 1700 return NULL; 1701 } 1702 1703 1704 SymbolVendorCreateInstance 1705 PluginManager::GetSymbolVendorCreateCallbackForPluginName (const ConstString &name) 1706 { 1707 if (name) 1708 { 1709 Mutex::Locker locker (GetSymbolVendorMutex ()); 1710 SymbolVendorInstances &instances = GetSymbolVendorInstances (); 1711 1712 SymbolVendorInstances::iterator pos, end = instances.end(); 1713 for (pos = instances.begin(); pos != end; ++ pos) 1714 { 1715 if (name == pos->name) 1716 return pos->create_callback; 1717 } 1718 } 1719 return NULL; 1720 } 1721 1722 1723 #pragma mark UnwindAssembly 1724 1725 struct UnwindAssemblyInstance 1726 { 1727 UnwindAssemblyInstance() : 1728 name(), 1729 description(), 1730 create_callback(NULL) 1731 { 1732 } 1733 1734 ConstString name; 1735 std::string description; 1736 UnwindAssemblyCreateInstance create_callback; 1737 }; 1738 1739 typedef std::vector<UnwindAssemblyInstance> UnwindAssemblyInstances; 1740 1741 static Mutex & 1742 GetUnwindAssemblyMutex () 1743 { 1744 static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive); 1745 return g_instances_mutex; 1746 } 1747 1748 static UnwindAssemblyInstances & 1749 GetUnwindAssemblyInstances () 1750 { 1751 static UnwindAssemblyInstances g_instances; 1752 return g_instances; 1753 } 1754 1755 bool 1756 PluginManager::RegisterPlugin 1757 ( 1758 const ConstString &name, 1759 const char *description, 1760 UnwindAssemblyCreateInstance create_callback 1761 ) 1762 { 1763 if (create_callback) 1764 { 1765 UnwindAssemblyInstance 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 (GetUnwindAssemblyMutex ()); 1772 GetUnwindAssemblyInstances ().push_back (instance); 1773 } 1774 return false; 1775 } 1776 1777 bool 1778 PluginManager::UnregisterPlugin (UnwindAssemblyCreateInstance create_callback) 1779 { 1780 if (create_callback) 1781 { 1782 Mutex::Locker locker (GetUnwindAssemblyMutex ()); 1783 UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances (); 1784 1785 UnwindAssemblyInstances::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 UnwindAssemblyCreateInstance 1799 PluginManager::GetUnwindAssemblyCreateCallbackAtIndex (uint32_t idx) 1800 { 1801 Mutex::Locker locker (GetUnwindAssemblyMutex ()); 1802 UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances (); 1803 if (idx < instances.size()) 1804 return instances[idx].create_callback; 1805 return NULL; 1806 } 1807 1808 1809 UnwindAssemblyCreateInstance 1810 PluginManager::GetUnwindAssemblyCreateCallbackForPluginName (const ConstString &name) 1811 { 1812 if (name) 1813 { 1814 Mutex::Locker locker (GetUnwindAssemblyMutex ()); 1815 UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances (); 1816 1817 UnwindAssemblyInstances::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 void 1828 PluginManager::DebuggerInitialize (Debugger &debugger) 1829 { 1830 // Initialize the DynamicLoader plugins 1831 { 1832 Mutex::Locker locker (GetDynamicLoaderMutex ()); 1833 DynamicLoaderInstances &instances = GetDynamicLoaderInstances (); 1834 1835 DynamicLoaderInstances::iterator pos, end = instances.end(); 1836 for (pos = instances.begin(); pos != end; ++ pos) 1837 { 1838 if (pos->debugger_init_callback) 1839 pos->debugger_init_callback (debugger); 1840 } 1841 } 1842 1843 // Initialize the Platform plugins 1844 { 1845 Mutex::Locker locker (GetPlatformInstancesMutex ()); 1846 PlatformInstances &instances = GetPlatformInstances (); 1847 1848 PlatformInstances::iterator pos, end = instances.end(); 1849 for (pos = instances.begin(); pos != end; ++ pos) 1850 { 1851 if (pos->debugger_init_callback) 1852 pos->debugger_init_callback (debugger); 1853 } 1854 } 1855 1856 // Initialize the Process plugins 1857 { 1858 Mutex::Locker locker (GetProcessMutex()); 1859 ProcessInstances &instances = GetProcessInstances(); 1860 1861 ProcessInstances::iterator pos, end = instances.end(); 1862 for (pos = instances.begin(); pos != end; ++ pos) 1863 { 1864 if (pos->debugger_init_callback) 1865 pos->debugger_init_callback (debugger); 1866 } 1867 } 1868 1869 } 1870 1871 // This is the preferred new way to register plugin specific settings. e.g. 1872 // This will put a plugin's settings under e.g. "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME". 1873 static lldb::OptionValuePropertiesSP 1874 GetDebuggerPropertyForPlugins (Debugger &debugger, 1875 const ConstString &plugin_type_name, 1876 const ConstString &plugin_type_desc, 1877 bool can_create) 1878 { 1879 lldb::OptionValuePropertiesSP parent_properties_sp (debugger.GetValueProperties()); 1880 if (parent_properties_sp) 1881 { 1882 static ConstString g_property_name("plugin"); 1883 1884 OptionValuePropertiesSP plugin_properties_sp = parent_properties_sp->GetSubProperty (NULL, g_property_name); 1885 if (!plugin_properties_sp && can_create) 1886 { 1887 plugin_properties_sp.reset (new OptionValueProperties (g_property_name)); 1888 parent_properties_sp->AppendProperty (g_property_name, 1889 ConstString("Settings specify to plugins."), 1890 true, 1891 plugin_properties_sp); 1892 } 1893 1894 if (plugin_properties_sp) 1895 { 1896 lldb::OptionValuePropertiesSP plugin_type_properties_sp = plugin_properties_sp->GetSubProperty (NULL, plugin_type_name); 1897 if (!plugin_type_properties_sp && can_create) 1898 { 1899 plugin_type_properties_sp.reset (new OptionValueProperties (plugin_type_name)); 1900 plugin_properties_sp->AppendProperty (plugin_type_name, 1901 plugin_type_desc, 1902 true, 1903 plugin_type_properties_sp); 1904 } 1905 return plugin_type_properties_sp; 1906 } 1907 } 1908 return lldb::OptionValuePropertiesSP(); 1909 } 1910 1911 // This is deprecated way to register plugin specific settings. e.g. 1912 // "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME" 1913 // and Platform generic settings would be under "platform.SETTINGNAME". 1914 static lldb::OptionValuePropertiesSP 1915 GetDebuggerPropertyForPluginsOldStyle (Debugger &debugger, 1916 const ConstString &plugin_type_name, 1917 const ConstString &plugin_type_desc, 1918 bool can_create) 1919 { 1920 static ConstString g_property_name("plugin"); 1921 lldb::OptionValuePropertiesSP parent_properties_sp (debugger.GetValueProperties()); 1922 if (parent_properties_sp) 1923 { 1924 OptionValuePropertiesSP plugin_properties_sp = parent_properties_sp->GetSubProperty (NULL, plugin_type_name); 1925 if (!plugin_properties_sp && can_create) 1926 { 1927 plugin_properties_sp.reset (new OptionValueProperties (plugin_type_name)); 1928 parent_properties_sp->AppendProperty (plugin_type_name, 1929 plugin_type_desc, 1930 true, 1931 plugin_properties_sp); 1932 } 1933 1934 if (plugin_properties_sp) 1935 { 1936 lldb::OptionValuePropertiesSP plugin_type_properties_sp = plugin_properties_sp->GetSubProperty (NULL, g_property_name); 1937 if (!plugin_type_properties_sp && can_create) 1938 { 1939 plugin_type_properties_sp.reset (new OptionValueProperties (g_property_name)); 1940 plugin_properties_sp->AppendProperty (g_property_name, 1941 ConstString("Settings specific to plugins"), 1942 true, 1943 plugin_type_properties_sp); 1944 } 1945 return plugin_type_properties_sp; 1946 } 1947 } 1948 return lldb::OptionValuePropertiesSP(); 1949 } 1950 1951 1952 lldb::OptionValuePropertiesSP 1953 PluginManager::GetSettingForDynamicLoaderPlugin (Debugger &debugger, const ConstString &setting_name) 1954 { 1955 lldb::OptionValuePropertiesSP properties_sp; 1956 lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPlugins (debugger, 1957 ConstString("dynamic-loader"), 1958 ConstString(), // not creating to so we don't need the description 1959 false)); 1960 if (plugin_type_properties_sp) 1961 properties_sp = plugin_type_properties_sp->GetSubProperty (NULL, setting_name); 1962 return properties_sp; 1963 } 1964 1965 bool 1966 PluginManager::CreateSettingForDynamicLoaderPlugin (Debugger &debugger, 1967 const lldb::OptionValuePropertiesSP &properties_sp, 1968 const ConstString &description, 1969 bool is_global_property) 1970 { 1971 if (properties_sp) 1972 { 1973 lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPlugins (debugger, 1974 ConstString("dynamic-loader"), 1975 ConstString("Settings for dynamic loader plug-ins"), 1976 true)); 1977 if (plugin_type_properties_sp) 1978 { 1979 plugin_type_properties_sp->AppendProperty (properties_sp->GetName(), 1980 description, 1981 is_global_property, 1982 properties_sp); 1983 return true; 1984 } 1985 } 1986 return false; 1987 } 1988 1989 1990 lldb::OptionValuePropertiesSP 1991 PluginManager::GetSettingForPlatformPlugin (Debugger &debugger, const ConstString &setting_name) 1992 { 1993 lldb::OptionValuePropertiesSP properties_sp; 1994 lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPluginsOldStyle (debugger, 1995 ConstString("platform"), 1996 ConstString(), // not creating to so we don't need the description 1997 false)); 1998 if (plugin_type_properties_sp) 1999 properties_sp = plugin_type_properties_sp->GetSubProperty (NULL, setting_name); 2000 return properties_sp; 2001 } 2002 2003 bool 2004 PluginManager::CreateSettingForPlatformPlugin (Debugger &debugger, 2005 const lldb::OptionValuePropertiesSP &properties_sp, 2006 const ConstString &description, 2007 bool is_global_property) 2008 { 2009 if (properties_sp) 2010 { 2011 lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPluginsOldStyle (debugger, 2012 ConstString("platform"), 2013 ConstString("Settings for platform plug-ins"), 2014 true)); 2015 if (plugin_type_properties_sp) 2016 { 2017 plugin_type_properties_sp->AppendProperty (properties_sp->GetName(), 2018 description, 2019 is_global_property, 2020 properties_sp); 2021 return true; 2022 } 2023 } 2024 return false; 2025 } 2026 2027 2028 lldb::OptionValuePropertiesSP 2029 PluginManager::GetSettingForProcessPlugin (Debugger &debugger, const ConstString &setting_name) 2030 { 2031 lldb::OptionValuePropertiesSP properties_sp; 2032 lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPlugins (debugger, 2033 ConstString("process"), 2034 ConstString(), // not creating to so we don't need the description 2035 false)); 2036 if (plugin_type_properties_sp) 2037 properties_sp = plugin_type_properties_sp->GetSubProperty (NULL, setting_name); 2038 return properties_sp; 2039 } 2040 2041 bool 2042 PluginManager::CreateSettingForProcessPlugin (Debugger &debugger, 2043 const lldb::OptionValuePropertiesSP &properties_sp, 2044 const ConstString &description, 2045 bool is_global_property) 2046 { 2047 if (properties_sp) 2048 { 2049 lldb::OptionValuePropertiesSP plugin_type_properties_sp (GetDebuggerPropertyForPlugins (debugger, 2050 ConstString("process"), 2051 ConstString("Settings for process plug-ins"), 2052 true)); 2053 if (plugin_type_properties_sp) 2054 { 2055 plugin_type_properties_sp->AppendProperty (properties_sp->GetName(), 2056 description, 2057 is_global_property, 2058 properties_sp); 2059 return true; 2060 } 2061 } 2062 return false; 2063 } 2064 2065
