[lldb] Remove non-stop mode code

[labath]

Summary

We added some support for this mode back in 2015, but the feature was
never productionized. It is completely untested, and there are known
major structural lldb issues that need to be resolved before this
feature can really be supported.

It also complicates making further changes to stop reply packet
handling, which is what I am about to do.

[jingham]

I don't think this patch added all that much value, and pretty much only worked if the non-stop threads never stopped... I think we'd have to start deeper in lldb to if we really want to support having threads that might stop while we think the process is stopped, and carrying this forward isn't going to help that effort when we get around to it.

So I have no problem with removing this.

[krytarowski]

NetBSD and FreeBSD do not support non-stop in the kernel.

lldb/include/lldb/Target/Target.h

public:
   Disassembler::HexImmediateStyle GetHexImmediateStyle() const;
 
   MemoryModuleLoadLevel GetMemoryModuleLoadLevel() const;
 
   bool GetUserSpecifiedTrapHandlerNames(Args &args) const;
 
   void SetUserSpecifiedTrapHandlerNames(const Args &args);
 
-  bool GetNonStopModeEnabled() const;
-
-  void SetNonStopModeEnabled(bool b);
-
   bool GetDisplayRuntimeSupportValues() const;
 
   void SetDisplayRuntimeSupportValues(bool b);
 
   bool GetDisplayRecognizedArguments() const;
 
   void SetDisplayRecognizedArguments(bool b);
 

lldb/source/Commands/CommandObjectThread.cpp

public:
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_step_in_avoid_no_debug = eLazyBoolCalculate;
     m_step_out_avoid_no_debug = eLazyBoolCalculate;
     m_run_mode = eOnlyDuringStepping;
 
     // Check if we are in Non-Stop mode
     TargetSP target_sp =
         execution_context ? execution_context->GetTargetSP() : TargetSP();
-    if (target_sp && target_sp->GetNonStopModeEnabled()) {
-      // NonStopMode runs all threads by definition, so when it is on we don't
-      // need to check the process setting for runs all threads.
-      m_run_mode = eOnlyThisThread;
-    } else {
-      ProcessSP process_sp =
-          execution_context ? execution_context->GetProcessSP() : ProcessSP();
-      if (process_sp && process_sp->GetSteppingRunsAllThreads())
-        m_run_mode = eAllThreads;
-    }
 
     m_avoid_regexp.clear();
     m_step_in_target.clear();
     m_step_count = 1;
     m_end_line = LLDB_INVALID_LINE_NUMBER;
     m_end_line_is_block_end = false;
   }
 

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

PacketResult SendPacketAndWaitForResponse(
       llvm::StringRef payload, StringExtractorGDBRemote &response,
       std::chrono::seconds interrupt_timeout = std::chrono::seconds(0));
 
   PacketResult SendPacketAndReceiveResponseWithOutputSupport(
       llvm::StringRef payload, StringExtractorGDBRemote &response,
       std::chrono::seconds interrupt_timeout,
       llvm::function_ref<void(llvm::StringRef)> output_callback);
 
-  bool SendvContPacket(llvm::StringRef payload,
-                       std::chrono::seconds interrupt_timeout,
-                       StringExtractorGDBRemote &response);
-
   class Lock {
   public:
     // If interrupt_timeout == 0 seconds, only take the lock if the target is
     // not running. If using this option, use the fact that the
     // interrupt_timeout is defaulted so it will be obvious at the call site
     // that you are choosing this mode. If it is non-zero, interrupt the target
     // if it is running, waiting for the given timeout for the interrupt to
     // succeed.

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

LLDB_LOGF(
         int(payload.size()), payload.data(), response.GetStringRef().data(),
         (i == (max_response_retries - 1))
             ? "using invalid response and giving up"
             : "ignoring response and waiting for another");
   }
   return packet_result;
 }
 
-bool GDBRemoteClientBase::SendvContPacket(
-    llvm::StringRef payload, std::chrono::seconds interrupt_timeout,
-    StringExtractorGDBRemote &response) {
-  Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
-  LLDB_LOGF(log, "GDBRemoteCommunicationClient::%s ()", __FUNCTION__);
-
-  // we want to lock down packet sending while we continue
-  Lock lock(*this, interrupt_timeout);
-
-  LLDB_LOGF(log,
-            "GDBRemoteCommunicationClient::%s () sending vCont packet: %.*s",
-            __FUNCTION__, int(payload.size()), payload.data());
-
-  if (SendPacketNoLock(payload) != PacketResult::Success)
-    return false;
-
-  OnRunPacketSent(true);
-
-  // wait for the response to the vCont
-  if (ReadPacket(response, llvm::None, false) == PacketResult::Success) {
-    if (response.IsOKResponse())
-      return true;
-  }
-
-  return false;
-}
 bool GDBRemoteClientBase::ShouldStop(const UnixSignals &signals,
                                      StringExtractorGDBRemote &response) {
   std::lock_guard<std::mutex> lock(m_mutex);
 
   if (m_async_count == 0)
     return true; // We were not interrupted. The process stopped on its own.
 
   // Older debugserver stubs (before April 2016) can return two stop-reply

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

public:
 
   uint8_t SendGDBStoppointTypePacket(
       GDBStoppointType type, // Type of breakpoint or watchpoint
       bool insert,           // Insert or remove?
       lldb::addr_t addr,     // Address of breakpoint or watchpoint
       uint32_t length,       // Byte Size of breakpoint or watchpoint
       std::chrono::seconds interrupt_timeout); // Time to wait for an interrupt
 
-  bool SetNonStopMode(const bool enable);
-
   void TestPacketSpeed(const uint32_t num_packets, uint32_t max_send,
                        uint32_t max_recv, uint64_t recv_amount, bool json,
                        Stream &strm);
 
   // This packet is for testing the speed of the interface only. Both
   // the client and server need to support it, but this allows us to
   // measure the packet speed without any other work being done on the
   // other end and avoids any of that work affecting the packet send

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

if (m_supports_qGroupName) {
     } else {
       m_supports_qGroupName = false;
       return false;
     }
   }
   return false;
 }
 
-bool GDBRemoteCommunicationClient::SetNonStopMode(const bool enable) {
-  // Form non-stop packet request
-  char packet[32];
-  const int packet_len =
-      ::snprintf(packet, sizeof(packet), "QNonStop:%1d", (int)enable);
-  assert(packet_len < (int)sizeof(packet));
-  UNUSED_IF_ASSERT_DISABLED(packet_len);
-
-  StringExtractorGDBRemote response;
-  // Send to target
-  if (SendPacketAndWaitForResponse(packet, response) == PacketResult::Success)
-    if (response.IsOKResponse())
-      return true;
-
-  // Failed or not supported
-  return false;
-}
-
 static void MakeSpeedTestPacket(StreamString &packet, uint32_t send_size,
                                 uint32_t recv_size) {
   packet.Clear();
   packet.Printf("qSpeedTest:response_size:%i;data:", recv_size);
   uint32_t bytes_left = send_size;
   while (bytes_left > 0) {
     if (bytes_left >= 26) {
       packet.PutCString("abcdefghijklmnopqrstuvwxyz");

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

enum {
     eBroadcastBitAsyncContinue = (1 << 0),
     eBroadcastBitAsyncThreadShouldExit = (1 << 1),
     eBroadcastBitAsyncThreadDidExit = (1 << 2)
   };
 
   GDBRemoteCommunicationClient m_gdb_comm;
   GDBRemoteCommunicationReplayServer m_gdb_replay_server;
   std::atomic<lldb::pid_t> m_debugserver_pid;
-  std::vector<StringExtractorGDBRemote> m_stop_packet_stack; // The stop packet
-                                                             // stack replaces
-                                                             // the last stop
-                                                             // packet variable
+
+  llvm::Optional<StringExtractorGDBRemote> m_last_stop_packet;
   std::recursive_mutex m_last_stop_packet_mutex;
+
   GDBRemoteDynamicRegisterInfoSP m_register_info_sp;
   Broadcaster m_async_broadcaster;
   lldb::ListenerSP m_async_listener_sp;
   HostThread m_async_thread;
   std::recursive_mutex m_async_thread_state_mutex;
   typedef std::vector<lldb::tid_t> tid_collection;
   typedef std::vector<std::pair<lldb::tid_t, int>> tid_sig_collection;
   typedef std::map<lldb::addr_t, lldb::addr_t> MMapMap;

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

Status ProcessGDBRemote::DoConnectRemote(llvm::StringRef remote_url) {
   } else {
     // We have a valid process
     SetID(pid);
     GetThreadList();
     StringExtractorGDBRemote response;
     if (m_gdb_comm.GetStopReply(response)) {
       SetLastStopPacket(response);
 
-      // '?' Packets must be handled differently in non-stop mode
-      if (GetTarget().GetNonStopModeEnabled())
-        HandleStopReplySequence();
-
       Target &target = GetTarget();
       if (!target.GetArchitecture().IsValid()) {
         if (m_gdb_comm.GetProcessArchitecture().IsValid()) {
           target.SetArchitecture(m_gdb_comm.GetProcessArchitecture());
         } else {
           if (m_gdb_comm.GetHostArchitecture().IsValid()) {
             target.SetArchitecture(m_gdb_comm.GetHostArchitecture());
           }
if (error.Success()) {
                   error.AsCString());
         KillDebugserverProcess();
         return error;
       }
 
       StringExtractorGDBRemote response;
       if (m_gdb_comm.GetStopReply(response)) {
         SetLastStopPacket(response);
-        // '?' Packets must be handled differently in non-stop mode
-        if (GetTarget().GetNonStopModeEnabled())
-          HandleStopReplySequence();
 
         const ArchSpec &process_arch = m_gdb_comm.GetProcessArchitecture();
 
         if (process_arch.IsValid()) {
           GetTarget().MergeArchitecture(process_arch);
         } else {
           const ArchSpec &host_arch = m_gdb_comm.GetHostArchitecture();
           if (host_arch.IsValid())
Status ProcessGDBRemote::ConnectToDebugserver(llvm::StringRef connect_url) {
   }
 
   if (!m_gdb_comm.IsConnected()) {
     if (error.Success())
       error.SetErrorString("not connected to remote gdb server");
     return error;
   }
 
-  // Start the communications read thread so all incoming data can be parsed
-  // into packets and queued as they arrive.
-  if (GetTarget().GetNonStopModeEnabled())
-    m_gdb_comm.StartReadThread();
-
   // We always seem to be able to open a connection to a local port so we need
   // to make sure we can then send data to it. If we can't then we aren't
   // actually connected to anything, so try and do the handshake with the
   // remote GDB server and make sure that goes alright.
   if (!m_gdb_comm.HandshakeWithServer(&error)) {
     m_gdb_comm.Disconnect();
     if (error.Success())
       error.SetErrorString("not connected to remote gdb server");
     return error;
   }
 
-  // Send $QNonStop:1 packet on startup if required
-  if (GetTarget().GetNonStopModeEnabled())
-    GetTarget().SetNonStopModeEnabled(m_gdb_comm.SetNonStopMode(true));
-
   m_gdb_comm.GetEchoSupported();
   m_gdb_comm.GetThreadSuffixSupported();
   m_gdb_comm.GetListThreadsInStopReplySupported();
   m_gdb_comm.GetHostInfo();
   m_gdb_comm.GetVContSupported('c');
   m_gdb_comm.GetVAttachOrWaitSupported();
   m_gdb_comm.EnableErrorStringInPacket();
 
-  // Ask the remote server for the default thread id
-  if (GetTarget().GetNonStopModeEnabled())
-    m_gdb_comm.GetDefaultThreadId(m_initial_tid);
-
   size_t num_cmds = GetExtraStartupCommands().GetArgumentCount();
   for (size_t idx = 0; idx < num_cmds; idx++) {
     StringExtractorGDBRemote response;
     m_gdb_comm.SendPacketAndWaitForResponse(
         GetExtraStartupCommands().GetArgumentAtIndex(idx), response);
   }
   return error;
 }
listener_sp->StartListeningForEvents(
         &m_async_broadcaster,
         ProcessGDBRemote::eBroadcastBitAsyncThreadDidExit);
 
     const size_t num_threads = GetThreadList().GetSize();
 
     StreamString continue_packet;
     bool continue_packet_error = false;
     if (m_gdb_comm.HasAnyVContSupport()) {
-      if (!GetTarget().GetNonStopModeEnabled() &&
-          (m_continue_c_tids.size() == num_threads ||
-           (m_continue_c_tids.empty() && m_continue_C_tids.empty() &&
-            m_continue_s_tids.empty() && m_continue_S_tids.empty()))) {
+      if (m_continue_c_tids.size() == num_threads ||
+           m_continue_s_tids.empty() && m_continue_S_tids.empty())) {
         // All threads are continuing, just send a "c" packet
         continue_packet.PutCString("c");
       } else {
         continue_packet.PutCString("vCont");
 
         if (!m_continue_c_tids.empty()) {
           if (m_gdb_comm.GetVContSupported('c')) {
             for (tid_collection::const_iterator
if (continue_packet_error) {
         }
       }
 
       if (continue_packet_error && num_continue_s_tids > 0) {
         if (num_continue_s_tids == num_threads) {
           // All threads are resuming...
           m_gdb_comm.SetCurrentThreadForRun(-1);
 
-          // If in Non-Stop-Mode use vCont when stepping
-          if (GetTarget().GetNonStopModeEnabled()) {
-            if (m_gdb_comm.GetVContSupported('s'))
-              continue_packet.PutCString("vCont;s");
-            else
-              continue_packet.PutChar('s');
-          } else
-            continue_packet.PutChar('s');
 
           continue_packet_error = false;
         } else if (num_continue_c_tids == 0 && num_continue_C_tids == 0 &&
                    num_continue_s_tids == 1 && num_continue_S_tids == 0) {
           // Only one thread is stepping
           m_gdb_comm.SetCurrentThreadForRun(m_continue_s_tids.front());
           continue_packet.PutChar('s');
           continue_packet_error = false;
if (m_jthreadsinfo_sp) {
     // See if we can get the thread IDs from the current stop reply packets
     // that might contain a "threads" key/value pair
 
     // Lock the thread stack while we access it
     // Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex);
     std::unique_lock<std::recursive_mutex> stop_stack_lock(
         m_last_stop_packet_mutex, std::defer_lock);
     if (stop_stack_lock.try_lock()) {
-      // Get the number of stop packets on the stack
-      int nItems = m_stop_packet_stack.size();
-      // Iterate over them
-      for (int i = 0; i < nItems; i++) {
+      if (m_last_stop_packet) {
         // Get the thread stop info
-        StringExtractorGDBRemote &stop_info = m_stop_packet_stack[i];
+        StringExtractorGDBRemote &stop_info = *m_last_stop_packet;
         const std::string &stop_info_str =
             std::string(stop_info.GetStringRef());
 
         m_thread_pcs.clear();
         const size_t thread_pcs_pos = stop_info_str.find(";thread-pcs:");
         if (thread_pcs_pos != std::string::npos) {
           const size_t start = thread_pcs_pos + strlen(";thread-pcs:");
           const size_t end = stop_info_str.find(';', start);
void ProcessGDBRemote::RefreshStateAfterStop() {
   // We might set some stop info's so make sure the thread list is up to
   // date before we do that or we might overwrite what was computed here.
   UpdateThreadListIfNeeded();
 
   // Scope for the lock
   {
     // Lock the thread stack while we access it
     std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex);
-    // Get the number of stop packets on the stack
-    int nItems = m_stop_packet_stack.size();
-    // Iterate over them
-    for (int i = 0; i < nItems; i++) {
-      // Get the thread stop info
-      StringExtractorGDBRemote stop_info = m_stop_packet_stack[i];
-      // Process thread stop info
-      SetThreadStopInfo(stop_info);
-    }
-    // Clear the thread stop stack
-    m_stop_packet_stack.clear();
+    if (m_last_stop_packet)
+      SetThreadStopInfo(*m_last_stop_packet);
+    m_last_stop_packet.reset();
   }
 
   // If we have queried for a default thread id
   if (m_initial_tid != LLDB_INVALID_THREAD_ID) {
     m_thread_list.SetSelectedThreadByID(m_initial_tid);
     m_initial_tid = LLDB_INVALID_THREAD_ID;
   }
 
if (did_exec) {
     m_gdb_comm.ResetDiscoverableSettings(did_exec);
   }
 
   // Scope the lock
   {
     // Lock the thread stack while we access it
     std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex);
 
-    // We are are not using non-stop mode, there can only be one last stop
-    // reply packet, so clear the list.
-    if (!GetTarget().GetNonStopModeEnabled())
-      m_stop_packet_stack.clear();
-
-    // Add this stop packet to the stop packet stack This stack will get popped
-    // and examined when we switch to the Stopped state
-    m_stop_packet_stack.push_back(response);
+    m_last_stop_packet = response;
   }
 }
 
 void ProcessGDBRemote::SetUnixSignals(const UnixSignalsSP &signals_sp) {
   Process::SetUnixSignals(std::make_shared<GDBRemoteSignals>(signals_sp));
 }
 
 // Process Queries
if (process->m_async_listener_sp->GetEvent(event_sp, llvm::None)) {
                       "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
                       ") got eBroadcastBitAsyncContinue: %s",
                       __FUNCTION__, arg, process->GetID(), continue_cstr);
 
             if (::strstr(continue_cstr, "vAttach") == nullptr)
               process->SetPrivateState(eStateRunning);
             StringExtractorGDBRemote response;
 
-            // If in Non-Stop-Mode
-            if (process->GetTarget().GetNonStopModeEnabled()) {
-              // send the vCont packet
-              if (!process->GetGDBRemote().SendvContPacket(
-                      llvm::StringRef(continue_cstr, continue_cstr_len),
-                      process->GetInterruptTimeout(), response)) {
-                // Something went wrong
-                done = true;
-                break;
-              }
-            }
-            // If in All-Stop-Mode
-            else {
-              StateType stop_state =
-                  process->GetGDBRemote().SendContinuePacketAndWaitForResponse(
-                      *process, *process->GetUnixSignals(),
-                      llvm::StringRef(continue_cstr, continue_cstr_len),
-                      process->GetInterruptTimeout(),
-                      response);
+                    process->GetInterruptTimeout(), response);
 
-              // We need to immediately clear the thread ID list so we are sure
-              // to get a valid list of threads. The thread ID list might be
-              // contained within the "response", or the stop reply packet that
-              // caused the stop. So clear it now before we give the stop reply
-              // packet to the process using the
-              // process->SetLastStopPacket()...
-              process->ClearThreadIDList();
 
-              switch (stop_state) {
-              case eStateStopped:
-              case eStateCrashed:
-              case eStateSuspended:
-                process->SetLastStopPacket(response);
-                process->SetPrivateState(stop_state);
-                break;
 
-              case eStateExited: {
-                process->SetLastStopPacket(response);
-                process->ClearThreadIDList();
-                response.SetFilePos(1);
 
-                int exit_status = response.GetHexU8();
-                std::string desc_string;
-                if (response.GetBytesLeft() > 0 &&
-                    response.GetChar('-') == ';') {
-                  llvm::StringRef desc_str;
-                  llvm::StringRef desc_token;
-                  while (response.GetNameColonValue(desc_token, desc_str)) {
-                    if (desc_token != "description")
-                      continue;
-                    StringExtractor extractor(desc_str);
-                    extractor.GetHexByteString(desc_string);
-                  }
-                }
-                process->SetExitStatus(exit_status, desc_string.c_str());
-                done = true;
-                break;
-              }
-              case eStateInvalid: {
-                // Check to see if we were trying to attach and if we got back
-                // the "E87" error code from debugserver -- this indicates that
-                // the process is not debuggable.  Return a slightly more
-                // helpful error message about why the attach failed.
-                if (::strstr(continue_cstr, "vAttach") != nullptr &&
-                    response.GetError() == 0x87) {
-                  process->SetExitStatus(-1, "cannot attach to process due to "
-                                             "System Integrity Protection");
-                } else if (::strstr(continue_cstr, "vAttach") != nullptr &&
-                           response.GetStatus().Fail()) {
-                  process->SetExitStatus(-1, response.GetStatus().AsCString());
-                } else {
-                  process->SetExitStatus(-1, "lost connection");
-                }
-                done = true;
-                break;
-              }
+              if (response.GetBytesLeft() > 0 && response.GetChar('-') == ';') {
 
-              default:
-                process->SetPrivateState(stop_state);
-                break;
-              } // switch(stop_state)
-            }   // else // if in All-stop-mode
+            }   // switch(stop_state)
           }     // if (continue_packet)
         }       // case eBroadcastBitAsyncContinue
         break;
 
         case eBroadcastBitAsyncThreadShouldExit:
           LLDB_LOGF(log,
                     "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
                     ") got eBroadcastBitAsyncThreadShouldExit...",

lldb/source/Target/Target.cpp

bool TargetProperties::GetDisplayRecognizedArguments() const {
   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
 }
 
 void TargetProperties::SetDisplayRecognizedArguments(bool b) {
   const uint32_t idx = ePropertyDisplayRecognizedArguments;
   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 }
 
-bool TargetProperties::GetNonStopModeEnabled() const {
-  const uint32_t idx = ePropertyNonStopModeEnabled;
-  return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
-}
-
-void TargetProperties::SetNonStopModeEnabled(bool b) {
-  const uint32_t idx = ePropertyNonStopModeEnabled;
-  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
-}
-
 const ProcessLaunchInfo &TargetProperties::GetProcessLaunchInfo() const {
   return m_launch_info;
 }
 
 void TargetProperties::SetProcessLaunchInfo(
     const ProcessLaunchInfo &launch_info) {
   m_launch_info = launch_info;
   SetArg0(launch_info.GetArg0());

lldb/source/Target/TargetProperties.td

def TrapHandlerNames: Property<"trap-handler-names", "Array">,
     ElementType<"String">,
     Desc<"A list of trap handler function names, e.g. a common Unix user process one is _sigtramp.">;
   def DisplayRuntimeSupportValues: Property<"display-runtime-support-values", "Boolean">,
     DefaultFalse,
     Desc<"If true, LLDB will show variables that are meant to support the operation of a language's runtime support.">;
   def DisplayRecognizedArguments: Property<"display-recognized-arguments", "Boolean">,
     DefaultFalse,
     Desc<"Show recognized arguments in variable listings by default.">;
-  def NonStopModeEnabled: Property<"non-stop-mode", "Boolean">,
-    DefaultFalse,
-    Desc<"Disable lock-step debugging, instead control threads independently.">;
   def RequireHardwareBreakpoints: Property<"require-hardware-breakpoint", "Boolean">,
     DefaultFalse,
     Desc<"Require all breakpoints to be hardware breakpoints.">;
   def AutoInstallMainExecutable: Property<"auto-install-main-executable", "Boolean">,
     DefaultTrue,
     Desc<"Always install the main executable when connected to a remote platform.">;
   def DebugUtilityExpression: Property<"debug-utility-expression", "Boolean">,
     DefaultFalse,