Make log options uniform between lldb-platform and lldb-gdbserver

[tberghammer]

Summary

Make log options uniform between lldb-platform and lldb-gdbserver

[clayborg]

Looks good.

include/lldb/Core/Log.h

typedef void (*ListCategoriesCallback)(Stream *strm);
     RegisterLogChannel(const ConstString &channel, const Log::Callbacks &log_callbacks);
 
     static bool
     UnregisterLogChannel(const ConstString &channel);
 
     static bool
     GetLogChannelCallbacks(const ConstString &channel, Log::Callbacks &log_callbacks);
 
+    static bool
+    EnableLogChannel(lldb::StreamSP &log_stream_sp, uint32_t log_options, const char *channel,
+                     const char **categories, Stream &error_stream);
+
     static void
     EnableAllLogChannels(lldb::StreamSP &log_stream_sp, uint32_t log_options, const char **categories,
                          Stream *feedback_strm);
 
     static void
     DisableAllLogChannels(Stream *feedback_strm);
 
     static void

source/Core/Debugger.cpp

Debugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton)
     // open logging streams, I just redirect everything from here on out to the
     // callback.
     m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton));
 }
 
 bool
 Debugger::EnableLog (const char *channel, const char **categories, const char *log_file, uint32_t log_options, Stream &error_stream)
 {
-    Log::Callbacks log_callbacks;
-
     StreamSP log_stream_sp;
     if (m_log_callback_stream_sp)
     {
         log_stream_sp = m_log_callback_stream_sp;
         // For now when using the callback mode you always get thread & timestamp.
         log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
     }
     else if (log_file == NULL || *log_file == '\0')
else
             m_log_streams[log_file] = log_stream_sp;
         }
     }
     assert (log_stream_sp.get());
     
     if (log_options == 0)
         log_options = LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE;
         
-    if (Log::GetLogChannelCallbacks (ConstString(channel), log_callbacks))
-    {
-        log_callbacks.enable (log_stream_sp, log_options, categories, &error_stream);
-        return true;
-    }
-    else
-    {
-        LogChannelSP log_channel_sp (LogChannel::FindPlugin (channel));
-        if (log_channel_sp)
-        {
-            if (log_channel_sp->Enable (log_stream_sp, log_options, &error_stream, categories))
-            {
-                return true;
-            }
-            else
-            {
-                error_stream.Printf ("Invalid log channel '%s'.\n", channel);
-                return false;
-            }
-        }
-        else
-        {
-            error_stream.Printf ("Invalid log channel '%s'.\n", channel);
-            return false;
-        }
-    }
-    return false;
+    return Log::EnableLogChannel(log_stream_sp, log_options, channel, categories, error_stream);
 }
 
 SourceManager &
 Debugger::GetSourceManager ()
 {
     if (m_source_manager_ap.get() == NULL)
         m_source_manager_ap.reset (new SourceManager (shared_from_this()));
     return *m_source_manager_ap;

source/Core/Log.cpp

Log::GetLogChannelCallbacks (const ConstString &channel, Log::Callbacks &log_callbacks)
     {
         log_callbacks = pos->second;
         return true;
     }
     ::memset (&log_callbacks, 0, sizeof(log_callbacks));
     return false;
 }
 
+bool
+Log::EnableLogChannel(lldb::StreamSP &log_stream_sp,
+                      uint32_t log_options,
+                      const char *channel,
+                      const char **categories,
+                      Stream &error_stream)
+{
+    Log::Callbacks log_callbacks;
+    if (Log::GetLogChannelCallbacks (ConstString(channel), log_callbacks))
+    {
+        log_callbacks.enable (log_stream_sp, log_options, categories, &error_stream);
+        return true;
+    }
+    
+    LogChannelSP log_channel_sp (LogChannel::FindPlugin (channel));
+    if (log_channel_sp)
+    {
+        if (log_channel_sp->Enable (log_stream_sp, log_options, &error_stream, categories))
+        {
+            return true;
+        }
+        else
+        {
+            error_stream.Printf ("Invalid log channel '%s'.\n", channel);
+            return false;
+        }
+    }
+    else
+    {
+        error_stream.Printf ("Invalid log channel '%s'.\n", channel);
+        return false;
+    }
+}
+
 void
 Log::EnableAllLogChannels
 (
     StreamSP &log_stream_sp,
     uint32_t log_options,
     const char **categories,
     Stream *feedback_strm
 )

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

 class GDBRemoteCommunicationServerLLGS :
     public GDBRemoteCommunicationServerCommon,
     public NativeProcessProtocol::NativeDelegate
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
-    GDBRemoteCommunicationServerLLGS(const lldb::PlatformSP& platform_sp,
-                      lldb::DebuggerSP& debugger_sp);
+    GDBRemoteCommunicationServerLLGS(const lldb::PlatformSP& platform_sp);
 
     virtual
     ~GDBRemoteCommunicationServerLLGS();
 
     //------------------------------------------------------------------
     /// Specify the program to launch and its arguments.
     ///
     /// @param[in] args

 
 protected:
     lldb::PlatformSP m_platform_sp;
     lldb::thread_t m_async_thread;
     lldb::tid_t m_current_tid;
     lldb::tid_t m_continue_tid;
     Mutex m_debugged_process_mutex;
     NativeProcessProtocolSP m_debugged_process_sp;
-    lldb::DebuggerSP m_debugger_sp;
     Communication m_stdio_communication;
     lldb::StateType m_inferior_prev_state;
     lldb::DataBufferSP m_active_auxv_buffer_sp;
     Mutex m_saved_registers_mutex;
     std::unordered_map<uint32_t, lldb::DataBufferSP> m_saved_registers_map;
     uint32_t m_next_saved_registers_id;
 
     PacketResult

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

 #include <cstring>
 #include <chrono>
 #include <thread>
 
 // Other libraries and framework includes
 #include "llvm/ADT/Triple.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/DataBuffer.h"
-#include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
+#include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/Endian.h"
 #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/Target/Process.h"
 #include "lldb/Host/common/NativeRegisterContext.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "Utility/UriParser.h"
 #include "ProcessGDBRemote.h"
enum GDBRemoteServerError
         eErrorExitStatus
     };
 }
 
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerLLGS constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(
-        const lldb::PlatformSP& platform_sp,
-        lldb::DebuggerSP &debugger_sp) :
+        const lldb::PlatformSP& platform_sp) :
     GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"),
     m_platform_sp (platform_sp),
     m_async_thread (LLDB_INVALID_HOST_THREAD),
     m_current_tid (LLDB_INVALID_THREAD_ID),
     m_continue_tid (LLDB_INVALID_THREAD_ID),
     m_debugged_process_mutex (Mutex::eMutexTypeRecursive),
     m_debugged_process_sp (),
-    m_debugger_sp (debugger_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)
 {
     assert(platform_sp);
-    assert(debugger_sp && "must specify non-NULL debugger_sp for lldb-gdbserver");
     RegisterPacketHandlers();
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerLLGS::~GDBRemoteCommunicationServerLLGS()
 {

tools/lldb-server/CMakeLists.txt

 endif ()
 
 include_directories(../../source)
 
 include(../../cmake/LLDBDependencies.cmake)
 
 if (BUILD_SHARED_LIBS )
   add_lldb_executable(lldb-server
-    lldb-server.cpp
     lldb-gdbserver.cpp
     lldb-platform.cpp
+    lldb-server.cpp
+    LLDBServerUtilities.cpp
     )
 
   target_link_libraries(lldb-server liblldb)
 else()
   add_lldb_executable(lldb-server
-    lldb-server.cpp
     lldb-gdbserver.cpp
     lldb-platform.cpp
+    lldb-server.cpp
+    LLDBServerUtilities.cpp
     ../../source/lldb.cpp
     )
 
   # The Darwin linker doesn't understand --start-group/--end-group.
   if (LLVM_COMPILER_IS_GCC_COMPATIBLE AND NOT "${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
     target_link_libraries(lldb-server
                           -Wl,--start-group ${LLDB_USED_LIBS} -Wl,--end-group)
   else()

tools/lldb-server/LLDBServerUtilities.h

+//===-- LLDBServerUtilities.h -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/StringRef.h"
+
+#include <string>
+
+namespace lldb_private {
+namespace lldb_server {
+
+class LLDBServerUtilities
+{
+public:
+  static bool
+  SetupLogging(const std::string& log_file, const llvm::StringRef& log_channels, uint32_t log_options);
+};
+
+}
+}

tools/lldb-server/LLDBServerUtilities.cpp

+//===-- LLDBServerUtilities.cpp ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LLDBServerUtilities.h"
+
+#include "lldb/Core/Log.h"
+#include "lldb/Core/StreamFile.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Interpreter/Args.h"
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+
+using namespace lldb;
+using namespace lldb_private::lldb_server;
+using namespace llvm;
+
+bool
+LLDBServerUtilities::SetupLogging(const std::string& log_file,
+                                const StringRef& log_channels,
+                                uint32_t log_options)
+{
+    lldb::StreamSP log_stream_sp;
+    if (log_file.empty())
+    {
+        log_stream_sp.reset(new StreamFile(stdout, false));
+    }
+    else
+    {
+        uint32_t options = File::eOpenOptionWrite | File::eOpenOptionCanCreate |
+                           File::eOpenOptionCloseOnExec | File::eOpenOptionAppend;
+        if (!(log_options & LLDB_LOG_OPTION_APPEND))
+            options |= File::eOpenOptionTruncate;
+
+        log_stream_sp.reset(new StreamFile(log_file.c_str(), options));
+    }
+
+    SmallVector<StringRef, 32> channel_array;
+    log_channels.split(channel_array, ":");
+    for (auto channel_with_categories : channel_array)
+    {
+        StreamString error_stream;
+        Args channel_then_categories(channel_with_categories);
+        std::string channel(channel_then_categories.GetArgumentAtIndex(0));
+        channel_then_categories.Shift (); // Shift off the channel
+
+        bool success = Log::EnableLogChannel(log_stream_sp,
+                                             log_options,
+                                             channel.c_str(),
+                                             channel_then_categories.GetConstArgumentVector(),
+                                             error_stream);
+        if (!success)
+        {
+            fprintf(stderr, "Unable to open log file '%s' for channel \"%s\"\n",
+                    log_file.c_str(),
+                    channel_with_categories.str().c_str());
+            return false;
+        }
+    }
+    return true;
+}

tools/lldb-server/lldb-gdbserver.cpp

 #include <unistd.h>
 #endif
 
 // C++ Includes
 
 // Other libraries and framework includes
 #include "llvm/ADT/StringRef.h"
 
-#include "lldb/Core/Error.h"
 #include "lldb/Core/ConnectionMachPort.h"
-#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Error.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/StreamFile.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/HostThread.h"
-#include "lldb/Host/Pipe.h"
 #include "lldb/Host/OptionParser.h"
+#include "lldb/Host/Pipe.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/ThreadLauncher.h"
-#include "lldb/Interpreter/CommandInterpreter.h"
-#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Target/Platform.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
 
 #ifndef LLGS_VERSION_STR
 #define LLGS_VERSION_STR "local_build"
 #endif
 
 using namespace llvm;
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::lldb_server;
 using namespace lldb_private::process_gdb_remote;
 
 // lldb-gdbserver state
 
 namespace
 {
 HostThread s_listen_thread;
     std::unique_ptr<ConnectionFileDescriptor> s_listen_connection_up;
signal_handler(int signo)
     }
 }
 #endif // #ifndef _WIN32
 
 static void
 display_usage (const char *progname, const char* subcommand)
 {
     fprintf(stderr, "Usage:\n  %s %s "
-            "[--log-file log-file-path] "
-            "[--log-flags flags] "
-            "[--lldb-command command]* "
+            "[--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);
#ifdef __linux__
     pthread_sigmask(SIG_BLOCK, &set, NULL);
 #endif
 
     const char *progname = argv[0];
     const char *subcommand = argv[1];
     argc--;
     argv++;
     int long_option_index = 0;
-    Args log_args;
     Error error;
     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;
 
-    lldb::DebuggerSP debugger_sp = Debugger::CreateInstance ();
-
-    debugger_sp->SetInputFileHandle(stdin, false);
-    debugger_sp->SetOutputFileHandle(stdout, false);
-    debugger_sp->SetErrorFileHandle(stderr, false);
-
     // ProcessLaunchInfo launch_info;
     ProcessAttachInfo attach_info;
 
     bool show_usage = false;
     int option_error = 0;
 #if __GLIBC__
     optind = 0;
 #else
     optreset = 1;
     optind = 1;
 #endif
 
     std::string short_options(OptionParser::GetShortOptionString(g_long_options));
 
-    std::vector<std::string> lldb_commands;
-
     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': // Set Log File
#endif
     }
 
     if (show_usage || option_error)
     {
         display_usage(progname, subcommand);
         exit(option_error);
     }
 
-    SmallVector<StringRef, 32> channel_array;
-    log_channels.split(channel_array, ":");
-    uint32_t log_options = 0;
-    for (auto channel_with_categories : channel_array)
-    {
-        StreamString error_stream;
-        Args channel_then_categories(channel_with_categories);
-        std::string channel(channel_then_categories.GetArgumentAtIndex(0));
-        channel_then_categories.Shift ();  // Shift off the channel
-        bool success = debugger_sp->EnableLog (channel.c_str(),
-                                               channel_then_categories.GetConstArgumentVector(),
-                                               log_file.c_str(),
-                                               log_options,
-                                               error_stream);
-        if (!success)
-        {
-            fprintf(stderr, "Unable to open log file '%s' for channel \"%s\"",
-                    log_file.c_str(),
-                    channel_with_categories.str().c_str());
-            return -1;
-        }
-    }
+    if (!LLDBServerUtilities::SetupLogging(log_file, log_channels, 0))
 
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_VERBOSE));
     if (log)
     {
         log->Printf ("lldb-server launch");
         for (int i = 0; i < argc; i++)
         {
             log->Printf ("argv[%i] = '%s'", i, argv[i]);
         }
     }
 
     // Skip any options we consumed with getopt_long_only.
     argc -= optind;
     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, debugger_sp);
+    GDBRemoteCommunicationServerLLGS gdb_server (platform_sp);
 
     const char *const host_and_port = argv[0];
     argc -= 1;
     argv += 1;
 
     // Any arguments left over are for the 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

tools/lldb-server/lldb-platform.cpp

 #include <stdlib.h>
 #include <string.h>
 #include <sys/wait.h>
 
 // C++ Includes
 
 // Other libraries and framework includes
 #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/Host/Socket.h"
-#include "lldb/Interpreter/CommandInterpreter.h"
-#include "lldb/Interpreter/CommandReturnObject.h"
+#include "LLDBServerUtilities.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::lldb_server;
 using namespace lldb_private::process_gdb_remote;
+using namespace llvm;
 
 //----------------------------------------------------------------------
 // option descriptors for getopt_long_only()
 //----------------------------------------------------------------------
 
 static int g_debug = 0;
 static int g_verbose = 0;
 static int g_server = 0;
 
 static struct option g_long_options[] =
 {
     { "debug",              no_argument,        &g_debug,           1   },
     { "verbose",            no_argument,        &g_verbose,         1   },
+    { "log-file",           required_argument,  NULL,               'l' },
+    { "log-channels",       required_argument,  NULL,               'c' },
     { "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' },
     { "server",             no_argument,        &g_server,          1   },
     { 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-server...\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);
+    fprintf(stderr, "Usage:\n  %s %s [--log-file log-file-name] [--log-channels log-channel-list] --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;
 
-    lldb::DebuggerSP debugger_sp = Debugger::CreateInstance ();
-
-    debugger_sp->SetInputFileHandle(stdin, false);
-    debugger_sp->SetOutputFileHandle(stdout, false);
-    debugger_sp->SetErrorFileHandle(stderr, false);
-    
+    std::string log_file;
+    StringRef log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
     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;
     int socket_error = -1;
     
     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 'l': // Set Log File
+            if (optarg && optarg[0])
+                log_file.assign(optarg);
+            break;
+
+        case 'c': // Log Channels
+            if (optarg && optarg[0])
+                log_channels = StringRef(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)
                     {
while ((ch = getopt_long_only(argc, argv, short_options.c_str(), g_long_options, &long_option_index)) != -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;
         }
     }
 
+    if (!LLDBServerUtilities::SetupLogging(log_file, log_channels, 0))
+        return -1;
+
     // 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);
-    }
-
     std::unique_ptr<Socket> listening_socket_up;
     Socket *socket = nullptr;
     printf ("Listening for a connection from %s...\n", listen_host_port.c_str());
     const bool children_inherit_listen_socket = false;
 
     // the test suite makes many connections in parallel, let's not miss any.
     // The highest this should get reasonably is a function of the number 
     // of target CPUs.  For now, let's just use 100

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/Core/Debugger.h"
 #include "lldb/Initialization/SystemLifetimeManager.h"
 #include "lldb/Initialization/SystemInitializerCommon.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ManagedStatic.h"
 
 #include <stdio.h>
 #include <stdlib.h>