Extend DynamicLibrary class to be usable without loading permanently.

include/lldb/Core/Debugger.h

SourceManager::SourceFileCache m_source_file_cache; // All the source managers
                                                       // source file cache.
   std::unique_ptr<CommandInterpreter> m_command_interpreter_ap;
 
   IOHandlerStack m_input_reader_stack;
   llvm::StringMap<std::weak_ptr<llvm::raw_ostream>> m_log_streams;
   std::shared_ptr<llvm::raw_ostream> m_log_callback_stream_sp;
   ConstString m_instance_name;
   static LoadPluginCallbackType g_load_plugin_callback;
-  typedef std::vector<llvm::sys::DynamicLibrary> LoadedPluginsList;
+  typedef std::vector<llvm::sys::DynamicLibrary*> LoadedPluginsList;
   LoadedPluginsList m_loaded_plugins;
   HostThread m_event_handler_thread;
   HostThread m_io_handler_thread;
   Broadcaster m_sync_broadcaster;
   lldb::ListenerSP m_forward_listener_sp;
   llvm::once_flag m_clear_once;
 
   //----------------------------------------------------------------------

include/lldb/lldb-private-types.h

 class DynamicLibrary;
 }
 }
 
 namespace lldb_private {
 class Platform;
 class ExecutionContext;
 
-typedef llvm::sys::DynamicLibrary (*LoadPluginCallbackType)(
+typedef llvm::sys::DynamicLibrary* (*LoadPluginCallbackType)(
     const lldb::DebuggerSP &debugger_sp, const FileSpec &spec, Status &error);
 
 //----------------------------------------------------------------------
 // Every register is described in detail including its name, alternate
 // name (optional), encoding, size in bytes and the default display
 // format.
 //----------------------------------------------------------------------
 struct RegisterInfo {

source/API/SBDebugger.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp,
-                                            const FileSpec &spec,
-                                            Status &error) {
-  llvm::sys::DynamicLibrary dynlib =
-      llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
-  if (dynlib.isValid()) {
+static llvm::sys::DynamicLibrary *
+LoadPlugin(const lldb::DebuggerSP &debugger_sp, const FileSpec &spec,
+  if (llvm::sys::DynamicLibrary *dynlib =
+      llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str())) {
     typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger);
 
     lldb::SBDebugger debugger_sb(debugger_sp);
     // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger)
     // function.
     // TODO: mangle this differently for your system - on OSX, the first
     // underscore needs to be removed and the second one stays
     LLDBCommandPluginInit init_func =
-        (LLDBCommandPluginInit)dynlib.getAddressOfSymbol(
+        (LLDBCommandPluginInit)dynlib->getAddressOfSymbol(
             "_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
     if (init_func) {
       if (init_func(debugger_sb))
         return dynlib;
       else
         error.SetErrorString("plug-in refused to load "
                              "(lldb::PluginInitialize(lldb::SBDebugger) "
                              "returned false)");
     } else {
       error.SetErrorString("plug-in is missing the required initialization: "
                            "lldb::PluginInitialize(lldb::SBDebugger)");
     }
   } else {
     if (spec.Exists())
       error.SetErrorString("this file does not represent a loadable dylib");
     else
       error.SetErrorString("no such file");
   }
-  return llvm::sys::DynamicLibrary();
+  return nullptr;
 }
 
 static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;
 
 SBError SBInputReader::Initialize(
     lldb::SBDebugger &sb_debugger,
     unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
                       char const *, unsigned long),

source/Core/Debugger.cpp

 }
 
 void Debugger::SettingsInitialize() { Target::SettingsInitialize(); }
 
 void Debugger::SettingsTerminate() { Target::SettingsTerminate(); }
 
 bool Debugger::LoadPlugin(const FileSpec &spec, Status &error) {
   if (g_load_plugin_callback) {
-    llvm::sys::DynamicLibrary dynlib =
-        g_load_plugin_callback(shared_from_this(), spec, error);
-    if (dynlib.isValid()) {
+    if (llvm::sys::DynamicLibrary *dynlib =
+        g_load_plugin_callback(shared_from_this(), spec, error)) {
       m_loaded_plugins.push_back(dynlib);
       return true;
     }
   } else {
     // The g_load_plugin_callback is registered in SBDebugger::Initialize()
     // and if the public API layer isn't available (code is linking against
     // all of the internal LLDB static libraries), then we can't load plugins
     error.SetErrorString("Public API layer is not available");

source/Core/PluginManager.cpp

enum PluginAction {
   ePluginUnregisterInstance,
   ePluginGetInstanceAtIndex
 };
 
 typedef bool (*PluginInitCallback)();
 typedef void (*PluginTermCallback)();
 
 struct PluginInfo {
-  PluginInfo() : plugin_init_callback(nullptr), plugin_term_callback(nullptr) {}
-
-  llvm::sys::DynamicLibrary library;
-  PluginInitCallback plugin_init_callback;
-  PluginTermCallback plugin_term_callback;
+  llvm::sys::DynamicLibrary* library = nullptr;
+  PluginInitCallback plugin_init_callback = nullptr;
+  PluginTermCallback plugin_term_callback = nullptr;
 };
 
 typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;
 
 static std::recursive_mutex &GetPluginMapMutex() {
   static std::recursive_mutex g_plugin_map_mutex;
   return g_plugin_map_mutex;
 }
if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
     if (PluginIsLoaded(plugin_file_spec))
       return FileSpec::eEnumerateDirectoryResultNext;
     else {
       PluginInfo plugin_info;
 
       std::string pluginLoadError;
       plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(
           plugin_file_spec.GetPath().c_str(), &pluginLoadError);
-      if (plugin_info.library.isValid()) {
+      if (plugin_info.library) {
         bool success = false;
         plugin_info.plugin_init_callback = CastToFPtr<PluginInitCallback>(
-            plugin_info.library.getAddressOfSymbol("LLDBPluginInitialize"));
+            plugin_info.library->getAddressOfSymbol("LLDBPluginInitialize"));
         if (plugin_info.plugin_init_callback) {
           // Call the plug-in "bool LLDBPluginInitialize(void)" function
           success = plugin_info.plugin_init_callback();
         }
 
         if (success) {
           // It is ok for the "LLDBPluginTerminate" symbol to be nullptr
           plugin_info.plugin_term_callback = CastToFPtr<PluginTermCallback>(
-              plugin_info.library.getAddressOfSymbol("LLDBPluginTerminate"));
+              plugin_info.library->getAddressOfSymbol("LLDBPluginTerminate"));
         } else {
           // The initialize function returned FALSE which means the plug-in
           // might not be
           // compatible, or might be too new or too old, or might not want to
           // run on this
           // machine.  Set it to a default-constructed instance to invalidate
           // it.
           plugin_info = PluginInfo();
#if 1
   }
 #endif
 }
 
 void PluginManager::Terminate() {
   std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
   PluginTerminateMap &plugin_map = GetPluginMap();
 
-  PluginTerminateMap::const_iterator pos, end = plugin_map.end();
-  for (pos = plugin_map.begin(); pos != end; ++pos) {
+  for (const auto &pos : plugin_map) {
+    const PluginInfo &plugin = pos.second;
     // Call the plug-in "void LLDBPluginTerminate (void)" function if there
     // is one (if the symbol was not nullptr).
-    if (pos->second.library.isValid()) {
-      if (pos->second.plugin_term_callback)
-        pos->second.plugin_term_callback();
-    }
+    if (plugin.library && plugin.plugin_term_callback)
+      plugin.plugin_term_callback();
   }
   plugin_map.clear();
 }
 
 #pragma mark ABI
 
 struct ABIInstance {
   ABIInstance() : name(), description(), create_callback(nullptr) {}