Add reverse-connect functionality to the gdb-remote command

[fjricci]

Summary

Add an optional "reverse" option to the gdb-remote command,
which causes lldb to listen on the specified [host:]port,
waiting for the remote server to reverse-connect back to lldb.

[fjricci]

Accidentally uploaded the wrong commit. Sorry about that

[zturner]

Looks like there's a few inconsistencies with our coding style. Can you please run clang-format on this patch?

[fjricci]

Apply clang-format

[fjricci]

Perhaps I ran clang-format in the wrong configuration, but it looks like it made the function declaration style in include/lldb/Target/Platform.h a bit inconsistent. Is this the desired behavior?

[zturner]

In D17099#349136, @fjricci wrote:

Perhaps I ran clang-format in the wrong configuration, but it looks like it made the function declaration style in include/lldb/Target/Platform.h a bit inconsistent. Is this the desired behavior?

The way it formatted the code is consistent with our rules, so it looks fine to me.

[zturner]

(The problem is that surrounding code was not clang-formatted)

[labath]

I think this would be better if you could specify the connection direction in the url. Also, a test for this functionality would be great.

source/Interpreter/CommandInterpreter.cpp

643

how about just using listen://... to mean reverse connection?

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

226

I don't think we need to pass this reverse=false around everywhere. We already support listen://host:port url scheme (see e.g. ConnectionFileDescriptor::Connect`). Could you use that to specify connection direction?

[fjricci]

Would it be better to add a test in the same commit or a separate one?

source/Interpreter/CommandInterpreter.cpp

643

My concern with doing it this way was that ProcessGDBRemote::ConnectToDebugserver() seems to implicitly require a connect://... url, and I didn't want to risk breaking future changes. However, it still works correctly if I pass a listen://... url, so it seems like a reasonable change.

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

226

I had considered that, but wasn't sure whether parsing the direction out of the url string every time it was needed would be better or worse than passing it around as a bool. I'll make the change.

[fjricci]

Refactor to use listen urls

[labath]

I like this more, but I'd like to take it a bit further. I think we won't have to parse the url string at all (see comments).

I believe the best way to avoid breaking (and being broken by) other changes is to make sure this fits in nicely in the existing architecture. Putting this logic into ConnectToDebugServer seems like the logical place.

You can wait with the test until we have settled on the final implementation, but I'd like the test to go in together with the change.

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

732

If we can get ConnectToDebugserver working with a listen url then we will get rid of this url parsing hack...

1075

ConnectionFileDescriptor::Connect seems to be able to handle listen:// urls. What would happen if you just passed the listen url to ConnectToDebugserver

[fjricci]

It looks like passing a listen:// url to ConnectToDebugserver actually works "out of the box". Thanks! I'll work on writing a unit test.

[fjricci]

Remove unnecessary special-case logic for reverse connecting

[fjricci]

This functionality can already be accessed by using the "process connect" command with a listen url directly.

include/lldb/Target/Platform.h

//        FindPlugin (Process *process, const ConstString &plugin_name);
                       Target *target,       // Can be nullptr, if nullptr create a new target, else use existing one
                       Error &error);
 
         virtual lldb::ProcessSP
         ConnectProcess (const char* connect_url,
                         const char* plugin_name,
                         lldb_private::Debugger &debugger,
                         lldb_private::Target *target,
-                        lldb_private::Error &error);
+                        lldb_private::Error &error,
+                        bool reverse = false);
 
         //------------------------------------------------------------------
         /// Attach to an existing process using a process ID.
         ///
         /// Each platform subclass needs to implement this function and 
         /// attempt to attach to the process with the process ID of \a pid.
         /// The platform subclass should return an appropriate ProcessSP 
         /// subclass that is attached to the process, or an empty shared 

include/lldb/Target/Process.h

public:
     ///
     /// @param[in] remote_url
     ///     The URL format that we are connecting to.
     ///
     /// @return
     ///     Returns an error object.
     //------------------------------------------------------------------
     virtual Error
-    ConnectRemote (Stream *strm, const char *remote_url);
+    ConnectRemote (Stream *strm, const char *remote_url, bool reverse = false);
 
     bool
     GetShouldDetach () const
     {
         return m_should_detach;
     }
 
     void
#endif
     ///
     /// @param[in] remote_url
     ///     The URL format that we are connecting to.
     ///
     /// @return
     ///     Returns an error object.
     //------------------------------------------------------------------
     virtual Error
-    DoConnectRemote (Stream *strm, const char *remote_url)
+    DoConnectRemote (Stream *strm, const char *remote_url, bool reverse = false)
     {
         Error error;
         error.SetErrorString ("remote connections are not supported");
         return error;
     }
 
     //------------------------------------------------------------------
     /// Attach to an existing process using a process ID.

source/Commands/CommandObjectProcess.cpp

public:
         
         std::string plugin_name;        
     };
 
     CommandObjectProcessConnect (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "process connect",
                              "Connect to a remote debug service.",
-                             "process connect <remote-url>",
+                             "process connect <remote-url> [reverse]",
                              0),
         m_options (interpreter)
     {
     }
     
     ~CommandObjectProcessConnect () override
     {
     }
 
     
     Options *
     GetOptions () override
     {
         return &m_options;
     }
     
 protected:
     bool
     DoExecute (Args& command, CommandReturnObject &result) override
     {
+        bool reverse_connect = false;
         if (command.GetArgumentCount() != 1)
         {
-            result.AppendErrorWithFormat ("'%s' takes exactly one argument:\nUsage: %s\n",
+            if (command.GetArgumentCount() != 2)
+            {
+                result.AppendErrorWithFormat ("'%s' takes either 1 or 2 arguments:\nUsage: %s\n",
+                                              m_cmd_name.c_str(),
+                                              m_cmd_syntax.c_str());
+                result.SetStatus (eReturnStatusFailed);
+                return false;
+            }
+
+            if (strcmp(command.GetArgumentAtIndex(1), "reverse"))
+            {
+                result.AppendErrorWithFormat ("Invalid arguments for '%s'.\nUsage: %s\n",
                                               m_cmd_name.c_str(),
                                               m_cmd_syntax.c_str());
                 result.SetStatus (eReturnStatusFailed);
                 return false;
             }
 
-        
+            reverse_connect = true;
+        }
+
+        if (!reverse_connect)
+        {
             Process *process = m_exe_ctx.GetProcessPtr();
             if (process && process->IsAlive())
             {
               result.AppendErrorWithFormat ("Process %" PRIu64 " is currently being debugged, kill the process before connecting.\n",
-                                          process->GetID());
               result.SetStatus (eReturnStatusFailed);
               return false;
             }
+        }
 
         const char *plugin_name = nullptr;
         if (!m_options.plugin_name.empty())
             plugin_name = m_options.plugin_name.c_str();
 
         Error error;
         Debugger& debugger = m_interpreter.GetDebugger();
         PlatformSP platform_sp = m_interpreter.GetPlatform(true);
         ProcessSP process_sp = platform_sp->ConnectProcess(command.GetArgumentAtIndex(0),
                                                            plugin_name,
                                                            debugger,
                                                            debugger.GetSelectedTarget().get(),
-                                                           error);
+                                                           error,
+                                                           reverse_connect);
         if (error.Fail() || process_sp == nullptr)
         {
             result.AppendError(error.AsCString("Error connecting to the process"));
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
         return true;
     }

source/Interpreter/CommandInterpreter.cpp

if (undisplay_regex_cmd_ap.get())
             m_command_dict[undisplay_regex_cmd_sp->GetCommandName ()] = undisplay_regex_cmd_sp;
         }
     }
 
     std::unique_ptr<CommandObjectRegexCommand>
     connect_gdb_remote_cmd_ap(new CommandObjectRegexCommand (*this,
                                                              "gdb-remote",
                                                              "Connect to a remote GDB server.  If no hostname is provided, localhost is assumed.",
-                                                             "gdb-remote [<hostname>:]<portnum>",
+                                                             "gdb-remote [<hostname>:]<portnum> [reverse]",
                                                              2,
                                                              0,
                                                              false));
     if (connect_gdb_remote_cmd_ap.get())
     {
         if (connect_gdb_remote_cmd_ap->AddRegexCommand("^([^:]+:[[:digit:]]+)$", "process connect --plugin gdb-remote connect://%1") &&
-            connect_gdb_remote_cmd_ap->AddRegexCommand("^([[:digit:]]+)$", "process connect --plugin gdb-remote connect://localhost:%1"))
+            connect_gdb_remote_cmd_ap->AddRegexCommand("^([[:digit:]]+)$", "process connect --plugin gdb-remote connect://localhost:%1") &&
+            connect_gdb_remote_cmd_ap->AddRegexCommand("^([^:]+:[[:digit:]]+) reverse$", "process connect --plugin gdb-remote connect://%1 reverse") &&
+            connect_gdb_remote_cmd_ap->AddRegexCommand("^([[:digit:]]+) reverse$", "process connect --plugin gdb-remote connect://localhost:%1 reverse"))
         {
             CommandObjectSP command_sp(connect_gdb_remote_cmd_ap.release());
             m_command_dict[command_sp->GetCommandName ()] = command_sp;
         }
     }
 
     std::unique_ptr<CommandObjectRegexCommand>
     connect_kdp_remote_cmd_ap(new CommandObjectRegexCommand (*this,
                                                              "kdp-remote",
                                                              "Connect to a remote KDP server.  udp port 41139 is the default port number.",
                                                              "kdp-remote <hostname>[:<portnum>]",

source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h

public:
     Error
     DisconnectRemote () override;
 
     lldb::ProcessSP
     ConnectProcess (const char* connect_url,
                     const char* plugin_name,
                     lldb_private::Debugger &debugger,
                     lldb_private::Target *target,
-                    lldb_private::Error &error) override;
+                    lldb_private::Error &error,
+                    bool reverse = false) override;
 
     size_t
     ConnectToWaitingProcesses(lldb_private::Debugger& debugger, lldb_private::Error& error) override;
 
 protected:
     std::string m_device_id;
     std::map<lldb::pid_t, uint16_t> m_port_forwards;
     llvm::Optional<AdbClient::UnixSocketNamespace> m_socket_namespace;

source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

PlatformAndroidRemoteGDBServer::MakeConnectURL(const lldb::pid_t pid,
     return error;
 }
 
 lldb::ProcessSP
 PlatformAndroidRemoteGDBServer::ConnectProcess(const char* connect_url,
                                                const char* plugin_name,
                                                lldb_private::Debugger &debugger,
                                                lldb_private::Target *target,
-                                               lldb_private::Error &error)
+                                               lldb_private::Error &error,
+                                               bool reverse)
 {
     // We don't have the pid of the remote gdbserver when it isn't started by us but we still want
     // to store the list of port forwards we set up in our port forward map. Generate a fake pid for
     // these cases what won't collide with any other valid pid on android.
     static lldb::pid_t s_remote_gdbserver_fake_pid = 0xffffffffffffffffULL;
 
     int remote_port;
     std::string scheme, host, path;
error = MakeConnectURL(s_remote_gdbserver_fake_pid--,
                            new_connect_url);
     if (error.Fail())
         return nullptr;
 
     return PlatformRemoteGDBServer::ConnectProcess(new_connect_url.c_str(),
                                                    plugin_name,
                                                    debugger,
                                                    target,
-                                                   error);
+                                                   error,
+                                                   reverse);
 }
 
 size_t
 PlatformAndroidRemoteGDBServer::ConnectToWaitingProcesses(Debugger& debugger, Error& error)
 {
     std::vector<std::string> connection_urls;
     GetPendingGdbServerList(connection_urls);
 
     for (size_t i = 0; i < connection_urls.size(); ++i)
     {
         ConnectProcess(connection_urls[i].c_str(), nullptr, debugger, nullptr, error);
         if (error.Fail())
             return i; // We already connected to i process succsessfully
     }
     return connection_urls.size();
 }

source/Plugins/Platform/POSIX/PlatformPOSIX.h

public:
     lldb_private::Error
     UnloadImage (lldb_private::Process* process, uint32_t image_token) override;
 
     lldb::ProcessSP
     ConnectProcess (const char* connect_url,
                     const char* plugin_name,
                     lldb_private::Debugger &debugger,
                     lldb_private::Target *target,
-                    lldb_private::Error &error) override;
+                    lldb_private::Error &error,
+                    bool reverse = false) override;
                     
     size_t
     ConnectToWaitingProcesses(lldb_private::Debugger& debugger, lldb_private::Error& error) override;
 
 protected:
     std::unique_ptr<lldb_private::OptionGroupPlatformRSync> m_option_group_platform_rsync;
     std::unique_ptr<lldb_private::OptionGroupPlatformSSH> m_option_group_platform_ssh;
     std::unique_ptr<lldb_private::OptionGroupPlatformCaching> m_option_group_platform_caching;

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

PlatformPOSIX::UnloadImage (lldb_private::Process* process, uint32_t image_token)
     return Error();
 }   
 
 lldb::ProcessSP
 PlatformPOSIX::ConnectProcess (const char* connect_url,
                                const char* plugin_name,
                                lldb_private::Debugger &debugger,
                                lldb_private::Target *target,
-                               lldb_private::Error &error)
+                               lldb_private::Error &error,
+                               bool reverse)
 {
     if (m_remote_platform_sp)
         return m_remote_platform_sp->ConnectProcess(connect_url,
                                                     plugin_name,
                                                     debugger,
                                                     target,
-                                                    error);
+                                                    error,
+                                                    reverse);
 
-    return Platform::ConnectProcess(connect_url, plugin_name, debugger, target, error);
+    return Platform::ConnectProcess(connect_url, plugin_name, debugger, target, error, reverse);
 }
 
 const char*
 PlatformPOSIX::GetLibdlFunctionDeclarations() const
 {
     return R"(
               extern "C" void* dlopen(const char*, int);
               extern "C" void* dlsym(void*, const char*);

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

public:
     const lldb::UnixSignalsSP &
     GetRemoteUnixSignals() override;
 
     lldb::ProcessSP
     ConnectProcess (const char* connect_url,
                     const char* plugin_name,
                     lldb_private::Debugger &debugger,
                     lldb_private::Target *target,
-                    lldb_private::Error &error) override;
+                    lldb_private::Error &error,
+                    bool reverse = false) override;
 
     virtual size_t
     GetPendingGdbServerList(std::vector<std::string>& connection_urls);
 
 protected:
     process_gdb_remote::GDBRemoteCommunicationClient m_gdb_client;
     std::string m_platform_description; // After we connect we can get a more complete description of what we are connected to
     std::string m_platform_scheme;

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

PlatformRemoteGDBServer::MakeUrl(const char* scheme,
     return result.GetString();
 }
 
 lldb::ProcessSP
 PlatformRemoteGDBServer::ConnectProcess(const char* connect_url,
                                         const char* plugin_name,
                                         lldb_private::Debugger &debugger,
                                         lldb_private::Target *target,
-                                        lldb_private::Error &error)
+                                        lldb_private::Error &error,
+                                        bool reverse)
 {
     if (!IsRemote() || !IsConnected())
     {
         error.SetErrorString("Not connected to remote gdb server");
         return nullptr;
     }
-    return Platform::ConnectProcess(connect_url, plugin_name, debugger, target, error);
+    return Platform::ConnectProcess(connect_url, plugin_name, debugger, target, error, reverse);
 }
 
 size_t
 PlatformRemoteGDBServer::GetPendingGdbServerList(std::vector<std::string>& connection_urls)
 {
     std::vector<std::pair<uint16_t, std::string>> remote_servers;
     m_gdb_client.QueryGDBServer(remote_servers);
     for (const auto& gdbserver : remote_servers)

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

public:
     }
 
     uint32_t
     GetPacketTimeoutInMicroSeconds () const
     {
         return m_packet_timeout * TimeValue::MicroSecPerSec;
     }
 
+    Error
+    WaitForDebugserver (const char *url);
+
     //------------------------------------------------------------------
     // Start a debugserver instance on the current host using the
     // supplied connection URL.
     //------------------------------------------------------------------
     Error
     StartDebugserverProcess(const char *url,
                             Platform *platform, // If non nullptr, then check with the platform for the GDB server binary if it can't be located
                             ProcessLaunchInfo &launch_info,
#endif
     // Returns 'false' if unable to decompress or if the checksum was invalid.
     //
     // NB: Once the packet has been decompressed, checksum cannot be computed based
     // on m_bytes.  The checksum was for the compressed packet.
     bool
     DecompressPacket ();
 
     Error
-    StartListenThread (const char *hostname = "127.0.0.1", uint16_t port = 0);
+    StartListenThread (const char *listen_url = "listen://127.0.0.1:0");
 
     bool
     JoinListenThread ();
 
     static lldb::thread_result_t
     ListenThread (lldb::thread_arg_t arg);
 
     // GDB-Remote read thread

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

if (!m_bytes.empty())
                 return GDBRemoteCommunication::PacketType::Standard;
         }
     }
     packet.Clear();
     return GDBRemoteCommunication::PacketType::Invalid;
 }
 
 Error
-GDBRemoteCommunication::StartListenThread (const char *hostname, uint16_t port)
+GDBRemoteCommunication::StartListenThread (const char *listen_url)
 {
     Error error;
     if (m_listen_thread.IsJoinable())
     {
         error.SetErrorString("listen thread already running");
     }
     else
     {
-        char listen_url[512];
-        if (hostname && hostname[0])
-            snprintf(listen_url, sizeof(listen_url), "listen://%s:%i", hostname, port);
-        else
-            snprintf(listen_url, sizeof(listen_url), "listen://%i", port);
         m_listen_url = listen_url;
         SetConnection(new ConnectionFileDescriptor());
         m_listen_thread = ThreadLauncher::LaunchThread(listen_url, GDBRemoteCommunication::ListenThread, this, &error);
     }
     return error;
 }
 
 bool
if (connection)
         // Do the listen on another thread so we can continue on...
         if (connection->Connect(comm->m_listen_url.c_str(), &error) != eConnectionStatusSuccess)
             comm->SetConnection(NULL);
     }
     return NULL;
 }
 
 Error
+GDBRemoteCommunication::WaitForDebugserver (const char *url)
+{
+    Error error;
+    Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
+    if (log)
+        log->Printf ("GDBRemoteCommunication::%s(url=%s)", __FUNCTION__, url ? url : "<empty>");
+
+    std::string listen_url(url);
+    size_t start_replace = listen_url.find("connect");
+    listen_url.replace(start_replace, start_replace + strlen("connect"), "listen");
+
+    error = StartListenThread (listen_url.c_str());
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunication::%s() unable to start listen thread: %s", __FUNCTION__, error.AsCString());
+        return error;
+    }
+
+    // Make sure we actually connect with the debugserver...
+    JoinListenThread();
+
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunication::%s() failed: %s", __FUNCTION__, error.AsCString());
+    }
+
+    return error;
+}
+
+Error
 GDBRemoteCommunication::StartDebugserverProcess (const char *url,
                                                  Platform *platform,
                                                  ProcessLaunchInfo &launch_info,
                                                  uint16_t *port,
                                                  const Args& inferior_args)
 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
     if (log)
#else
                 debugserver_args.AppendArgument(std::to_string(write_fd).c_str());
                 launch_info.AppendCloseFileAction(socket_pipe.GetReadFileDescriptor());
 #endif
             }
             else
             {
                 // No host and port given, so lets listen on our end and make the debugserver
                 // connect to us..
-                error = StartListenThread ("127.0.0.1", 0);
+                error = StartListenThread ("listen://127.0.0.1:0");
                 if (error.Fail())
                 {
                     if (log)
                         log->Printf ("GDBRemoteCommunication::%s() unable to start listen thread: %s", __FUNCTION__, error.AsCString());
                     return error;
                 }
     
                 ConnectionFileDescriptor *connection = (ConnectionFileDescriptor *)GetConnection ();

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

public:
 
     Error
     WillAttachToProcessWithID (lldb::pid_t pid) override;
 
     Error
     WillAttachToProcessWithName (const char *process_name, bool wait_for_launch) override;
 
     Error
-    DoConnectRemote (Stream *strm, const char *remote_url) override;
+    DoConnectRemote (Stream *strm, const char *remote_url, bool reverse = false) override;
     
     Error
     WillLaunchOrAttach ();
     
     Error
     DoAttachToProcessWithID (lldb::pid_t pid, const ProcessAttachInfo &attach_info) override;
     
     Error

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

 
 Error
 ProcessGDBRemote::WillAttachToProcessWithName (const char *process_name, bool wait_for_launch)
 {
     return WillLaunchOrAttach ();
 }
 
 Error
-ProcessGDBRemote::DoConnectRemote (Stream *strm, const char *remote_url)
+ProcessGDBRemote::DoConnectRemote (Stream *strm, const char *remote_url, bool reverse)
 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
     Error error (WillLaunchOrAttach ());
 
     if (error.Fail())
         return error;
 
-    error = ConnectToDebugserver (remote_url);
+    if (reverse) {
+        error = m_gdb_comm.WaitForDebugserver(remote_url);
+        if (error.Fail())
+            return error;
+    }
     
+    error = ConnectToDebugserver (remote_url);
     if (error.Fail())
         return error;
     StartAsyncThread ();
 
     lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID ();
     if (pid == LLDB_INVALID_PROCESS_ID)
     {
         // We don't have a valid process ID, so note that we are connected
if (connect_url && connect_url[0])
             log->Printf("ProcessGDBRemote::%s Connecting to %s", __FUNCTION__, connect_url);
         std::unique_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor());
         if (conn_ap.get())
         {
             const uint32_t max_retry_count = 50;
             uint32_t retry_count = 0;
             while (!m_gdb_comm.IsConnected())
             {
                 if (conn_ap->Connect(connect_url, &error) == eConnectionStatusSuccess)
                 {
                     m_gdb_comm.SetConnection (conn_ap.release());
                     break;
                 }
                 else if (error.WasInterrupted())
                 {
                     // If we were interrupted, don't keep retrying.
                     break;

source/Target/Platform.cpp

Platform::UnloadImage(lldb_private::Process* process, uint32_t image_token)
     return Error("UnloadImage is not supported on the current platform");
 }
 
 lldb::ProcessSP
 Platform::ConnectProcess(const char* connect_url,
                          const char* plugin_name,
                          lldb_private::Debugger &debugger,
                          lldb_private::Target *target,
-                         lldb_private::Error &error)
+                         lldb_private::Error &error,
+                         bool reverse)
 {
     error.Clear();
 
     if (!target)
     {
         TargetSP new_target_sp;
         error = debugger.GetTargetList().CreateTarget(debugger,
                                                       nullptr,
Platform::ConnectProcess(const char* connect_url,
     debugger.GetTargetList().SetSelectedTarget(target);
 
     lldb::ProcessSP process_sp = target->CreateProcess(debugger.GetListener(),
                                                        plugin_name,
                                                        nullptr);
     if (!process_sp)
         return nullptr;
 
-    error = process_sp->ConnectRemote(debugger.GetOutputFile().get(), connect_url);
+    error = process_sp->ConnectRemote(debugger.GetOutputFile().get(), connect_url, reverse);
     if (error.Fail())
         return nullptr;
 
     return process_sp;
 }
 
 size_t
 Platform::ConnectToWaitingProcesses(lldb_private::Debugger& debugger, lldb_private::Error& error)
 {
     error.Clear();
     return 0;
 }

source/Target/Process.cpp

if (new_executable_module_sp)
                          exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str () : "<none>");
         }
     }
 
     m_stop_info_override_callback = process_arch.GetStopInfoOverrideCallback();
 }
 
 Error
-Process::ConnectRemote (Stream *strm, const char *remote_url)
+Process::ConnectRemote (Stream *strm, const char *remote_url, bool reverse)
 {
     m_abi_sp.reset();
     m_process_input_reader.reset();
     
     // Find the process and its architecture.  Make sure it matches the architecture
     // of the current Target, and if not adjust it.
     
-    Error error (DoConnectRemote (strm, remote_url));
+    Error error (DoConnectRemote (strm, remote_url, reverse));
     if (error.Success())
     {
         if (GetID() != LLDB_INVALID_PROCESS_ID)
         {
             EventSP event_sp;
             StateType state = WaitForProcessStopPrivate(NULL, event_sp);
         
             if (state == eStateStopped || state == eStateCrashed)