[gdb-remote server] Abstract away getting current process

[mgorny]

Summary

Introduce new m_current_process and m_continue_process variables that
keep the pointers to currently selected process. At this moment, this
is equivalent to m_debugged_process_up but it lays foundations for
the future multiprocess support.

[labath]

Does this actually need to be a function? It seems like this could just be a pointer variable (or two), pointing into our pool of processes. I'd consider making a small struct to group the current process and the current thread within that process.

[mgorny]

In D100256#2685632, @labath wrote:

Does this actually need to be a function? It seems like this could just be a pointer variable (or two), pointing into our pool of processes. I'd consider making a small struct to group the current process and the current thread within that process.

I suppose a pointer might work for the proposed design. However, I'm wondering why we have the GetID() check here — can we have an invalid value of m_debugged_process_up then?

[labath]

In D100256#2685807, @mgorny wrote:

In D100256#2685632, @labath wrote:

Does this actually need to be a function? It seems like this could just be a pointer variable (or two), pointing into our pool of processes. I'd consider making a small struct to group the current process and the current thread within that process.

I suppose a pointer might work for the proposed design. However, I'm wondering why we have the GetID() check here — can we have an invalid value of m_debugged_process_up then?

I think someone was just being overly cautious. I'm pretty sure the check is redundant...

[mgorny]

Switched to using two pointers instead of a function. Made ReadTid() accept a default PID instead of playing with bools. Corrected Hc PID to apply only to c/C/s/vCont packets, similarly to how GDB does it.

@labath, I've left the GetID() asserts in place because I've just did a big search/replace, and replacing them would be non-trivial and I can't really spend much more time on this.

[labath]

Looks about right.

[mgorny]

Rebase and make linter happier. Now let's re-test and push.

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

protected:
   llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
   ReadXferObject(llvm::StringRef object, llvm::StringRef annex);
 
   static std::string XMLEncodeAttributeValue(llvm::StringRef value);
 
   virtual std::vector<std::string>
   HandleFeatures(const llvm::ArrayRef<llvm::StringRef> client_features) override;
 
+  // Verify and get the process instance selected by the client.
+  // If run is true, the process selected by "Hc" packet will be returned,
+  // otherwise the one selected by "Hg" will be used.  Returns nullptr if there
+  // is no process debugged.
+  NativeProcessProtocol *GetCurrentProcess(bool run) const;
+
 private:
   llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> BuildTargetXml();
 
   void HandleInferiorState_Exited(NativeProcessProtocol *process);
 
   void HandleInferiorState_Stopped(NativeProcessProtocol *process);
 
   NativeThreadProtocol *GetThreadFromSuffix(StringExtractorGDBRemote &packet);
private:
   void DataAvailableCallback();
 
   void SendProcessOutput();
 
   void StartSTDIOForwarding();
 
   void StopSTDIOForwarding();
 
-  // Read thread-id from packet.  If the thread-id is correct, returns it.
-  // Otherwise, returns the error.
+  // Read thread-id from packet.  If run is true, a TID without PID will be
+  // associated with the process selected via "Hc" packet.  Otherwise, the PID
+  // selected by "Hg" will be used.
   //
   // If allow_all is true, then the pid/tid value of -1 ('all') will be allowed.
   // In any case, the function assumes that exactly one inferior is being
   // debugged and rejects pid values that do no match that inferior.
+  //
+  // If the thread-id is correct, it is returned.  Otherwise, the error is
+  // returned.
   llvm::Expected<lldb::tid_t> ReadTid(StringExtractorGDBRemote &packet,
+                                      bool run,
                                       bool allow_all = false);
 
   // Call SetEnabledExtensions() with appropriate flags on the process.
   void SetEnabledExtensions(NativeProcessProtocol& process);
 
   // For GDBRemoteCommunicationServerLLGS only
   GDBRemoteCommunicationServerLLGS(const GDBRemoteCommunicationServerLLGS &) =
       delete;
   const GDBRemoteCommunicationServerLLGS &
   operator=(const GDBRemoteCommunicationServerLLGS &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERLLGS_H

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

case eConnectionStatusTimedOut:
       return;
     }
   }
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupported(
     StringExtractorGDBRemote &packet) {
-
-  // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(Status("Process not running."));
 
-  return SendJSONResponse(m_debugged_process_up->TraceSupported());
+  return SendJSONResponse(process->TraceSupported());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStop(
     StringExtractorGDBRemote &packet) {
-  // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(Status("Process not running."));
 
   packet.ConsumeFront("jLLDBTraceStop:");
   Expected<TraceStopRequest> stop_request =
       json::parse<TraceStopRequest>(packet.Peek(), "TraceStopRequest");
   if (!stop_request)
     return SendErrorResponse(stop_request.takeError());
 
-  if (Error err = m_debugged_process_up->TraceStop(*stop_request))
+  if (Error err = process->TraceStop(*stop_request))
     return SendErrorResponse(std::move(err));
 
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStart(
     StringExtractorGDBRemote &packet) {
-
-  // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(Status("Process not running."));
 
   packet.ConsumeFront("jLLDBTraceStart:");
   Expected<TraceStartRequest> request =
       json::parse<TraceStartRequest>(packet.Peek(), "TraceStartRequest");
   if (!request)
     return SendErrorResponse(request.takeError());
 
-  if (Error err =
-          m_debugged_process_up->TraceStart(packet.Peek(), request->type))
+  if (Error err = process->TraceStart(packet.Peek(), request->type))
     return SendErrorResponse(std::move(err));
 
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetState(
     StringExtractorGDBRemote &packet) {
-
-  // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(Status("Process not running."));
 
   packet.ConsumeFront("jLLDBTraceGetState:");
   Expected<TraceGetStateRequest> request =
       json::parse<TraceGetStateRequest>(packet.Peek(), "TraceGetStateRequest");
   if (!request)
     return SendErrorResponse(request.takeError());
 
-  return SendJSONResponse(m_debugged_process_up->TraceGetState(request->type));
+  return SendJSONResponse(process->TraceGetState(request->type));
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetBinaryData(
     StringExtractorGDBRemote &packet) {
-
-  // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(Status("Process not running."));
 
   packet.ConsumeFront("jLLDBTraceGetBinaryData:");
   llvm::Expected<TraceGetBinaryDataRequest> request =
       llvm::json::parse<TraceGetBinaryDataRequest>(packet.Peek(),
                                                    "TraceGetBinaryDataRequest");
   if (!request)
     return SendErrorResponse(Status(request.takeError()));
 
   if (Expected<std::vector<uint8_t>> bytes =
-          m_debugged_process_up->TraceGetBinaryData(*request)) {
+          process->TraceGetBinaryData(*request)) {
     StreamGDBRemote response;
     response.PutEscapedBytes(bytes->data(), bytes->size());
     return SendPacketNoLock(response.GetString());
   } else
     return SendErrorResponse(bytes.takeError());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo(
     StringExtractorGDBRemote &packet) {
-  // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(68);
 
-  lldb::pid_t pid = m_debugged_process_up->GetID();
+  lldb::pid_t pid = process->GetID();
 
   if (pid == LLDB_INVALID_PROCESS_ID)
     return SendErrorResponse(1);
 
   ProcessInstanceInfo proc_info;
   if (!Host::GetProcessInfo(pid, proc_info))
     return SendErrorResponse(1);
 
   StreamString response;
   CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) {
-  // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(68);
 
   // Make sure we set the current thread so g and p packets return the data the
   // gdb will expect.
-  lldb::tid_t tid = m_debugged_process_up->GetCurrentThreadID();
+  lldb::tid_t tid = process->GetCurrentThreadID();
   SetCurrentThreadID(tid);
 
-  NativeThreadProtocol *thread = m_debugged_process_up->GetCurrentThread();
+  NativeThreadProtocol *thread = process->GetCurrentThread();
   if (!thread)
     return SendErrorResponse(69);
 
   StreamString response;
   response.Printf("QC%" PRIx64, thread->GetID());
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   StopSTDIOForwarding();
 
-  if (!m_debugged_process_up) {
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
     LLDB_LOG(log, "No debugged process found.");
     return PacketResult::Success;
   }
 
-  Status error = m_debugged_process_up->Kill();
+  Status error = process->Kill();
   if (error.Fail())
-    LLDB_LOG(log, "Failed to kill debugged process {0}: {1}",
-             m_debugged_process_up->GetID(), error);
+    LLDB_LOG(log, "Failed to kill debugged process {0}: {1}", process->GetID(),
+             error);
 
   // No OK response for kill packet.
   // return SendOKResponse ();
   return PacketResult::Success;
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR(
GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir(
   return SendErrorResponse(14);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_C(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
   LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
 
-  // Ensure we have a native process.
-  if (!m_debugged_process_up) {
+  auto *process = GetCurrentProcess(true);
+  if (!process) {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s no debugged process "
               "shared pointer",
               __FUNCTION__);
     return SendErrorResponse(0x36);
   }
 
   // Pull out the signal number.
ResumeAction action = {GetContinueThreadID(), StateType::eStateRunning,
                            static_cast<int>(signo)};
 
     // Add the action for the continue thread (or all threads when the continue
     // thread isn't present).
     resume_actions.Append(action);
   } else {
     // Send the signal to the process since we weren't targeting a specific
     // continue thread with the signal.
-    error = m_debugged_process_up->Signal(signo);
+    error = process->Signal(signo);
     if (error.Fail()) {
       LLDB_LOG(log, "failed to send signal for process {0}: {1}",
-               m_debugged_process_up->GetID(), error);
+               process->GetID(), error);
 
       return SendErrorResponse(0x52);
     }
   }
 
   // Resume the threads.
-  error = m_debugged_process_up->Resume(resume_actions);
+  error = process->Resume(resume_actions);
   if (error.Fail()) {
     LLDB_LOG(log, "failed to resume threads for process {0}: {1}",
-             m_debugged_process_up->GetID(), error);
+             process->GetID(), error);
 
     return SendErrorResponse(0x38);
   }
 
   // Don't send an "OK" packet; response is the stopped/exited message.
   return PacketResult::Success;
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_c(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
   LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
 
   packet.SetFilePos(packet.GetFilePos() + ::strlen("c"));
 
   // For now just support all continue.
   const bool has_continue_address = (packet.GetBytesLeft() > 0);
   if (has_continue_address) {
     LLDB_LOG(log, "not implemented for c[address] variant [{0} remains]",
              packet.Peek());
     return SendUnimplementedResponse(packet.GetStringRef().data());
   }
 
   // Ensure we have a native process.
-  if (!m_debugged_process_up) {
+  auto *process = GetCurrentProcess(true);
+  if (!process) {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s no debugged process "
               "shared pointer",
               __FUNCTION__);
     return SendErrorResponse(0x36);
   }
 
   // Build the ResumeActionList
   ResumeActionList actions(StateType::eStateRunning,
                            LLDB_INVALID_SIGNAL_NUMBER);
 
-  Status error = m_debugged_process_up->Resume(actions);
+  Status error = process->Resume(actions);
   if (error.Fail()) {
-    LLDB_LOG(log, "c failed for process {0}: {1}",
-             m_debugged_process_up->GetID(), error);
+    LLDB_LOG(log, "c failed for process {0}: {1}", process->GetID(), error);
     return SendErrorResponse(GDBRemoteServerError::eErrorResume);
   }
 
-  LLDB_LOG(log, "continued process {0}", m_debugged_process_up->GetID());
+  LLDB_LOG(log, "continued process {0}", process->GetID());
   // No response required from continue.
   return PacketResult::Success;
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_vCont_actions(
     StringExtractorGDBRemote &packet) {
   StreamString response;
if (::strcmp(packet.Peek(), ";c") == 0) {
     return Handle_c(packet);
   } else if (::strcmp(packet.Peek(), ";s") == 0) {
     // Move past the ';', then do a simple 's'.
     packet.SetFilePos(packet.GetFilePos() + 1);
     return Handle_s(packet);
   }
 
   // Ensure we have a native process.
-  if (!m_debugged_process_up) {
+  auto *process = GetCurrentProcess(true);
+  if (!process) {
     LLDB_LOG(log, "no debugged process");
     return SendErrorResponse(0x36);
   }
 
   ResumeActionList thread_actions;
 
   while (packet.GetBytesLeft() && *packet.Peek() == ';') {
     // Skip the semi-colon.
default:
       break;
     }
 
     // Parse out optional :{thread-id} value.
     if (packet.GetBytesLeft() && (*packet.Peek() == ':')) {
       // Consume the separator.
       packet.GetChar();
 
-      llvm::Expected<lldb::tid_t> tid_ret = ReadTid(packet, /*allow_all=*/true);
+      llvm::Expected<lldb::tid_t> tid_ret = ReadTid(packet, /*run=*/true,
+                                                    /*allow_all=*/true);
       if (!tid_ret)
         return SendErrorResponse(tid_ret.takeError());
 
       thread_action.tid = tid_ret.get();
       if (thread_action.tid == StringExtractorGDBRemote::AllThreads)
         thread_action.tid = LLDB_INVALID_THREAD_ID;
     }
 
     thread_actions.Append(thread_action);
   }
 
-  Status error = m_debugged_process_up->Resume(thread_actions);
+  Status error = process->Resume(thread_actions);
   if (error.Fail()) {
-    LLDB_LOG(log, "vCont failed for process {0}: {1}",
-             m_debugged_process_up->GetID(), error);
+    LLDB_LOG(log, "vCont failed for process {0}: {1}", process->GetID(), error);
     return SendErrorResponse(GDBRemoteServerError::eErrorResume);
   }
 
-  LLDB_LOG(log, "continued process {0}", m_debugged_process_up->GetID());
+  LLDB_LOG(log, "continued process {0}", process->GetID());
   // No response required from vCont.
   return PacketResult::Success;
 }
 
 void GDBRemoteCommunicationServerLLGS::SetCurrentThreadID(lldb::tid_t tid) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
   LLDB_LOG(log, "setting current thread id to {0}", tid);
 

 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_stop_reason(
     StringExtractorGDBRemote &packet) {
   // Handle the $? gdbremote command.
 
   // If no process, indicate error
-  if (!m_debugged_process_up)
+  auto *process = GetCurrentProcess(true);
+  if (!process)
     return SendErrorResponse(02);
 
-  return SendStopReasonForState(m_debugged_process_up->GetState());
+  return SendStopReasonForState(process->GetState());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::SendStopReasonForState(
     lldb::StateType process_state) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   switch (process_state) {
GDBRemoteCommunicationServerLLGS::SendStopReasonForState(
   }
 
   return SendErrorResponse(0);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo(
     StringExtractorGDBRemote &packet) {
-  // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(68);
 
   // Ensure we have a thread.
-  NativeThreadProtocol *thread = m_debugged_process_up->GetThreadAtIndex(0);
+  NativeThreadProtocol *thread = process->GetThreadAtIndex(0);
   if (!thread)
     return SendErrorResponse(69);
 
   // Get the register context for the first thread.
   NativeRegisterContext &reg_context = thread->GetRegisterContext();
 
   // Parse out the register number from the request.
   packet.SetFilePos(strlen("qRegisterInfo"));
GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo(
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo(
     StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
-  // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
-    LLDB_LOG(log, "no process ({0}), returning OK",
-             m_debugged_process_up ? "invalid process id"
-                                   : "null m_debugged_process_up");
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
+    LLDB_LOG(log, "no process, returning OK");
     return SendOKResponse();
   }
 
   StreamGDBRemote response;
   response.PutChar('m');
 
   LLDB_LOG(log, "starting thread iteration");
   NativeThreadProtocol *thread;
   uint32_t thread_index;
   for (thread_index = 0,
-      thread = m_debugged_process_up->GetThreadAtIndex(thread_index);
+      thread = process->GetThreadAtIndex(thread_index);
        thread; ++thread_index,
-      thread = m_debugged_process_up->GetThreadAtIndex(thread_index)) {
+      thread = process->GetThreadAtIndex(thread_index)) {
     LLDB_LOG(log, "iterated thread {0}(tid={2})", thread_index,
              thread->GetID());
     if (thread_index > 0)
       response.PutChar(',');
     response.Printf("%" PRIx64, thread->GetID());
   }
 
   LLDB_LOG(log, "finished thread iteration");
LLDB_LOGF(
         log,
         "GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c",
         __FUNCTION__, h_variant);
     return SendIllFormedResponse(packet,
                                  "H variant unsupported, should be c or g");
   }
 
   // Parse out the thread number.
-  llvm::Expected<lldb::tid_t> tid_ret = ReadTid(packet, /*allow_all=*/true);
+  llvm::Expected<lldb::tid_t> tid_ret =
+      ReadTid(packet, /*run=*/h_variant == 'c', /*allow_all=*/true);
   if (!tid_ret)
     return SendErrorResponse(tid_ret.takeError());
 
   lldb::tid_t tid = tid_ret.get();
   // Ensure we have the given thread when not specifying -1 (all threads) or 0
   // (any thread).
   if (tid != LLDB_INVALID_THREAD_ID && tid != 0) {
     NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
GDBRemoteCommunicationServerLLGS::Handle_H(StringExtractorGDBRemote &packet) {
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_I(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
   // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  if (!GetCurrentProcess(false)) {
     LLDB_LOGF(
         log,
         "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
         __FUNCTION__);
     return SendErrorResponse(0x15);
   }
 
   packet.SetFilePos(::strlen("I"));

 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_interrupt(
     StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
 
   // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(true);
+  if (!process) {
     LLDB_LOG(log, "failed, no process available");
     return SendErrorResponse(0x15);
   }
 
   // Interrupt the process.
-  Status error = m_debugged_process_up->Interrupt();
+  Status error = process->Interrupt();
   if (error.Fail()) {
-    LLDB_LOG(log, "failed for process {0}: {1}", m_debugged_process_up->GetID(),
-             error);
+    LLDB_LOG(log, "failed for process {0}: {1}", process->GetID(), error);
     return SendErrorResponse(GDBRemoteServerError::eErrorResume);
   }
 
-  LLDB_LOG(log, "stopped process {0}", m_debugged_process_up->GetID());
+  LLDB_LOG(log, "stopped process {0}", process->GetID());
 
   // No response required from stop all.
   return PacketResult::Success;
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_memory_read(
     StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
     LLDB_LOGF(
         log,
         "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
         __FUNCTION__);
     return SendErrorResponse(0x15);
   }
 
   // Parse out the memory address.
GDBRemoteCommunicationServerLLGS::Handle_memory_read(
 
   // Allocate the response buffer.
   std::string buf(byte_count, '\0');
   if (buf.empty())
     return SendErrorResponse(0x78);
 
   // Retrieve the process memory.
   size_t bytes_read = 0;
-  Status error = m_debugged_process_up->ReadMemoryWithoutTrap(
+  Status error = process->ReadMemoryWithoutTrap(
       read_addr, &buf[0], byte_count, bytes_read);
   if (error.Fail()) {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
               " mem 0x%" PRIx64 ": failed to read. Error: %s",
-              __FUNCTION__, m_debugged_process_up->GetID(), read_addr,
-              error.AsCString());
+              __FUNCTION__, process->GetID(), read_addr, error.AsCString());
     return SendErrorResponse(0x08);
   }
 
   if (bytes_read == 0) {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
               " mem 0x%" PRIx64 ": read 0 of %" PRIu64 " requested bytes",
-              __FUNCTION__, m_debugged_process_up->GetID(), read_addr,
-              byte_count);
+              __FUNCTION__, process->GetID(), read_addr, byte_count);
     return SendErrorResponse(0x08);
   }
 
   StreamGDBRemote response;
   packet.SetFilePos(0);
   char kind = packet.GetChar('?');
   if (kind == 'x')
     response.PutEscapedBytes(buf.data(), byte_count);
   else {
     assert(kind == 'm');
     for (size_t i = 0; i < bytes_read; ++i)
       response.PutHex8(buf[i]);
   }
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle__M(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
     LLDB_LOGF(
         log,
         "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
         __FUNCTION__);
     return SendErrorResponse(0x15);
   }
 
   // Parse out the memory address.
while (packet.GetBytesLeft() > 0) {
     case 'x':
       perms |= ePermissionsExecutable;
       break;
     default:
       return SendIllFormedResponse(packet, "Bad permissions");
     }
   }
 
-  llvm::Expected<addr_t> addr =
-      m_debugged_process_up->AllocateMemory(size, perms);
+  llvm::Expected<addr_t> addr = process->AllocateMemory(size, perms);
   if (!addr)
     return SendErrorResponse(addr.takeError());
 
   StreamGDBRemote response;
   response.PutHex64(*addr);
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle__m(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
     LLDB_LOGF(
         log,
         "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
         __FUNCTION__);
     return SendErrorResponse(0x15);
   }
 
   // Parse out the memory address.
   packet.SetFilePos(strlen("_m"));
   if (packet.GetBytesLeft() < 1)
     return SendIllFormedResponse(packet, "Too short m packet");
 
   const lldb::addr_t addr = packet.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
   if (addr == LLDB_INVALID_ADDRESS)
     return SendIllFormedResponse(packet, "Address not valid");
 
-  if (llvm::Error Err = m_debugged_process_up->DeallocateMemory(addr))
+  if (llvm::Error Err = process->DeallocateMemory(addr))
     return SendErrorResponse(std::move(Err));
 
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_M(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
     LLDB_LOGF(
         log,
         "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
         __FUNCTION__);
     return SendErrorResponse(0x15);
   }
 
   // Parse out the memory address.
GDBRemoteCommunicationServerLLGS::Handle_M(StringExtractorGDBRemote &packet) {
 
   // Convert the hex memory write contents to bytes.
   StreamGDBRemote response;
   const uint64_t convert_count = packet.GetHexBytes(buf, 0);
   if (convert_count != byte_count) {
     LLDB_LOG(log,
              "pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} "
              "to convert.",
-             m_debugged_process_up->GetID(), write_addr, byte_count,
-             convert_count);
+             process->GetID(), write_addr, byte_count, convert_count);
     return SendIllFormedResponse(packet, "M content byte length specified did "
                                          "not match hex-encoded content "
                                          "length");
   }
 
   // Write the process memory.
   size_t bytes_written = 0;
-  Status error = m_debugged_process_up->WriteMemory(write_addr, &buf[0],
-                                                    byte_count, bytes_written);
+  Status error =
+      process->WriteMemory(write_addr, &buf[0], byte_count, bytes_written);
   if (error.Fail()) {
     LLDB_LOG(log, "pid {0} mem {1:x}: failed to write. Error: {2}",
-             m_debugged_process_up->GetID(), write_addr, error);
+             process->GetID(), write_addr, error);
     return SendErrorResponse(0x09);
   }
 
   if (bytes_written == 0) {
     LLDB_LOG(log, "pid {0} mem {1:x}: wrote 0 of {2} requested bytes",
-             m_debugged_process_up->GetID(), write_addr, byte_count);
+             process->GetID(), write_addr, byte_count);
     return SendErrorResponse(0x09);
   }
 
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported(
     StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   // Currently only the NativeProcessProtocol knows if it can handle a
   // qMemoryRegionInfoSupported request, but we're not guaranteed to be
   // attached to a process.  For now we'll assume the client only asks this
   // when a process is being debugged.
 
   // Ensure we have a process running; otherwise, we can't figure this out
   // since we won't have a NativeProcessProtocol.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
     LLDB_LOGF(
         log,
         "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
         __FUNCTION__);
     return SendErrorResponse(0x15);
   }
 
   // Test if we can get any region back when asking for the region around NULL.
   MemoryRegionInfo region_info;
-  const Status error =
-      m_debugged_process_up->GetMemoryRegionInfo(0, region_info);
+  const Status error = process->GetMemoryRegionInfo(0, region_info);
   if (error.Fail()) {
     // We don't support memory region info collection for this
     // NativeProcessProtocol.
     return SendUnimplementedResponse("");
   }
 
   return SendOKResponse();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo(
     StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   // Ensure we have a process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
     LLDB_LOGF(
         log,
         "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
         __FUNCTION__);
     return SendErrorResponse(0x15);
   }
 
   // Parse out the memory address.
   packet.SetFilePos(strlen("qMemoryRegionInfo:"));
   if (packet.GetBytesLeft() < 1)
     return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet");
 
   // Read the address.  Punting on validation.
   const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);
 
   StreamGDBRemote response;
 
   // Get the memory region info for the target address.
   MemoryRegionInfo region_info;
-  const Status error =
-      m_debugged_process_up->GetMemoryRegionInfo(read_addr, region_info);
+  const Status error = process->GetMemoryRegionInfo(read_addr, region_info);
   if (error.Fail()) {
     // Return the error message.
 
     response.PutCString("error:");
     response.PutStringAsRawHex8(error.AsCString());
     response.PutChar(';');
   } else {
     // Range start and size.
GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo(
   }
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_Z(StringExtractorGDBRemote &packet) {
   // Ensure we have a process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
     LLDB_LOG(log, "failed, no process available");
     return SendErrorResponse(0x15);
   }
 
   // Parse out software or hardware breakpoint or watchpoint requested.
   packet.SetFilePos(strlen("Z"));
   if (packet.GetBytesLeft() < 1)
GDBRemoteCommunicationServerLLGS::Handle_Z(StringExtractorGDBRemote &packet) {
   const uint32_t size =
       packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
   if (size == std::numeric_limits<uint32_t>::max())
     return SendIllFormedResponse(
         packet, "Malformed Z packet, failed to parse size argument");
 
   if (want_breakpoint) {
     // Try to set the breakpoint.
-    const Status error =
-        m_debugged_process_up->SetBreakpoint(addr, size, want_hardware);
+    const Status error = process->SetBreakpoint(addr, size, want_hardware);
     if (error.Success())
       return SendOKResponse();
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
-    LLDB_LOG(log, "pid {0} failed to set breakpoint: {1}",
-             m_debugged_process_up->GetID(), error);
+    LLDB_LOG(log, "pid {0} failed to set breakpoint: {1}", process->GetID(),
+             error);
     return SendErrorResponse(0x09);
   } else {
     // Try to set the watchpoint.
-    const Status error = m_debugged_process_up->SetWatchpoint(
+    const Status error = process->SetWatchpoint(
         addr, size, watch_flags, want_hardware);
     if (error.Success())
       return SendOKResponse();
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
-    LLDB_LOG(log, "pid {0} failed to set watchpoint: {1}",
-             m_debugged_process_up->GetID(), error);
+    LLDB_LOG(log, "pid {0} failed to set watchpoint: {1}", process->GetID(),
+             error);
     return SendErrorResponse(0x09);
   }
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) {
   // Ensure we have a process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
     LLDB_LOG(log, "failed, no process available");
     return SendErrorResponse(0x15);
   }
 
   // Parse out software or hardware breakpoint or watchpoint requested.
   packet.SetFilePos(strlen("z"));
   if (packet.GetBytesLeft() < 1)
GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) {
   std::numeric_limits<uint32_t>::max ());
   if (size == std::numeric_limits<uint32_t>::max ())
       return SendIllFormedResponse(packet, "Malformed z packet, failed to parse
   size argument");
   */
 
   if (want_breakpoint) {
     // Try to clear the breakpoint.
-    const Status error =
-        m_debugged_process_up->RemoveBreakpoint(addr, want_hardware);
+    const Status error = process->RemoveBreakpoint(addr, want_hardware);
     if (error.Success())
       return SendOKResponse();
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
-    LLDB_LOG(log, "pid {0} failed to remove breakpoint: {1}",
-             m_debugged_process_up->GetID(), error);
+    LLDB_LOG(log, "pid {0} failed to remove breakpoint: {1}", process->GetID(),
+             error);
     return SendErrorResponse(0x09);
   } else {
     // Try to clear the watchpoint.
-    const Status error = m_debugged_process_up->RemoveWatchpoint(addr);
+    const Status error = process->RemoveWatchpoint(addr);
     if (error.Success())
       return SendOKResponse();
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
-    LLDB_LOG(log, "pid {0} failed to remove watchpoint: {1}",
-             m_debugged_process_up->GetID(), error);
+    LLDB_LOG(log, "pid {0} failed to remove watchpoint: {1}", process->GetID(),
+             error);
     return SendErrorResponse(0x09);
   }
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_s(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
 
   // Ensure we have a process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(true);
+  if (!process) {
     LLDB_LOGF(
         log,
         "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
         __FUNCTION__);
     return SendErrorResponse(0x32);
   }
 
   // We first try to use a continue thread id.  If any one or any all set, use
   // the current thread. Bail out if we don't have a thread id.
   lldb::tid_t tid = GetContinueThreadID();
   if (tid == 0 || tid == LLDB_INVALID_THREAD_ID)
     tid = GetCurrentThreadID();
   if (tid == LLDB_INVALID_THREAD_ID)
     return SendErrorResponse(0x33);
 
   // Double check that we have such a thread.
   // TODO investigate: on MacOSX we might need to do an UpdateThreads () here.
-  NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
+  NativeThreadProtocol *thread = process->GetThreadByID(tid);
   if (!thread)
     return SendErrorResponse(0x33);
 
   // Create the step action for the given thread.
   ResumeAction action = {tid, eStateStepping, LLDB_INVALID_SIGNAL_NUMBER};
 
   // Setup the actions list.
   ResumeActionList actions;
   actions.Append(action);
 
   // All other threads stop while we're single stepping a thread.
   actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0);
-  Status error = m_debugged_process_up->Resume(actions);
+  Status error = process->Resume(actions);
   if (error.Fail()) {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
               " tid %" PRIu64 " Resume() failed with error: %s",
-              __FUNCTION__, m_debugged_process_up->GetID(), tid,
-              error.AsCString());
+              __FUNCTION__, process->GetID(), tid, error.AsCString());
     return SendErrorResponse(0x49);
   }
 
   // No response here - the stop or exit will come from the resulting action.
   return PacketResult::Success;
 }
 
 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
GDBRemoteCommunicationServerLLGS::BuildTargetXml() {
   response.Printf("</target>");
   return MemoryBuffer::getMemBufferCopy(response.GetString(), "target.xml");
 }
 
 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
 GDBRemoteCommunicationServerLLGS::ReadXferObject(llvm::StringRef object,
                                                  llvm::StringRef annex) {
   // Make sure we have a valid process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
+  auto *process = GetCurrentProcess(false);
+  if (!process) {
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "No process available");
   }
 
   if (object == "auxv") {
     // Grab the auxv data.
-    auto buffer_or_error = m_debugged_process_up->GetAuxvData();
+    auto buffer_or_error = process->GetAuxvData();
     if (!buffer_or_error)
       return llvm::errorCodeToError(buffer_or_error.getError());
     return std::move(*buffer_or_error);
   }
 
   if (object == "libraries-svr4") {
-    auto library_list = m_debugged_process_up->GetLoadedSVR4Libraries();
+    auto library_list = process->GetLoadedSVR4Libraries();
     if (!library_list)
       return library_list.takeError();
 
     StreamString response;
     response.Printf("<library-list-svr4 version=\"1.0\">");
     for (auto const &library : *library_list) {
       response.Printf("<library name=\"%s\" ",
                       XMLEncodeAttributeValue(library.name.c_str()).c_str());

 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo(
     StringExtractorGDBRemote &) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
 
   // Ensure we have a debugged process.
-  if (!m_debugged_process_up ||
-      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(50);
-  LLDB_LOG(log, "preparing packet for pid {0}", m_debugged_process_up->GetID());
+  LLDB_LOG(log, "preparing packet for pid {0}", process->GetID());
 
   StreamString response;
   const bool threads_with_valid_stop_info_only = false;
   llvm::Expected<json::Value> threads_info = GetJSONThreadsInfo(
-      *m_debugged_process_up, threads_with_valid_stop_info_only);
+      *process, threads_with_valid_stop_info_only);
   if (!threads_info) {
     LLDB_LOG_ERROR(log, threads_info.takeError(),
                    "failed to prepare a packet for pid {1}: {0}",
-                   m_debugged_process_up->GetID());
+                   process->GetID());
     return SendErrorResponse(52);
   }
 
   response.AsRawOstream() << *threads_info;
   StreamGDBRemote escaped_response;
   escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
   return SendPacketNoLock(escaped_response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo(
     StringExtractorGDBRemote &packet) {
   // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(68);
 
   packet.SetFilePos(strlen("qWatchpointSupportInfo"));
   if (packet.GetBytesLeft() == 0)
     return SendOKResponse();
   if (packet.GetChar() != ':')
     return SendErrorResponse(67);
 
-  auto hw_debug_cap = m_debugged_process_up->GetHardwareDebugSupportInfo();
+  auto hw_debug_cap = process->GetHardwareDebugSupportInfo();
 
   StreamGDBRemote response;
   if (hw_debug_cap == llvm::None)
     response.Printf("num:0;");
   else
     response.Printf("num:%d;", hw_debug_cap->second);
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress(
     StringExtractorGDBRemote &packet) {
   // Fail if we don't have a current process.
-  if (!m_debugged_process_up ||
-      m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(67);
 
   packet.SetFilePos(strlen("qFileLoadAddress:"));
   if (packet.GetBytesLeft() == 0)
     return SendErrorResponse(68);
 
   std::string file_name;
   packet.GetHexByteString(file_name);
 
   lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS;
-  Status error =
-      m_debugged_process_up->GetFileLoadAddress(file_name, file_load_address);
+  Status error = process->GetFileLoadAddress(file_name, file_load_address);
   if (error.Fail())
     return SendErrorResponse(69);
 
   if (file_load_address == LLDB_INVALID_ADDRESS)
     return SendErrorResponse(1); // File not loaded
 
   StreamGDBRemote response;
   response.PutHex64(file_load_address);
while (packet.GetBytesLeft() > 0) {
     if (separator == '\0')
       break; // End of string
     if (separator != ';')
       return SendIllFormedResponse(packet, "Invalid separator,"
                                             " expected semicolon.");
   }
 
   // Fail if we don't have a current process.
-  if (!m_debugged_process_up)
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return SendErrorResponse(68);
 
-  Status error = m_debugged_process_up->IgnoreSignals(signals);
+  Status error = process->IgnoreSignals(signals);
   if (error.Fail())
     return SendErrorResponse(69);
 
   return SendOKResponse();
 }
 
 void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
if (connection) {
       }
     }
   }
 }
 
 NativeThreadProtocol *GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix(
     StringExtractorGDBRemote &packet) {
   // We have no thread if we don't have a process.
-  if (!m_debugged_process_up ||
-      m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)
+  auto *process = GetCurrentProcess(false);
+  if (!process)
     return nullptr;
 
   // If the client hasn't asked for thread suffix support, there will not be a
   // thread suffix. Use the current thread in that case.
   if (!m_thread_suffix_supported) {
     const lldb::tid_t current_tid = GetCurrentThreadID();
     if (current_tid == LLDB_INVALID_THREAD_ID)
       return nullptr;
     else if (current_tid == 0) {
       // Pick a thread.
-      return m_debugged_process_up->GetThreadAtIndex(0);
+      return process->GetThreadAtIndex(0);
     } else
-      return m_debugged_process_up->GetThreadByID(current_tid);
+      return process->GetThreadByID(current_tid);
   }
 
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
   // Parse out the ';'.
   if (packet.GetBytesLeft() < 1 || packet.GetChar() != ';') {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s gdb-remote parse "
LLDB_LOGF(log,
               "error: expected 'thread:' but not found, packet contents = "
               "'%s'",
               __FUNCTION__, packet.GetStringRef().data());
     return nullptr;
   }
   packet.SetFilePos(packet.GetFilePos() + strlen("thread:"));
   const lldb::tid_t tid = packet.GetHexMaxU64(false, 0);
   if (tid != 0)
-    return m_debugged_process_up->GetThreadByID(tid);
+    return process->GetThreadByID(tid);
 
   return nullptr;
 }
 
 lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const {
   if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) {
     // Use whatever the debug process says is the current thread id since the
     // protocol either didn't specify or specified we want any/all threads
     // marked as the current thread.
-    if (!m_debugged_process_up)
+    auto *process = GetCurrentProcess(false);
+    if (!process)
       return LLDB_INVALID_THREAD_ID;
-    return m_debugged_process_up->GetCurrentThreadID();
+    return process->GetCurrentThreadID();
   }
   // Use the specific current thread id set by the gdb remote protocol.
   return m_current_tid;
 }
 
 uint32_t GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID() {
   std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
   return m_next_saved_registers_id++;
 }
 
 void GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   LLDB_LOG(log, "clearing {0} xfer buffers", m_xfer_buffer_map.size());
   m_xfer_buffer_map.clear();
 }
 
 FileSpec
 GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path,
                                                  const ArchSpec &arch) {
-  if (m_debugged_process_up) {
+  auto *process = GetCurrentProcess(false);
+  if (process) {
     FileSpec file_spec;
-    if (m_debugged_process_up
-            ->GetLoadedModuleFileSpec(module_path.c_str(), file_spec)
+    if (process->GetLoadedModuleFileSpec(module_path.c_str(), file_spec)
             .Success()) {
       if (FileSystem::Instance().Exists(file_spec))
         return file_spec;
     }
   }
 
   return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch);
 }
default:
       break;
     }
   }
   return result;
 }
 
 llvm::Expected<lldb::tid_t>
 GDBRemoteCommunicationServerLLGS::ReadTid(StringExtractorGDBRemote &packet,
-                                          bool allow_all) {
-  assert(m_debugged_process_up);
-  assert(m_debugged_process_up->GetID() != LLDB_INVALID_PROCESS_ID);
+                                          bool run, bool allow_all) {
+  auto *process = GetCurrentProcess(run);
+  assert(process);
+  assert(process->GetID() != LLDB_INVALID_PROCESS_ID);
 
-  auto pid_tid = packet.GetPidTid(m_debugged_process_up->GetID());
+  auto pid_tid = packet.GetPidTid(process->GetID());
   if (!pid_tid)
     return llvm::make_error<StringError>(inconvertibleErrorCode(),
                                          "Malformed thread-id");
 
   lldb::pid_t pid = pid_tid->first;
   lldb::tid_t tid = pid_tid->second;
 
   if (!allow_all && pid == StringExtractorGDBRemote::AllProcesses)
     return llvm::make_error<StringError>(
         inconvertibleErrorCode(),
         llvm::formatv("PID value {0} not allowed", pid == 0 ? 0 : -1));
 
   if (!allow_all && tid == StringExtractorGDBRemote::AllThreads)
     return llvm::make_error<StringError>(
         inconvertibleErrorCode(),
         llvm::formatv("TID value {0} not allowed", tid == 0 ? 0 : -1));
 
   if (pid != StringExtractorGDBRemote::AllProcesses) {
-    if (pid != m_debugged_process_up->GetID())
+    if (pid != process->GetID())
       return llvm::make_error<StringError>(
           inconvertibleErrorCode(), llvm::formatv("PID {0} not debugged", pid));
   }
 
   return tid;
 }
 
 std::vector<std::string> GDBRemoteCommunicationServerLLGS::HandleFeatures(
void GDBRemoteCommunicationServerLLGS::SetEnabledExtensions(
   if (m_vfork_events_supported)
     flags |= NativeProcessProtocol::Extension::vfork;
 
   llvm::Error error = process.SetEnabledExtensions(flags);
   if (error)
     LLDB_LOG_ERROR(log, std::move(error),
                    "Enabling protocol extensions failed: {0}");
 }
+
+NativeProcessProtocol *
+GDBRemoteCommunicationServerLLGS::GetCurrentProcess(bool run) const {
+  // Fail if we don't have a current process.
+  if (!m_debugged_process_up ||
+      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
+    return nullptr;
+
+  return m_debugged_process_up.get();
+}