Remove platform plugins from lldb-server

[labath]

Summary

This removes the last usage of Platform plugins in lldb-server -- it was used for launching child
processes, where it can be trivially replaced by Host::LaunchProces (as lldb-server is always
running on the host).

Removing platform plugins enables us to remove a lot of other unused code, which was pulled in as
a transitive dependency, and it reduces lldb-server size by 4%--9% (depending on build type and
architecture).

source/API/SystemInitializerFull.cpp

 #include "Plugins/ABI/SysV-i386/ABISysV_i386.h"
 #include "Plugins/ABI/SysV-mips/ABISysV_mips.h"
 #include "Plugins/ABI/SysV-mips64/ABISysV_mips64.h"
 #include "Plugins/ABI/SysV-ppc/ABISysV_ppc.h"
 #include "Plugins/ABI/SysV-ppc64/ABISysV_ppc64.h"
 #include "Plugins/ABI/SysV-s390x/ABISysV_s390x.h"
 #include "Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h"
 #include "Plugins/Disassembler/llvm/DisassemblerLLVMC.h"
-#include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
 #include "Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h"
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
+#include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
 #include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
 #include "Plugins/Instruction/ARM64/EmulateInstructionARM64.h"
 #include "Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.h"
 #include "Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.h"
 #include "Plugins/JITLoader/GDB/JITLoaderGDB.h"
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/Go/GoLanguage.h"
 #include "Plugins/Language/Java/JavaLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"
 #include "Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h"
 #include "Plugins/LanguageRuntime/Go/GoLanguageRuntime.h"
 #include "Plugins/LanguageRuntime/Java/JavaLanguageRuntime.h"
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h"
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h"
 #include "Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h"
 #include "Plugins/MemoryHistory/asan/MemoryHistoryASan.h"
-#include "Plugins/OperatingSystem/Python/OperatingSystemPython.h"
 #include "Plugins/OperatingSystem/Go/OperatingSystemGo.h"
+#include "Plugins/OperatingSystem/Python/OperatingSystemPython.h"
+#include "Plugins/Platform/Android/PlatformAndroid.h"
+#include "Plugins/Platform/FreeBSD/PlatformFreeBSD.h"
+#include "Plugins/Platform/Kalimba/PlatformKalimba.h"
+#include "Plugins/Platform/Linux/PlatformLinux.h"
+#include "Plugins/Platform/MacOSX/PlatformMacOSX.h"
+#include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
+#include "Plugins/Platform/NetBSD/PlatformNetBSD.h"
+#include "Plugins/Platform/Windows/PlatformWindows.h"
 #include "Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h"
 #include "Plugins/Process/elf-core/ProcessElfCore.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
 #include "Plugins/ScriptInterpreter/None/ScriptInterpreterNone.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h"
 #include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
 #include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
 #include "Plugins/SymbolVendor/ELF/SymbolVendorELF.h"
 #include "Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h"
 #include "Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h"
 #include "Plugins/UnwindAssembly/x86/UnwindAssembly-x86.h"
 
 #if defined(__APPLE__)
-#include "Plugins/Process/mach-core/ProcessMachCore.h"
-#include "Plugins/Process/MacOSX-Kernel/ProcessKDP.h"
-#include "Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.h"
+#include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h"
 #include "Plugins/Platform/MacOSX/PlatformAppleTVSimulator.h"
 #include "Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.h"
+#include "Plugins/Platform/MacOSX/PlatformDarwinKernel.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteAppleTV.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.h"
-#include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h"
+#include "Plugins/Platform/MacOSX/PlatformiOSSimulator.h"
+#include "Plugins/Process/MacOSX-Kernel/ProcessKDP.h"
+#include "Plugins/Process/mach-core/ProcessMachCore.h"
+#include "Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.h"
 #endif
 
 #if defined(__FreeBSD__)
 #include "Plugins/Process/FreeBSD/ProcessFreeBSD.h"
 #endif
 
 #if defined(_MSC_VER)
 #include "lldb/Host/windows/windows.h"
#if !defined(LLDB_DISABLE_PYTHON)
     InitializeSWIG();
 
     // ScriptInterpreterPython::Initialize() depends on things like HostInfo being initialized
     // so it can compute the python directory etc, so we need to do this after
     // SystemInitializerCommon::Initialize().
     ScriptInterpreterPython::Initialize();
 #endif
 
+    platform_freebsd::PlatformFreeBSD::Initialize();
+    platform_linux::PlatformLinux::Initialize();
+    platform_netbsd::PlatformNetBSD::Initialize();
+    PlatformWindows::Initialize();
+    PlatformKalimba::Initialize();
+    platform_android::PlatformAndroid::Initialize();
+    PlatformRemoteiOS::Initialize();
+    PlatformMacOSX::Initialize();
+#if defined(__APPLE__)
+    PlatformiOSSimulator::Initialize();
+    PlatformDarwinKernel::Initialize();
+#endif
+
     // Initialize LLVM and Clang
     llvm::InitializeAllTargets();
     llvm::InitializeAllAsmPrinters();
     llvm::InitializeAllTargetMCs();
     llvm::InitializeAllDisassemblers();
 
     ClangASTContext::Initialize();
     GoASTContext::Initialize();
#endif
     DynamicLoaderStatic::Terminate();
     DynamicLoaderWindowsDYLD::Terminate();
 
 #ifndef LLDB_DISABLE_PYTHON
     OperatingSystemPython::Terminate();
 #endif
     OperatingSystemGo::Terminate();
 
+    platform_freebsd::PlatformFreeBSD::Terminate();
+    platform_linux::PlatformLinux::Terminate();
+    platform_netbsd::PlatformNetBSD::Terminate();
+    PlatformWindows::Terminate();
+    PlatformKalimba::Terminate();
+    platform_android::PlatformAndroid::Terminate();
+    PlatformMacOSX::Terminate();
+    PlatformRemoteiOS::Terminate();
+#if defined(__APPLE__)
+    PlatformiOSSimulator::Terminate();
+    PlatformDarwinKernel::Terminate();
+#endif
+
     // Now shutdown the common parts, in reverse order.
     SystemInitializerCommon::Terminate();
 }

source/Initialization/SystemInitializerCommon.cpp

 #include "lldb/Core/Timer.h"
 #include "Plugins/Instruction/ARM/EmulateInstructionARM.h"
 #include "Plugins/Instruction/MIPS/EmulateInstructionMIPS.h"
 #include "Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.h"
 #include "Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h"
 #include "Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h"
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
-#include "Plugins/Platform/Android/PlatformAndroid.h"
-#include "Plugins/Platform/FreeBSD/PlatformFreeBSD.h"
-#include "Plugins/Platform/Kalimba/PlatformKalimba.h"
-#include "Plugins/Platform/Linux/PlatformLinux.h"
-#include "Plugins/Platform/MacOSX/PlatformMacOSX.h"
-#include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
-#include "Plugins/Platform/NetBSD/PlatformNetBSD.h"
-#include "Plugins/Platform/Windows/PlatformWindows.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 
 #if defined(__APPLE__)
-#include "Plugins/Platform/MacOSX/PlatformiOSSimulator.h"
 #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
-#include "Plugins/Platform/MacOSX/PlatformDarwinKernel.h"
 #endif
 
 #if defined(__linux__)
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #endif
 
 #if defined(_MSC_VER)
 #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
#endif
     llvm::install_fatal_error_handler(fatal_error_handler, 0);
 
     process_gdb_remote::ProcessGDBRemoteLog::Initialize();
 
     // Initialize plug-ins
     ObjectContainerBSDArchive::Initialize();
     ObjectFileELF::Initialize();
     ObjectFilePECOFF::Initialize();
-    platform_freebsd::PlatformFreeBSD::Initialize();
-    platform_linux::PlatformLinux::Initialize();
-    platform_netbsd::PlatformNetBSD::Initialize();
-    PlatformWindows::Initialize();
-    PlatformKalimba::Initialize();
-    platform_android::PlatformAndroid::Initialize();
 
     EmulateInstructionARM::Initialize();
     EmulateInstructionMIPS::Initialize();
     EmulateInstructionMIPS64::Initialize();
 
     //----------------------------------------------------------------------
     // Apple/Darwin hosted plugins
     //----------------------------------------------------------------------
     ObjectContainerUniversalMachO::Initialize();
 
-    PlatformRemoteiOS::Initialize();
-    PlatformMacOSX::Initialize();
 
 #if defined(__APPLE__)
-    PlatformiOSSimulator::Initialize();
-    PlatformDarwinKernel::Initialize();
     ObjectFileMachO::Initialize();
 #endif
 #if defined(__linux__)
     static ConstString g_linux_log_name("linux");
     ProcessPOSIXLog::Initialize(g_linux_log_name);
 #endif
 #if defined(_MSC_VER)
     ProcessWindowsLog::Initialize();
 #endif
 }
 
 void
 SystemInitializerCommon::Terminate()
 {
     Timer scoped_timer(__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
     ObjectContainerBSDArchive::Terminate();
     ObjectFileELF::Terminate();
     ObjectFilePECOFF::Terminate();
-    platform_freebsd::PlatformFreeBSD::Terminate();
-    platform_linux::PlatformLinux::Terminate();
-    platform_netbsd::PlatformNetBSD::Terminate();
-    PlatformWindows::Terminate();
-    PlatformKalimba::Terminate();
-    platform_android::PlatformAndroid::Terminate();
-    ObjectContainerUniversalMachO::Terminate();
-    PlatformMacOSX::Terminate();
-    PlatformRemoteiOS::Terminate();
 
     EmulateInstructionARM::Terminate();
     EmulateInstructionMIPS::Terminate();
     EmulateInstructionMIPS64::Terminate();
 
+    ObjectContainerUniversalMachO::Terminate();
 #if defined(__APPLE__)
-    PlatformiOSSimulator::Terminate();
     ObjectFileMachO::Terminate();
-    PlatformDarwinKernel::Terminate();
 #endif
 
 #if defined(_MSC_VER)
     ProcessWindowsLog::Terminate();
 #endif
 
     HostInfo::Terminate();
     Log::Terminate();
 }

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

 class GDBRemoteCommunicationServerLLGS :
     public GDBRemoteCommunicationServerCommon,
     public NativeProcessProtocol::NativeDelegate
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
-    GDBRemoteCommunicationServerLLGS(const lldb::PlatformSP& platform_sp, MainLoop &mainloop);
+    GDBRemoteCommunicationServerLLGS(MainLoop &mainloop);
 
     //------------------------------------------------------------------
     /// Specify the program to launch and its arguments.
     ///
     /// @param[in] args
     ///     The command line to launch.
     ///
     /// @param[in] argc
public:
 
     void
     DidExec (NativeProcessProtocol *process) override;
 
     Error
     InitializeConnection (std::unique_ptr<Connection> &&connection);
 
 protected:
-    lldb::PlatformSP m_platform_sp;
     MainLoop &m_mainloop;
     MainLoop::ReadHandleUP m_network_handle_up;
     lldb::tid_t m_current_tid;
     lldb::tid_t m_continue_tid;
     std::recursive_mutex m_debugged_process_mutex;
     NativeProcessProtocolSP m_debugged_process_sp;
 
     Communication m_stdio_communication;

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/MemoryRegionInfo.h"
-#include "lldb/Target/Platform.h"
 #include "lldb/Host/common/NativeRegisterContext.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/Utility/JSON.h"
 #include "lldb/Utility/LLDBAssert.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
enum GDBRemoteServerError
         eErrorResume,
         eErrorExitStatus
     };
 }
 
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerLLGS constructor
 //----------------------------------------------------------------------
-GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(const lldb::PlatformSP &platform_sp,
-                                                                   MainLoop &mainloop)
+GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(MainLoop &mainloop)
     : GDBRemoteCommunicationServerCommon("gdb-remote.server", "gdb-remote.server.rx_packet"),
-      m_platform_sp(platform_sp),
       m_mainloop(mainloop),
       m_current_tid(LLDB_INVALID_THREAD_ID),
       m_continue_tid(LLDB_INVALID_THREAD_ID),
       m_debugged_process_mutex(),
       m_debugged_process_sp(),
       m_stdio_communication("process.stdio"),
       m_inferior_prev_state(StateType::eStateInvalid),
       m_active_auxv_buffer_sp(),
       m_saved_registers_mutex(),
       m_saved_registers_map(),
       m_next_saved_registers_id(1),
       m_handshake_completed(false)
 {
-    assert(platform_sp);
     RegisterPacketHandlers();
 }
 
 void
 GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers()
 {
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C,
                                   &GDBRemoteCommunicationServerLLGS::Handle_C);

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h

public:
     void
     SetPendingGdbServer(lldb::pid_t pid, uint16_t port, const std::string& socket_name);
 
 protected:
     const Socket::SocketProtocol m_socket_protocol;
     const std::string m_socket_scheme;
     std::recursive_mutex m_spawned_pids_mutex;
     std::set<lldb::pid_t> m_spawned_pids;
-    lldb::PlatformSP m_platform_sp;
 
     PortMap m_port_map;
     uint16_t m_port_offset;
     struct { lldb::pid_t pid; uint16_t port; std::string socket_name; } m_pending_gdb_server;
 
     PacketResult
     Handle_qLaunchGDBServer (StringExtractorGDBRemote &packet);
 

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

 // GDBRemoteCommunicationServerPlatform constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(const Socket::SocketProtocol socket_protocol,
                                                                            const char *socket_scheme)
     : GDBRemoteCommunicationServerCommon("gdb-remote.server", "gdb-remote.server.rx_packet"),
       m_socket_protocol(socket_protocol),
       m_socket_scheme(socket_scheme),
       m_spawned_pids_mutex(),
-      m_platform_sp(Platform::GetHostPlatform()),
       m_port_map(),
       m_port_offset(0)
 {
     m_pending_gdb_server.pid = LLDB_INVALID_PROCESS_ID;
     m_pending_gdb_server.port = 0;
 
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC,
                                   &GDBRemoteCommunicationServerPlatform::Handle_qC);
GDBRemoteCommunicationServerPlatform::LaunchProcess ()
     // specify the process monitor if not already set.  This should
     // generally be what happens since we need to reap started
     // processes.
     if (!m_process_launch_info.GetMonitorProcessCallback ())
         m_process_launch_info.SetMonitorProcessCallback(
             std::bind(&GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped, this, std::placeholders::_1),
             false);
 
-    Error error = m_platform_sp->LaunchProcess (m_process_launch_info);
+    Error error = Host::LaunchProcess(m_process_launch_info);
     if (!error.Success ())
     {
         fprintf (stderr, "%s: failed to launch executable %s", __FUNCTION__, m_process_launch_info.GetArguments ().GetArgumentAtIndex (0));
         return error;
     }
 
     printf ("Launched '%s' as process %" PRIu64 "...\n", m_process_launch_info.GetArguments ().GetArgumentAtIndex (0), m_process_launch_info.GetProcessID());
 

tools/lldb-server/lldb-gdbserver.cpp

 #include "lldb/Core/Error.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/HostGetOpt.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/StringConvert.h"
-#include "lldb/Target/Platform.h"
 #include "Acceptor.h"
 #include "LLDBServerUtilities.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 
 #ifndef LLGS_PROGRAM_NAME
 #define LLGS_PROGRAM_NAME "lldb-server"
 #endif

 //----------------------------------------------------------------------
 
 static int g_debug = 0;
 static int g_verbose = 0;
 
 static struct option g_long_options[] =
 {
     { "debug",              no_argument,        &g_debug,           1   },
-    { "platform",           required_argument,  NULL,               'p' },
     { "verbose",            no_argument,        &g_verbose,         1   },
     { "log-file",           required_argument,  NULL,               'l' },
     { "log-channels",       required_argument,  NULL,               'c' },
     { "attach",             required_argument,  NULL,               'a' },
     { "named-pipe",         required_argument,  NULL,               'N' },
     { "pipe",               required_argument,  NULL,               'U' },
     { "native-regs",        no_argument,        NULL,               'r' },  // Specify to use the native registers instead of the gdb defaults for the architecture.  NOTE: this is a do-nothing arg as it's behavior is default now.  FIXME remove call from lldb-platform.
     { "reverse-connect",    no_argument,        NULL,               'R' },  // Specifies that llgs attaches to the client address:port rather than llgs listening for a connection from address on port.

 #endif // #ifndef _WIN32
 
 static void
 display_usage (const char *progname, const char* subcommand)
 {
     fprintf(stderr, "Usage:\n  %s %s "
             "[--log-file log-file-name] "
             "[--log-channels log-channel-list] "
-            "[--platform platform_name] "
             "[--setsid] "
             "[--named-pipe named-pipe-path] "
             "[--native-regs] "
             "[--attach pid] "
             "[[HOST]:PORT] "
             "[-- PROGRAM ARG1 ARG2 ...]\n", progname, subcommand);
     exit(0);
 }
 
-static void
-dump_available_platforms (FILE *output_file)
-{
-    fprintf (output_file, "Available platform plugins:\n");
-    for (int i = 0; ; ++i)
-    {
-        const char *plugin_name = PluginManager::GetPlatformPluginNameAtIndex (i);
-        const char *plugin_desc = PluginManager::GetPlatformPluginDescriptionAtIndex (i);
-
-        if (!plugin_name || !plugin_desc)
-            break;
-
-        fprintf (output_file, "%s\t%s\n", plugin_name, plugin_desc);
-    }
-
-    if ( Platform::GetHostPlatform () )
-    {
-        // add this since the default platform doesn't necessarily get registered by
-        // the plugin name (e.g. 'host' doesn't show up as a
-        // registered platform plugin even though it's the default).
-        fprintf (output_file, "%s\tDefault platform for this host.\n", Platform::GetHostPlatform ()->GetPluginName ().AsCString ());
-    }
-}
-
-static lldb::PlatformSP
-setup_platform (const std::string &platform_name)
-{
-    lldb::PlatformSP platform_sp;
-
-    if (platform_name.empty())
-    {
-        printf ("using the default platform: ");
-        platform_sp = Platform::GetHostPlatform ();
-        printf ("%s\n", platform_sp->GetPluginName ().AsCString ());
-        return platform_sp;
-    }
-
-    Error error;
-    platform_sp = Platform::Create (lldb_private::ConstString(platform_name), error);
-    if (error.Fail ())
-    {
-        // the host platform isn't registered with that name (at
-        // least, not always.  Check if the given name matches
-        // the default platform name.  If so, use it.
-        if ( Platform::GetHostPlatform () && ( Platform::GetHostPlatform ()->GetPluginName () == ConstString (platform_name.c_str()) ) )
-        {
-            platform_sp = Platform::GetHostPlatform ();
-        }
-        else
-        {
-            fprintf (stderr, "error: failed to create platform with name '%s'\n", platform_name.c_str());
-            dump_available_platforms (stderr);
-            exit (1);
-        }
-    }
-    printf ("using platform: %s\n", platform_name.c_str ());
-
-    return platform_sp;
-}
-
 void
 handle_attach_to_pid (GDBRemoteCommunicationServerLLGS &gdb_server, lldb::pid_t pid)
 {
     Error error = gdb_server.AttachToProcess (pid);
     if (error.Fail ())
     {
         fprintf (stderr, "error: failed to attach to pid %" PRIu64 ": %s\n", pid, error.AsCString());
         exit(1);

 #endif
 
     const char *progname = argv[0];
     const char *subcommand = argv[1];
     argc--;
     argv++;
     int long_option_index = 0;
     int ch;
-    std::string platform_name;
     std::string attach_target;
     std::string named_pipe_path;
     std::string log_file;
     StringRef log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
     int unnamed_pipe_fd = -1;
     bool reverse_connect = false;
 
     // ProcessLaunchInfo launch_info;
while ((ch = getopt_long_only(argc, argv, short_options.c_str(), g_long_options, &long_option_index)) != -1)
                 log_file.assign(optarg);
             break;
 
         case 'c': // Log Channels
             if (optarg && optarg[0])
                 log_channels = StringRef(optarg);
             break;
 
-        case 'p': // platform name
-            if (optarg && optarg[0])
-                platform_name = optarg;
-            break;
-
         case 'N': // named pipe
             if (optarg && optarg[0])
                 named_pipe_path = optarg;
             break;
 
         case 'U': // unnamed pipe
             if (optarg && optarg[0])
                 unnamed_pipe_fd = StringConvert::ToUInt32(optarg, -1);
#endif
     argv += optind;
 
     if (argc == 0)
     {
         display_usage(progname, subcommand);
         exit(255);
     }
 
-    // Setup the platform that GDBRemoteCommunicationServerLLGS will use.
-    lldb::PlatformSP platform_sp = setup_platform (platform_name);
-
-    GDBRemoteCommunicationServerLLGS gdb_server (platform_sp, mainloop);
+    GDBRemoteCommunicationServerLLGS gdb_server(mainloop);
 
     const char *const host_and_port = argv[0];
     argc -= 1;
     argv += 1;
 
     // Any arguments left over are for the program that we need to launch. If there
     // are no arguments, then the GDB server will start up and wait for an 'A' packet
     // to launch a program, or a vAttach packet to attach to an existing process, unless