Merge lldb-platform and lldb-gdbserver into a single binary

This commit merges lldb-platform and lldb-gdbserver into a single binary
of the same size as each of the previous individual binaries. Execution
mode is controlled by the first argument being either platform or
gdbserver.

Patch from: flackr <flackr@google.com>

Differential revision: http://reviews.llvm.org/D7545

llvm-svn: 229683

1 files changed, 314 insertions, 0 deletions

diff --git a/lldb/tools/lldb-server/lldb-platform.cpp b/lldb/tools/lldb-server/lldb-platform.cpp
new file mode 100644
index 00000000000..bdfe2d0ac41
--- /dev/null
+++ b/lldb/tools/lldb-server/lldb-platform.cpp
@@ -0,0 +1,314 @@
+//===-- lldb-platform.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-python.h"
+
+// C Includes
+#include <errno.h>
+#if defined(__APPLE__)
+#include <netinet/in.h>
+#endif
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// C++ Includes
+
+// Other libraries and framework includes
+#include "lldb/lldb-private-log.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/ConnectionMachPort.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/StreamFile.h"
+#include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/HostGetOpt.h"
+#include "lldb/Host/OptionParser.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
+#include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+//----------------------------------------------------------------------
+// option descriptors for getopt_long_only()
+//----------------------------------------------------------------------
+
+static int g_debug = 0;
+static int g_verbose = 0;
+static int g_stay_alive = 0;
+
+static struct option g_long_options[] =
+{
+    { "debug",              no_argument,        &g_debug,           1   },
+    { "verbose",            no_argument,        &g_verbose,         1   },
+    { "stay-alive",         no_argument,        &g_stay_alive,      1   },
+    { "listen",             required_argument,  NULL,               'L' },
+    { "port-offset",        required_argument,  NULL,               'p' },
+    { "gdbserver-port",     required_argument,  NULL,               'P' },
+    { "min-gdbserver-port", required_argument,  NULL,               'm' },
+    { "max-gdbserver-port", required_argument,  NULL,               'M' },
+    { "lldb-command",       required_argument,  NULL,               'c' },
+    { NULL,                 0,                  NULL,               0   }
+};
+
+#if defined (__APPLE__)
+#define LOW_PORT    (IPPORT_RESERVED)
+#define HIGH_PORT   (IPPORT_HIFIRSTAUTO)
+#else
+#define LOW_PORT    (1024u)
+#define HIGH_PORT   (49151u)
+#endif
+
+
+//----------------------------------------------------------------------
+// Watch for signals
+//----------------------------------------------------------------------
+static void
+signal_handler(int signo)
+{
+    switch (signo)
+    {
+    case SIGHUP:
+        // Use SIGINT first, if that does not work, use SIGHUP as a last resort.
+        // And we should not call exit() here because it results in the global destructors
+        // to be invoked and wreaking havoc on the threads still running.
+        Host::SystemLog(Host::eSystemLogWarning, "SIGHUP received, exiting lldb-platform...\n");
+        abort();
+        break;
+    }
+}
+
+static void
+display_usage (const char *progname, const char *subcommand)
+{
+    fprintf(stderr, "Usage:\n  %s %s [--log-file log-file-path] [--log-flags flags] --listen port\n", progname, subcommand);
+    exit(0);
+}
+
+//----------------------------------------------------------------------
+// main
+//----------------------------------------------------------------------
+int
+main_platform (int argc, char *argv[])
+{
+    const char *progname = argv[0];
+    const char *subcommand = argv[1];
+    argc--;
+    argv++;
+    signal (SIGPIPE, SIG_IGN);
+    signal (SIGHUP, signal_handler);
+    int long_option_index = 0;
+    Error error;
+    std::string listen_host_port;
+    int ch;
+    Debugger::Initialize(NULL);
+
+    lldb::DebuggerSP debugger_sp = Debugger::CreateInstance ();
+
+    debugger_sp->SetInputFileHandle(stdin, false);
+    debugger_sp->SetOutputFileHandle(stdout, false);
+    debugger_sp->SetErrorFileHandle(stderr, false);
+    
+    GDBRemoteCommunicationServerPlatform::PortMap gdbserver_portmap;
+    int min_gdbserver_port = 0;
+    int max_gdbserver_port = 0;
+    uint16_t port_offset = 0;
+    
+    std::vector<std::string> lldb_commands;
+    bool show_usage = false;
+    int option_error = 0;
+    
+    std::string short_options(OptionParser::GetShortOptionString(g_long_options));
+                            
+#if __GLIBC__
+    optind = 0;
+#else
+    optreset = 1;
+    optind = 1;
+#endif
+
+    while ((ch = getopt_long_only(argc, argv, short_options.c_str(), g_long_options, &long_option_index)) != -1)
+    {
+        switch (ch)
+        {
+        case 0:   // Any optional that auto set themselves will return 0
+            break;
+
+        case 'L':
+            listen_host_port.append (optarg);
+            break;
+
+        case 'p':
+            {
+                char *end = NULL;
+                long tmp_port_offset = strtoul(optarg, &end, 0);
+                if (end && *end == '\0')
+                {
+                    if (LOW_PORT <= tmp_port_offset && tmp_port_offset <= HIGH_PORT)
+                    {
+                        port_offset = (uint16_t)tmp_port_offset;
+                    }
+                    else
+                    {
+                        fprintf (stderr, "error: port offset %li is not in the valid user port range of %u - %u\n", tmp_port_offset, LOW_PORT, HIGH_PORT);
+                        option_error = 5;
+                    }
+                }
+                else
+                {
+                    fprintf (stderr, "error: invalid port offset string %s\n", optarg);
+                    option_error = 4;
+                }
+            }
+            break;
+                
+        case 'P':
+        case 'm':
+        case 'M':
+            {
+                char *end = NULL;
+                long portnum = strtoul(optarg, &end, 0);
+                if (end && *end == '\0')
+                {
+                    if (LOW_PORT <= portnum && portnum <= HIGH_PORT)
+                    {
+                        if (ch  == 'P')
+                            gdbserver_portmap[(uint16_t)portnum] = LLDB_INVALID_PROCESS_ID;
+                        else if (ch == 'm')
+                            min_gdbserver_port = portnum;
+                        else
+                            max_gdbserver_port = portnum;
+                    }
+                    else
+                    {
+                        fprintf (stderr, "error: port number %li is not in the valid user port range of %u - %u\n", portnum, LOW_PORT, HIGH_PORT);
+                        option_error = 1;
+                    }
+                }
+                else
+                {
+                    fprintf (stderr, "error: invalid port number string %s\n", optarg);
+                    option_error = 2;
+                }
+            }
+            break;
+            
+        case 'c':
+            lldb_commands.push_back(optarg);
+            break;
+
+        case 'h':   /* fall-through is intentional */
+        case '?':
+            show_usage = true;
+            break;
+        }
+    }
+
+    // Make a port map for a port range that was specified.
+    if (min_gdbserver_port < max_gdbserver_port)
+    {
+        for (uint16_t port = min_gdbserver_port; port < max_gdbserver_port; ++port)
+            gdbserver_portmap[port] = LLDB_INVALID_PROCESS_ID;
+    }
+    else if (min_gdbserver_port != max_gdbserver_port)
+    {
+        fprintf (stderr, "error: --min-gdbserver-port (%u) is greater than --max-gdbserver-port (%u)\n", min_gdbserver_port, max_gdbserver_port);
+        option_error = 3;
+        
+    }
+
+    // Print usage and exit if no listening port is specified.
+    if (listen_host_port.empty())
+        show_usage = true;
+    
+    if (show_usage || option_error)
+    {
+        display_usage(progname, subcommand);
+        exit(option_error);
+    }
+    
+    // Execute any LLDB commands that we were asked to evaluate.
+    for (const auto &lldb_command : lldb_commands)
+    {
+        lldb_private::CommandReturnObject result;
+        printf("(lldb) %s\n", lldb_command.c_str());
+        debugger_sp->GetCommandInterpreter().HandleCommand(lldb_command.c_str(), eLazyBoolNo, result);
+        const char *output = result.GetOutputData();
+        if (output && output[0])
+            puts(output);
+    }
+
+
+    do {
+        GDBRemoteCommunicationServerPlatform platform;
+        
+        if (port_offset > 0)
+            platform.SetPortOffset(port_offset);
+
+        if (!gdbserver_portmap.empty())
+        {
+            platform.SetPortMap(std::move(gdbserver_portmap));
+        }
+
+        if (!listen_host_port.empty())
+        {
+            std::unique_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor());
+            if (conn_ap.get())
+            {
+                std::string connect_url ("listen://");
+                connect_url.append(listen_host_port.c_str());
+
+                printf ("Listening for a connection from %s...\n", listen_host_port.c_str());
+                if (conn_ap->Connect(connect_url.c_str(), &error) == eConnectionStatusSuccess)
+                {
+                    printf ("Connection established.\n");
+                    platform.SetConnection (conn_ap.release());
+                }
+                else
+                {
+                    printf ("error: %s\n", error.AsCString());
+                }
+            }
+
+            if (platform.IsConnected())
+            {
+                // After we connected, we need to get an initial ack from...
+                if (platform.HandshakeWithClient(&error))
+                {
+                    bool interrupt = false;
+                    bool done = false;
+                    while (!interrupt && !done)
+                    {
+                        if (platform.GetPacketAndSendResponse (UINT32_MAX, error, interrupt, done) != GDBRemoteCommunication::PacketResult::Success)
+                            break;
+                    }
+                    
+                    if (error.Fail())
+                    {
+                        fprintf(stderr, "error: %s\n", error.AsCString());
+                    }
+                }
+                else
+                {
+                    fprintf(stderr, "error: handshake with client failed\n");
+                }
+            }
+        }
+    } while (g_stay_alive);
+
+    Debugger::Terminate();
+
+    fprintf(stderr, "lldb-platform exiting...\n");
+
+    return 0;
+}