2 files changed, 66 insertions, 22 deletions

diff --git a/lldb/source/Plugins/Process/Linux/ThreadStateCoordinator.cpp b/lldb/source/Plugins/Process/Linux/ThreadStateCoordinator.cpp
index 78b9abbd88a..b6d1382577d 100644
--- a/lldb/source/Plugins/Process/Linux/ThreadStateCoordinator.cpp
+++ b/lldb/source/Plugins/Process/Linux/ThreadStateCoordinator.cpp
@@ -49,10 +49,6 @@ public:
     {
     }
 
-    ~EventStopCoordinator () override
-    {
-    }
-
     bool
     ProcessEvent(ThreadStateCoordinator &coordinator) override
     {
@@ -77,10 +73,6 @@ public:
     {
     }
 
-    ~EventCallAfterThreadsStop () override
-    {
-    }
-
     lldb::tid_t GetTriggeringTID () const
     {
         return m_triggering_tid;
@@ -181,6 +173,24 @@ private:
 
 //===----------------------------------------------------------------------===//
 
+class ThreadStateCoordinator::EventReset : public ThreadStateCoordinator::EventBase
+{
+public:
+    EventReset ():
+    EventBase ()
+    {
+    }
+
+    bool
+    ProcessEvent(ThreadStateCoordinator &coordinator) override
+    {
+        coordinator.ResetNow ();
+        return true;
+    }
+};
+
+//===----------------------------------------------------------------------===//
+
 class ThreadStateCoordinator::EventThreadStopped : public ThreadStateCoordinator::EventBase
 {
 public:
@@ -190,10 +200,6 @@ public:
     {
     }
 
-    ~EventThreadStopped () override
-    {
-    }
-
     bool
     ProcessEvent(ThreadStateCoordinator &coordinator) override
     {
@@ -217,10 +223,6 @@ public:
     {
     }
 
-    ~EventThreadCreate () override
-    {
-    }
-
     bool
     ProcessEvent(ThreadStateCoordinator &coordinator) override
     {
@@ -244,10 +246,6 @@ public:
     {
     }
 
-    ~EventThreadDeath () override
-    {
-    }
-
     bool
     ProcessEvent(ThreadStateCoordinator &coordinator) override
     {
@@ -387,6 +385,19 @@ ThreadStateCoordinator::ThreadDidDie (lldb::tid_t tid)
 }
 
 void
+ThreadStateCoordinator::ResetNow ()
+{
+    // Clear the pending notification if there was one.
+    m_pending_notification_sp.reset ();
+
+    // Clear the stop map - we no longer know anything about any thread state.
+    // The caller is expected to reset thread states for all threads, and we
+    // will assume anything we haven't heard about is running and requires a
+    // stop.
+    m_tid_stop_map.clear ();
+}
+
+void
 ThreadStateCoordinator::Log (const char *format, ...)
 {
     va_list args;
@@ -416,6 +427,26 @@ ThreadStateCoordinator::NotifyThreadDeath (lldb::tid_t tid)
 }
 
 void
+ThreadStateCoordinator::ResetForExec ()
+{
+    std::lock_guard<std::mutex> lock (m_queue_mutex);
+
+    // Remove everything from the queue.  This is the only
+    // state mutation that takes place outside the processing
+    // loop.
+    QueueType empty_queue;
+    m_event_queue.swap (empty_queue);
+
+    // Do the real clear behavior on the the queue to eliminate
+    // the chance that processing of a dequeued earlier event is
+    // overlapping with the clearing of state here.  Push it
+    // directly because we need to have this happen with the lock,
+    // and so far I only have this one place that needs a no-lock
+    // variant.
+    m_event_queue.push (EventBaseSP (new EventReset ()));
+}
+
+void
 ThreadStateCoordinator::StopCoordinator ()
 {
     EnqueueEvent (EventBaseSP (new EventStopCoordinator ()));
diff --git a/lldb/source/Plugins/Process/Linux/ThreadStateCoordinator.h b/lldb/source/Plugins/Process/Linux/ThreadStateCoordinator.h
index 14399abfe08..f27dc67099f 100644
--- a/lldb/source/Plugins/Process/Linux/ThreadStateCoordinator.h
+++ b/lldb/source/Plugins/Process/Linux/ThreadStateCoordinator.h
@@ -59,6 +59,14 @@ namespace lldb_private
         void
         NotifyThreadDeath (lldb::tid_t tid);
 
+        // Indicate the calling process did an exec and that the thread state
+        // should be 100% cleared.
+        //
+        // Note this will clear out any pending notifications, but will not stop
+        // a notification currently in progress via ProcessNextEvent().
+        void
+        ResetForExec ();
+
         // Indicate when the coordinator should shut down.
         void
         StopCoordinator ();
@@ -77,11 +85,13 @@ namespace lldb_private
         class EventBase;
 
         class EventCallAfterThreadsStop;
-        class EventStopCoordinator;
         class EventThreadStopped;
         class EventThreadCreate;
         class EventThreadDeath;
 
+        class EventStopCoordinator;
+        class EventReset;
+
         typedef std::shared_ptr<EventBase> EventBaseSP;
 
         typedef std::queue<EventBaseSP> QueueType;
@@ -109,6 +119,9 @@ namespace lldb_private
         ThreadDidDie (lldb::tid_t tid);
 
         void
+        ResetNow ();
+
+        void
         Log (const char *format, ...);
 
         // Member variables.
@@ -116,7 +129,7 @@ namespace lldb_private
 
         QueueType m_event_queue;
         // For now we do simple read/write lock strategy with efficient wait-for-data.
-        // We can replace with entirely non-blocking queue later but we still want the
+        // We can replace with an entirely non-blocking queue later but we still want the
         // reader to sleep when nothing is available - this will be a bursty but infrequent
         // event mechanism.
         std::condition_variable m_queue_condition;