Enable process launching on android from lldb-gdbserver

[tberghammer]

Summary

Enable process launching on android from lldb-gdbserver

Currently it is uses the same code used on linux. Will be replaced with android specific code if needed.

[ovyalov]

Look good.

source/Plugins/Platform/Android/PlatformAndroid.cpp

33

Do we still need conditional compilation here?

[tberghammer]

source/Plugins/Platform/Android/PlatformAndroid.cpp

33

Yes we do because each Platform*::Initialize() will be called on startup but only one of them have to register itself as a host platform.

source/Plugins/Platform/Android/PlatformAndroid.h

namespace lldb_private {
     class PlatformAndroid : public PlatformLinux
     {
     public:
         static void
         Initialize ();
 
         static void
         Terminate ();
-        
-        PlatformAndroid ();
+        PlatformAndroid (bool is_host);
 
         virtual
         ~PlatformAndroid();
 
         //------------------------------------------------------------
         // lldb_private::PluginInterface functions
         //------------------------------------------------------------
         static lldb::PlatformSP
         CreateInstance (bool force, const lldb_private::ArchSpec *arch);
 
         static lldb_private::ConstString
-        GetPluginNameStatic ();
+        GetPluginNameStatic (bool is_host);
 
         static const char *
-        GetPluginDescriptionStatic ();
+        GetPluginDescriptionStatic (bool is_host);
 
         lldb_private::ConstString
         GetPluginName() override;
         
         uint32_t
         GetPluginVersion() override
         {
             return 1;

source/Plugins/Platform/Android/PlatformAndroid.cpp

 //===-- PlatformAndroid.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 #include "lldb/Core/Log.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/HostInfo.h"
 
 // Project includes
 #include "PlatformAndroid.h"
 #include "PlatformAndroidRemoteGDBServer.h"
 
 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(),
+#if defined(__ANDROID__)
+        PlatformSP default_platform_sp (new PlatformAndroid(true));
+        default_platform_sp->SetSystemArchitecture(HostInfo::GetArchitecture());
+        Platform::SetHostPlatform (default_platform_sp);
+#endif
+        PluginManager::RegisterPlugin (PlatformAndroid::GetPluginNameStatic(false),
+                                       PlatformAndroid::GetPluginDescriptionStatic(false),
                                        PlatformAndroid::CreateInstance);
     }
 }
 
 void
 PlatformAndroid::Terminate ()
 {
     if (g_initialize_count > 0)
#endif
             default:
                 break;
         }
         
         if (create)
         {
             switch (triple.getOS())
             {
-                case llvm::Triple::Linux:
+                case llvm::Triple::Android:
                     break;
-                    
 #if defined(__ANDROID__)
                 // Only accept "unknown" for the OS if the host is android and
                 // it "unknown" wasn't specified (it was just returned because it
                 // was NOT specified)
                 case llvm::Triple::OSType::UnknownOS:
                     create = !arch->TripleOSWasSpecified();
                     break;
 #endif
                 default:
                     create = false;
                     break;
             }
         }
     }
 
     if (create)
     {
         if (log)
             log->Printf ("PlatformAndroid::%s() creating remote-android platform", __FUNCTION__);
-        return PlatformSP(new PlatformAndroid());
+        return PlatformSP(new PlatformAndroid(false));
     }
 
     if (log)
         log->Printf ("PlatformAndroid::%s() aborting creation of remote-android platform", __FUNCTION__);
 
     return PlatformSP();
 }
 
-PlatformAndroid::PlatformAndroid () :
-    PlatformLinux(false)  // Platform android is always a remote target
+PlatformAndroid::PlatformAndroid (bool is_host) :
+    PlatformLinux(is_host)
 {
 }
 
 PlatformAndroid::~PlatformAndroid()
 {
 }
 
 lldb_private::ConstString
-PlatformAndroid::GetPluginNameStatic ()
+PlatformAndroid::GetPluginNameStatic (bool is_host)
+{
+    if (is_host)
+    {
+        static ConstString g_host_name(Platform::GetHostPlatformName ());
+        return g_host_name;
+    }
+    else
     {
         static ConstString g_remote_name("remote-android");
         return g_remote_name;
     }
+}
 
 const char *
-PlatformAndroid::GetPluginDescriptionStatic ()
+PlatformAndroid::GetPluginDescriptionStatic (bool is_host)
 {
+    if (is_host)
+        return "Local Android user platform plug-in.";
+    else
         return "Remote Android user platform plug-in.";
 }
 
 lldb_private::ConstString
 PlatformAndroid::GetPluginName()
 {
-    return GetPluginNameStatic();
+    return GetPluginNameStatic(IsHost());
 }
 
 Error
 PlatformAndroid::ConnectRemote (Args& args)
 {
+    if (IsHost())
+    {
+        return Error ("can't connect to the host platform '%s', always connected", GetPluginName().GetCString());
+    }
+
     if (!m_remote_platform_sp)
         m_remote_platform_sp = PlatformSP(new PlatformAndroidRemoteGDBServer());
     return PlatformLinux::ConnectRemote (args);
 }

source/Plugins/Platform/Linux/PlatformLinux.cpp

 
 void
 PlatformLinux::Initialize ()
 {
     PlatformPOSIX::Initialize ();
 
     if (g_initialize_count++ == 0)
     {
-#if defined(__linux__)
+#if defined(__linux__) && !defined(__ANDROID__)
         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);

 }
 
 Error
 PlatformLinux::LaunchNativeProcess (
     ProcessLaunchInfo &launch_info,
     lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
     NativeProcessProtocolSP &process_sp)
 {
-#if !defined(__linux__) || defined(__ANDROID_NDK__)
-    return Error("only implemented on Linux hosts");
-#else
     if (!IsHost ())
         return Error("PlatformLinux::%s (): cannot launch a debug process when not the host", __FUNCTION__);
 
     // Retrieve the exe module.
     lldb::ModuleSP exe_module_sp;
     ModuleSpec exe_module_spec(launch_info.GetExecutableFile(), launch_info.GetArchitecture());
 
     Error error = ResolveExecutable (
PlatformLinux::LaunchNativeProcess (
     // Launch it for debugging
     error = NativeProcessLinux::LaunchProcess (
         exe_module_sp.get (),
         launch_info,
         native_delegate,
         process_sp);
 
     return error;
-#endif
 }
 
 Error
 PlatformLinux::AttachNativeProcess (lldb::pid_t pid,
                                     lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
                                     NativeProcessProtocolSP &process_sp)
 {
-#if !defined(__linux__) || defined(__ANDROID_NDK__)
-    return Error("only implemented on Linux hosts");
-#else
     if (!IsHost ())
         return Error("PlatformLinux::%s (): cannot attach to a debug process when not the host", __FUNCTION__);
 
     // Launch it for debugging
     return NativeProcessLinux::AttachToProcess (pid, native_delegate, process_sp);
-#endif
 }

source/Plugins/Process/Linux/NativeThreadLinux.cpp

#if 0
         case llvm::Triple::mips64:
         {
             RegisterContextPOSIXProcessMonitor_mips64 *reg_ctx = new RegisterContextPOSIXProcessMonitor_mips64(*this, 0, reg_interface);
             m_posix_thread = reg_ctx;
             m_reg_context_sp.reset(reg_ctx);
             break;
         }
 #endif
-#if 0
+
         case llvm::Triple::x86:
-#endif
         case llvm::Triple::x86_64:
         {
             const uint32_t concrete_frame_idx = 0;
             m_reg_context_sp.reset (new NativeRegisterContextLinux_x86_64(*this, concrete_frame_idx, reg_interface));
             break;
         }
         default:
             break;