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