Add Debugger::InitializeForLLGS to allow ref counted LLGS initialization.

[flackr]

Summary

After http://reviews.llvm.org/D8133 landed as r231550 process launch on remote platform stopped working.

This adds Debugger::InitializeForLLGS and tracks whether one or both of Initialize and InitializeForLLGS have been called, calling only the corresponding lldb_private::Terminate* methods as necessary. Since lldb_private::Terminate calls lldb_private::TerminateForLLGS, the latter method may be called twice if Initialize was called for both however the terminate methods ensure they are only called once after being initialized.

This still maintains the reduced binary size, though it does now technically link in lldb_private::Terminate on lldb-server even though this should never be called.

This should resolve the issue raised in http://reviews.llvm.org/D8133 where Debugger::Terminate assumed that there were 0 references to debugger and terminated early.

[vharron]

Please build and run tests under configure+make before commit.

[flackr]

In D8183#137075, @vharron wrote:

Please build and run tests under configure+make before commit.

Confirmed, tests using configure+make work with this commit.

[tberghammer]

The reference counting looks good. Thanks for adding it.

source/lldb.cpp

189–192 ↗

(On Diff #21514)

Please discuss with @vharron if ScriptInterpreterPython is necessary in LLGS or not (he removed it with a previous CL) and only put it back if it is used for something.

[flackr]

source/lldb.cpp

189–192 ↗

(On Diff #21514)

Yes, he removed it because it was calling Debugger::Terminate in configure+make builds (oddly didn't seem to in cmake) which since it didn't have any references called lldb_private::Terminate cleaning up the objects we intended to use. It does seem to be necessary at least for remote process launching, and he was okay with adding it back as long as the configure+make tests still work which I've tested.

[tberghammer]

Thanks for the explanation

[clayborg]

Looks good.

lldb/trunk/include/lldb/Core/Debugger.h

public:
 
     static lldb::TargetSP
     FindTargetWithProcessID (lldb::pid_t pid);
     
     static lldb::TargetSP
     FindTargetWithProcess (Process *process);
 
     static void
+    InitializeForLLGS (LoadPluginCallbackType load_plugin_callback);
+
+    static void
     Initialize (LoadPluginCallbackType load_plugin_callback);
     
     static void 
     Terminate ();
     
     static void
     SettingsInitialize ();
     

lldb/trunk/source/Core/Debugger.cpp

 //
 
 int
 Debugger::TestDebuggerRefCount ()
 {
     return g_shared_debugger_refcount;
 }
 
+static bool lldb_initialized_for_llgs = false;
+void
+Debugger::InitializeForLLGS (LoadPluginCallbackType load_plugin_callback)
+{
+    lldb_initialized_for_llgs = true;
+    g_shared_debugger_refcount++;
+    g_load_plugin_callback = load_plugin_callback;
+    lldb_private::InitializeForLLGS();
+}
+
+static bool lldb_initialized = true;
 void
 Debugger::Initialize (LoadPluginCallbackType load_plugin_callback)
 {
+    lldb_initialized = true;
+    g_shared_debugger_refcount++;
     g_load_plugin_callback = load_plugin_callback;
-    if (g_shared_debugger_refcount++ == 0)
-        lldb_private::Initialize();
 }
 
 void
 Debugger::Terminate ()
 {
     if (g_shared_debugger_refcount > 0)
     {
         g_shared_debugger_refcount--;
         if (g_shared_debugger_refcount == 0)
         {
             lldb_private::WillTerminate();
+            if (lldb_initialized_for_llgs) {
+                lldb_initialized_for_llgs = false;
+                lldb_private::TerminateLLGS();
+            }
+            if (lldb_initialized) {
+                lldb_initialized = false;
                 lldb_private::Terminate();
+            }
 
             // Clear our master list of debugger objects
             Mutex::Locker locker (GetDebuggerListMutex ());
             GetDebuggerList().clear();
         }
     }
 }
 

lldb/trunk/source/lldb.cpp

 using namespace lldb_private;
 
 static void fatal_error_handler(void *user_data, const std::string& reason,
                                 bool gen_crash_diag) {
     Host::SetCrashDescription(reason.c_str());
     ::abort();
 }
 
+static bool g_inited_for_llgs = false;
 void
 lldb_private::InitializeForLLGS ()
 {
     // Make sure we initialize only once
     static Mutex g_inited_mutex(Mutex::eMutexTypeRecursive);
-    static bool g_inited = false;
 
     Mutex::Locker locker(g_inited_mutex);
-    if (!g_inited)
+    if (!g_inited_for_llgs)
     {
-        g_inited = true;
+        g_inited_for_llgs = true;
 
 #if defined(_MSC_VER)
         const char *disable_crash_dialog_var = getenv("LLDB_DISABLE_CRASH_DIALOG");
         if (disable_crash_dialog_var && llvm::StringRef(disable_crash_dialog_var).equals_lower("true"))
         {
             // This will prevent Windows from displaying a dialog box requiring user interaction when
             // LLDB crashes.  This is mostly useful when automating LLDB, for example via the test
             // suite, so that a crash in LLDB does not prevent completion of the test suite.
#endif
         SystemRuntimeMacOSX::Initialize();
 
 #if defined (__APPLE__)
         SymbolVendorMacOSX::Initialize();
         DynamicLoaderDarwinKernel::Initialize();
         PlatformDarwinKernel::Initialize();
         ObjectFileMachO::Initialize();
 #endif
+#ifndef LLDB_DISABLE_PYTHON
+        ScriptInterpreterPython::InitializePrivate();
+        OperatingSystemPython::Initialize();
+#endif
     }
 }
 
+static bool g_inited = false;
 void
 lldb_private::Initialize ()
 {
     // Make sure we initialize only once
     static Mutex g_inited_mutex(Mutex::eMutexTypeRecursive);
-    static bool g_inited = false;
 
     InitializeForLLGS();
     Mutex::Locker locker(g_inited_mutex);
     if (!g_inited)
     {
         g_inited = true;
 
-#ifndef LLDB_DISABLE_PYTHON
-        ScriptInterpreterPython::InitializePrivate();
-        OperatingSystemPython::Initialize();
-#endif
-
         // Initialize LLVM and Clang
         llvm::InitializeAllTargets();
         llvm::InitializeAllAsmPrinters();
         llvm::InitializeAllTargetMCs();
         llvm::InitializeAllDisassemblers();
 
         ABIMacOSX_i386::Initialize();
         ABIMacOSX_arm::Initialize();

 lldb_private::WillTerminate()
 {
     Host::WillTerminate();
 }
 
 void
 lldb_private::TerminateLLGS ()
 {
+    if (g_inited_for_llgs)
+    {
+        g_inited_for_llgs = false;
+
         Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
         ObjectContainerBSDArchive::Terminate();
         ObjectFileELF::Terminate();
         SymbolVendorELF::Terminate();
         SymbolFileDWARF::Terminate();
         SymbolFileSymtab::Terminate();
         UnwindAssembly_x86::Terminate();
         UnwindAssemblyInstEmulation::Terminate();
         EmulateInstructionARM::Terminate ();
         EmulateInstructionARM64::Terminate ();
         ObjectFilePECOFF::Terminate ();
         DynamicLoaderPOSIXDYLD::Terminate ();
         PlatformFreeBSD::Terminate();
         PlatformLinux::Terminate();
         PlatformWindows::Terminate();
         PlatformKalimba::Terminate();
         PlatformAndroid::Terminate();
         SymbolFileDWARFDebugMap::Terminate();
         ItaniumABILanguageRuntime::Terminate();
         DynamicLoaderMacOSXDYLD::Terminate();
         AppleObjCRuntimeV2::Terminate();
         AppleObjCRuntimeV1::Terminate();
         ObjectContainerUniversalMachO::Terminate();
         PlatformMacOSX::Terminate();
         PlatformRemoteiOS::Terminate();
         PlatformiOSSimulator::Terminate();
         SystemRuntimeMacOSX::Terminate();
 
 #if defined (__APPLE__)
         DynamicLoaderDarwinKernel::Terminate();
         ObjectFileMachO::Terminate();
         PlatformDarwinKernel::Terminate();
         SymbolVendorMacOSX::Terminate();
 #endif
 
+#ifndef LLDB_DISABLE_PYTHON
+        OperatingSystemPython::Terminate();
+#endif
+
         Log::Terminate();
     }
+}
 
 void
 lldb_private::Terminate ()
 {
+    if (g_inited)
+    {
+        g_inited = false;
+
         Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
         // Terminate and unload and loaded system or user LLDB plug-ins
         PluginManager::Terminate();
         ABIMacOSX_i386::Terminate();
         ABIMacOSX_arm::Terminate();
         ABIMacOSX_arm64::Terminate();
         ABISysV_x86_64::Terminate();
         ABISysV_ppc::Terminate();
         ABISysV_ppc64::Terminate();
         DisassemblerLLVMC::Terminate();
 
         JITLoaderGDB::Terminate();
         ProcessElfCore::Terminate();
         MemoryHistoryASan::Terminate();
         AddressSanitizerRuntime::Terminate();
 
 #if defined (__APPLE__)
         ProcessMachCore::Terminate();
         ProcessKDP::Terminate();
 #endif
 #if defined(_MSC_VER)
         DynamicLoaderWindows::Terminate();
 #endif
 
 #if defined (__linux__)
         ProcessLinux::Terminate();
 #endif
 
 #if defined (__FreeBSD__)
         ProcessFreeBSD::Terminate();
 #endif
         Debugger::SettingsTerminate ();
 
         PlatformRemoteGDBServer::Terminate();
         ProcessGDBRemote::Terminate();
         DynamicLoaderStatic::Terminate();
 
-#ifndef LLDB_DISABLE_PYTHON
-    OperatingSystemPython::Terminate();
-#endif
-
         TerminateLLGS();
     }
+}
 
 #if defined (__APPLE__)
 extern "C" const unsigned char liblldb_coreVersionString[];
 #else
 
 #include "clang/Basic/Version.h"
 
 static const char *

lldb/trunk/tools/lldb-server/lldb-server.cpp

 //===-- lldb-server.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/lldb-private.h"
+#include "lldb/Core/Debugger.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
 static void
 display_usage (const char *progname)
 {
     fprintf(stderr, "Usage:\n"
             "  %s g[dbserver] [options]\n"
             "  %s p[latform] [options]\n"
             "Invoke subcommand for additional help\n", progname, progname);
     exit(0);
 }
 
 // Forward declarations of subcommand main methods.
 int main_gdbserver (int argc, char *argv[]);
 int main_platform (int argc, char *argv[]);
 
 static void
 initialize ()
 {
-    lldb_private::InitializeForLLGS();
+    lldb_private::Debugger::InitializeForLLGS(NULL);
 }
 
 static void
 terminate ()
 {
-    lldb_private::WillTerminate();
-    lldb_private::TerminateLLGS();
+    lldb_private::Debugger::Terminate();
 }
 
 //----------------------------------------------------------------------
 // main
 //----------------------------------------------------------------------
 int
 main (int argc, char *argv[])
 {