1 files changed, 153 insertions, 0 deletions
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.h
new file mode 100644
index 00000000000..9cfba4b8394
--- /dev/null
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.h
@@ -0,0 +1,153 @@
+//===-- GDBRemoteClientBase.h -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_GDBRemoteClientBase_h_
+#define liblldb_GDBRemoteClientBase_h_
+
+#include "GDBRemoteCommunication.h"
+
+#include <condition_variable>
+
+namespace lldb_private
+{
+namespace process_gdb_remote
+{
+
+class GDBRemoteClientBase : public GDBRemoteCommunication
+{
+public:
+    struct ContinueDelegate
+    {
+        virtual ~ContinueDelegate();
+        virtual void
+        HandleAsyncStdout(llvm::StringRef out) = 0;
+        virtual void
+        HandleAsyncMisc(llvm::StringRef data) = 0;
+        virtual void
+        HandleStopReply() = 0;
+    };
+
+    GDBRemoteClientBase(const char *comm_name, const char *listener_name);
+
+    bool
+    SendAsyncSignal(int signo);
+
+    bool
+    Interrupt();
+
+    lldb::StateType
+    SendContinuePacketAndWaitForResponse(ContinueDelegate &delegate, const UnixSignals &signals,
+                                         llvm::StringRef payload, StringExtractorGDBRemote &response);
+
+    PacketResult
+    SendPacketAndWaitForResponse(const char *payload, size_t len, StringExtractorGDBRemote &response, bool send_async)
+    {
+        return SendPacketAndWaitForResponse(llvm::StringRef(payload, len), response, send_async);
+    }
+
+    PacketResult
+    SendPacketAndWaitForResponse(llvm::StringRef payload, StringExtractorGDBRemote &response, bool send_async);
+
+    bool
+    SendvContPacket(llvm::StringRef payload, StringExtractorGDBRemote &response);
+
+    class Lock
+    {
+    public:
+        Lock(GDBRemoteClientBase &comm, bool interrupt);
+        ~Lock();
+
+        explicit operator bool() { return m_acquired; }
+
+        // Whether we had to interrupt the continue thread to acquire the connection.
+        bool
+        DidInterrupt() const
+        {
+            return m_did_interrupt;
+        }
+
+    private:
+        std::unique_lock<std::recursive_mutex> m_async_lock;
+        GDBRemoteClientBase &m_comm;
+        bool m_acquired;
+        bool m_did_interrupt;
+
+        void
+        SyncWithContinueThread(bool interrupt);
+    };
+
+protected:
+    PacketResult
+    SendPacketAndWaitForResponseNoLock(llvm::StringRef payload, StringExtractorGDBRemote &response);
+
+    virtual void
+    OnRunPacketSent(bool first);
+
+private:
+    // Variables handling synchronization between the Continue thread and any other threads
+    // wishing to send packets over the connection. Either the continue thread has control over
+    // the connection (m_is_running == true) or the connection is free for an arbitrary number of
+    // other senders to take which indicate their interest by incrementing m_async_count.
+    // Semantics of individual states:
+    // - m_continue_packet == false, m_async_count == 0: connection is free
+    // - m_continue_packet == true, m_async_count == 0: only continue thread is present
+    // - m_continue_packet == true, m_async_count > 0: continue thread has control, async threads
+    //   should interrupt it and wait for it to set m_continue_packet to false
+    // - m_continue_packet == false, m_async_count > 0: async threads have control, continue
+    //   thread needs to wait for them to finish (m_async_count goes down to 0).
+    std::mutex m_mutex;
+    std::condition_variable m_cv;
+    // Packet with which to resume after an async interrupt. Can be changed by an async thread
+    // e.g. to inject a signal.
+    std::string m_continue_packet;
+    // When was the interrupt packet sent. Used to make sure we time out if the stub does not
+    // respond to interrupt requests.
+    std::chrono::time_point<std::chrono::steady_clock> m_interrupt_time;
+    uint32_t m_async_count;
+    bool m_is_running;
+    bool m_should_stop; // Whether we should resume after a stop.
+    // end of continue thread synchronization block
+
+    // This handles the synchronization between individual async threads. For now they just use a
+    // simple mutex.
+    std::recursive_mutex m_async_mutex;
+
+    bool
+    ShouldStop(const UnixSignals &signals, StringExtractorGDBRemote &response);
+
+    class ContinueLock
+    {
+    public:
+        enum class LockResult
+        {
+            Success,
+            Cancelled,
+            Failed
+        };
+
+        explicit ContinueLock(GDBRemoteClientBase &comm);
+        ~ContinueLock();
+        explicit operator bool() { return m_acquired; }
+
+        LockResult
+        lock();
+
+        void
+        unlock();
+
+    private:
+        GDBRemoteClientBase &m_comm;
+        bool m_acquired;
+    };
+};
+
+} // namespace process_gdb_remote
+} // namespace lldb_private
+
+#endif // liblldb_GDBRemoteCommunicationClient_h_