Add Initialize/Terminate method to Platform base plugin

[tberghammer]

Summary

Add Initialize/Terminate method to Platform base plugin

The platform base plugin holds a smart pointer to each platform object created in a static variable what cause the platform destructors called only on program exit when other static variables are already destructed. With this change the destructors are called by lldb_private::Terminate() before the exit of the program.

+ Fix DebuggerRefCount handling in ScriptInterpreterPython

The issue pop out during the investigation of a resource leak (port forwards) in platform android caused by the fact that a static variable in Socket.cpp is destructed earlier then an instance of PlatformAndroid.

[clayborg]

Looks good.

include/lldb/Target/Platform.h

namespace lldb_private {
     ///     @li listing and getting info for existing processes
     ///     @li attaching and possibly debugging the platform's kernel
     //----------------------------------------------------------------------
     class Platform :
         public PluginInterface
     {
     public:
 
+        static void
+        Initialize ();
+
+        static void
+        Terminate ();
+
         //------------------------------------------------------------------
-        /// Get the native host platform plug-in. 
+        /// Get the native host platform plug-in.
         ///
         /// There should only be one of these for each host that LLDB runs
         /// upon that should be statically compiled in and registered using
         /// preprocessor macros or other similar build mechanisms in a 
         /// PlatformSubclass::Initialize() function.
         ///
         /// This platform will be used as the default platform when launching
         /// or attaching to processes unless another platform is specified.

source/Interpreter/ScriptInterpreterPython.cpp

if (HostInfo::GetLLDBPath(ePathTypePythonDir, file_spec))
                 python_path.append (python_dir_path);
                 python_path.append ("\")");
                 PyRun_SimpleString (python_path.c_str());
                 python_path.resize (orig_len);
             }
         }
     }
 
+    // Importing 'lldb' module calls SBDebugger::Initialize, which calls Debugger::Initialize, which increments a
+    // global debugger ref-count; therefore we need to check the ref-count before and after importing lldb, and if the
+    // ref-count increased we need to call Debugger::Terminate here to decrement the ref-count so that when the final 
+    // call to Debugger::Terminate is made, the ref-count has the correct value. 
+    
+    int old_count = Debugger::TestDebuggerRefCount ();
+
     PyRun_SimpleString ("sys.dont_write_bytecode = 1; import lldb.embedded_interpreter; from lldb.embedded_interpreter import run_python_interpreter; from lldb.embedded_interpreter import run_one_line");
 
+    int new_count = Debugger::TestDebuggerRefCount ();
+    
+    if (new_count > old_count)
+        Debugger::Terminate ();
+
     if (threads_already_initialized) {
         if (log)
             log->Printf("Releasing PyGILState. Returning to state = %slocked\n", gstate == PyGILState_UNLOCKED ? "un" : "");
         PyGILState_Release (gstate);
     } else {
         // We initialized the threads in this function, just unlock the GIL.
         PyEval_SaveThread();
     }

source/Plugins/Platform/Android/PlatformAndroid.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 static uint32_t g_initialize_count = 0;
 
 void
 PlatformAndroid::Initialize ()
 {
+    PlatformLinux::Initialize ();
+
     if (g_initialize_count++ == 0)
     {
         PluginManager::RegisterPlugin (PlatformAndroid::GetPluginNameStatic(),
                                        PlatformAndroid::GetPluginDescriptionStatic(),
                                        PlatformAndroid::CreateInstance);
     }
 }
 
 void
 PlatformAndroid::Terminate ()
 {
     if (g_initialize_count > 0)
     {
         if (--g_initialize_count == 0)
         {
             PluginManager::UnregisterPlugin (PlatformAndroid::CreateInstance);
         }
     }
+
+    PlatformLinux::Terminate ();
 }
 
 PlatformSP
 PlatformAndroid::CreateInstance (bool force, const ArchSpec *arch)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
     if (log)
     {

source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

else
         return "Remote FreeBSD user platform plug-in.";
 }
 
 static uint32_t g_initialize_count = 0;
 
 void
 PlatformFreeBSD::Initialize ()
 {
+    Platform::Initialize ();
+
     if (g_initialize_count++ == 0)
     {
 #if defined (__FreeBSD__)
       // Force a host flag to true for the default platform object.
         PlatformSP default_platform_sp (new PlatformFreeBSD(true));
         default_platform_sp->SetSystemArchitecture(HostInfo::GetArchitecture());
         Platform::SetHostPlatform (default_platform_sp);
 #endif
         PluginManager::RegisterPlugin(PlatformFreeBSD::GetPluginNameStatic(false),
                                       PlatformFreeBSD::GetDescriptionStatic(false),
                                       PlatformFreeBSD::CreateInstance);
     }
 }
 
 void
 PlatformFreeBSD::Terminate ()
 {
     if (g_initialize_count > 0 && --g_initialize_count == 0)
       PluginManager::UnregisterPlugin (PlatformFreeBSD::CreateInstance);
+
+    Platform::Terminate ();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformFreeBSD::PlatformFreeBSD (bool is_host) :
 Platform(is_host),
 m_remote_platform_sp()

source/Plugins/Platform/Kalimba/PlatformKalimba.cpp

 PlatformKalimba::GetPluginName()
 {
     return GetPluginNameStatic(false);
 }
 
 void
 PlatformKalimba::Initialize ()
 {
+    Platform::Initialize ();
+
     if (g_initialize_count++ == 0)
     {
         PluginManager::RegisterPlugin(PlatformKalimba::GetPluginNameStatic(false),
                                       PlatformKalimba::GetPluginDescriptionStatic(false),
                                       PlatformKalimba::CreateInstance);
     }
 }
 
 void
 PlatformKalimba::Terminate ()
 {
     if (g_initialize_count > 0)
     {
         if (--g_initialize_count == 0)
         {
             PluginManager::UnregisterPlugin (PlatformKalimba::CreateInstance);
         }
     }
+
+    Platform::Terminate ();
 }
 
 Error
 PlatformKalimba::ResolveExecutable (const ModuleSpec &ms,
                                     lldb::ModuleSP &exe_module_sp,
                                     const FileSpecList *module_search_paths_ptr)
 {
     Error error;

source/Plugins/Platform/Linux/PlatformLinux.cpp

 PlatformLinux::GetPluginName()
 {
     return GetPluginNameStatic(IsHost());
 }
 
 void
 PlatformLinux::Initialize ()
 {
+    PlatformPOSIX::Initialize ();
+
     if (g_initialize_count++ == 0)
     {
 #if defined(__linux__)
         PlatformSP default_platform_sp (new PlatformLinux(true));
         default_platform_sp->SetSystemArchitecture(HostInfo::GetArchitecture());
         Platform::SetHostPlatform (default_platform_sp);
 #endif
         PluginManager::RegisterPlugin(PlatformLinux::GetPluginNameStatic(false),
                                       PlatformLinux::GetPluginDescriptionStatic(false),
                                       PlatformLinux::CreateInstance,
                                       PlatformLinux::DebuggerInitialize);
     }
 }
 
 void
 PlatformLinux::Terminate ()
 {
     if (g_initialize_count > 0)
     {
         if (--g_initialize_count == 0)
         {
             PluginManager::UnregisterPlugin (PlatformLinux::CreateInstance);
         }
     }
+
+    PlatformPOSIX::Terminate ();
 }
 
 Error
 PlatformLinux::ResolveExecutable (const ModuleSpec &ms,
                                   lldb::ModuleSP &exe_module_sp,
                                   const FileSpecList *module_search_paths_ptr)
 {
     Error error;

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

 static uint32_t g_initialize_count = 0;
 
 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------
 void
 PlatformDarwinKernel::Initialize ()
 {
+    PlatformDarwin::Initialize ();
+
     if (g_initialize_count++ == 0)
     {
         PluginManager::RegisterPlugin (PlatformDarwinKernel::GetPluginNameStatic(),
                                        PlatformDarwinKernel::GetDescriptionStatic(),
                                        PlatformDarwinKernel::CreateInstance,
                                        PlatformDarwinKernel::DebuggerInitialize);
     }
 }
 
 void
 PlatformDarwinKernel::Terminate ()
 {
     if (g_initialize_count > 0)
     {
         if (--g_initialize_count == 0)
         {
             PluginManager::UnregisterPlugin (PlatformDarwinKernel::CreateInstance);
         }
     }
+
+    PlatformDarwin::Terminate ();
 }
 
 PlatformSP
 PlatformDarwinKernel::CreateInstance (bool force, const ArchSpec *arch)
 {
     // This is a special plugin that we don't want to activate just based on an ArchSpec for normal
     // userlnad debugging.  It is only useful in kernel debug sessions and the DynamicLoaderDarwinPlugin
     // (or a user doing 'platform select') will force the creation of this Platform plugin.

source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

 using namespace lldb;
 using namespace lldb_private;
     
 static uint32_t g_initialize_count = 0;
 
 void
 PlatformMacOSX::Initialize ()
 {
+    PlatformDarwin::Initialize ();
+
     if (g_initialize_count++ == 0)
     {
 #if defined (__APPLE__)
         PlatformSP default_platform_sp (new PlatformMacOSX(true));
         default_platform_sp->SetSystemArchitecture(HostInfo::GetArchitecture());
         Platform::SetHostPlatform (default_platform_sp);
 #endif        
         PluginManager::RegisterPlugin (PlatformMacOSX::GetPluginNameStatic(false),
                                        PlatformMacOSX::GetDescriptionStatic(false),
                                        PlatformMacOSX::CreateInstance);
     }
 
 }
 
 void
 PlatformMacOSX::Terminate ()
 {
     if (g_initialize_count > 0)
     {
         if (--g_initialize_count == 0)
         {
             PluginManager::UnregisterPlugin (PlatformMacOSX::CreateInstance);
         }
     }
+
+    PlatformDarwin::Terminate ();
 }
 
 PlatformSP
 PlatformMacOSX::CreateInstance (bool force, const ArchSpec *arch)
 {
     // The only time we create an instance is when we are creating a remote
     // macosx platform
     const bool is_host = false;

source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

 static uint32_t g_initialize_count = 0;
 
 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------
 void
 PlatformRemoteiOS::Initialize ()
 {
+    PlatformDarwin::Initialize ();
+
     if (g_initialize_count++ == 0)
     {
         PluginManager::RegisterPlugin (PlatformRemoteiOS::GetPluginNameStatic(),
                                        PlatformRemoteiOS::GetDescriptionStatic(),
                                        PlatformRemoteiOS::CreateInstance);
     }
 }
 
 void
 PlatformRemoteiOS::Terminate ()
 {
     if (g_initialize_count > 0)
     {
         if (--g_initialize_count == 0)
         {
             PluginManager::UnregisterPlugin (PlatformRemoteiOS::CreateInstance);
         }
     }
+
+    PlatformDarwin::Terminate ();
 }
 
 PlatformSP
 PlatformRemoteiOS::CreateInstance (bool force, const ArchSpec *arch)
 {
     bool create = force;
     if (create == false && arch && arch->IsValid())
     {

source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

 static uint32_t g_initialize_count = 0;
 
 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------
 void
 PlatformiOSSimulator::Initialize ()
 {
+    PlatformDarwin::Initialize ();
+
     if (g_initialize_count++ == 0)
     {
         PluginManager::RegisterPlugin (PlatformiOSSimulator::GetPluginNameStatic(),
                                        PlatformiOSSimulator::GetDescriptionStatic(),
                                        PlatformiOSSimulator::CreateInstance);
     }
 }
 
 void
 PlatformiOSSimulator::Terminate ()
 {
     if (g_initialize_count > 0)
     {
         if (--g_initialize_count == 0)
         {
             PluginManager::UnregisterPlugin (PlatformiOSSimulator::CreateInstance);
         }
     }
+
+    PlatformDarwin::Terminate ();
 }
 
 PlatformSP
 PlatformiOSSimulator::CreateInstance (bool force, const ArchSpec *arch)
 {
     bool create = force;
     if (create == false && arch && arch->IsValid())
     {

source/Plugins/Platform/Windows/PlatformWindows.cpp

 PlatformWindows::GetPluginName(void)
 {
     return GetPluginNameStatic(IsHost());
 }
 
 void
 PlatformWindows::Initialize(void)
 {
+    Platform::Initialize ();
+
     if (g_initialize_count++ == 0)
     {
 #if defined (_WIN32)
         WSADATA dummy;
         WSAStartup(MAKEWORD(2,2), &dummy);
         // Force a host flag to true for the default platform object.
         PlatformSP default_platform_sp (new PlatformWindows(true));
         default_platform_sp->SetSystemArchitecture(HostInfo::GetArchitecture());
if (g_initialize_count > 0)
         if (--g_initialize_count == 0)
         {
 #ifdef _WIN32
             WSACleanup();
 #endif
             PluginManager::UnregisterPlugin (PlatformWindows::CreateInstance);
         }
     }
+
+    Platform::Terminate ();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformWindows::PlatformWindows (bool is_host) :
     Platform(is_host)
 {

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 static bool g_initialized = false;
 
 void
 PlatformRemoteGDBServer::Initialize ()
 {
+    Platform::Initialize ();
+
     if (g_initialized == false)
     {
         g_initialized = true;
         PluginManager::RegisterPlugin (PlatformRemoteGDBServer::GetPluginNameStatic(),
                                        PlatformRemoteGDBServer::GetDescriptionStatic(),
                                        PlatformRemoteGDBServer::CreateInstance);
     }
 }
 
 void
 PlatformRemoteGDBServer::Terminate ()
 {
     if (g_initialized)
     {
         g_initialized = false;
         PluginManager::UnregisterPlugin (PlatformRemoteGDBServer::CreateInstance);
     }
+
+    Platform::Terminate ();
 }
 
 PlatformSP
 PlatformRemoteGDBServer::CreateInstance (bool force, const lldb_private::ArchSpec *arch)
 {
     bool create = force;
     if (!create)
     {

source/Target/Platform.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Utils.h"
 
 using namespace lldb;
 using namespace lldb_private;
-    
+static uint32_t g_initialize_count = 0;
+
 // Use a singleton function for g_local_platform_sp to avoid init
 // constructors since LLDB is often part of a shared library
 static PlatformSP&
 GetHostPlatformSP ()
 {
     static PlatformSP g_platform_sp;
     return g_platform_sp;
 }

 static Mutex &
 GetPlatformListMutex ()
 {
     static Mutex g_mutex(Mutex::eMutexTypeRecursive);
     return g_mutex;
 }
 
 void
+Platform::Initialize ()
+{
+    g_initialize_count++;
+}
+
+void
+Platform::Terminate ()
+{
+    if (g_initialize_count > 0)
+    {
+        if (--g_initialize_count == 0)
+        {
+            Mutex::Locker locker(GetPlatformListMutex ());
+            GetPlatformList().clear();
+        }
+    }
+}
+
+void
 Platform::SetHostPlatform (const lldb::PlatformSP &platform_sp)
 {
     // The native platform should use its static void Platform::Initialize()
     // function to register itself as the native platform.
     GetHostPlatformSP () = platform_sp;
 
     if (platform_sp)
     {

source/lldb.cpp

 #if defined (__linux__)
     ProcessLinux::Terminate();
 #endif
 
 #if defined (__FreeBSD__)
     ProcessFreeBSD::Terminate();
 #endif
 
+    PlatformRemoteGDBServer::Terminate();
     ProcessGDBRemote::Terminate();
     DynamicLoaderStatic::Terminate();
 
     Log::Terminate();
 }
 
 #if defined (__APPLE__)
 extern "C" const unsigned char liblldb_coreVersionString[];