Reinstating r181091 and r181106 with fix for Linux regressions.

llvm-svn: 181340

2 files changed, 56 insertions, 52 deletions

diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index 06e15ab1f40..0302f9312b7 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -1281,14 +1281,14 @@ ProcessGDBRemote::DoResume ()
 void
 ProcessGDBRemote::ClearThreadIDList ()
 {
-    Mutex::Locker locker(m_thread_list.GetMutex());
+    Mutex::Locker locker(m_thread_list_real.GetMutex());
     m_thread_ids.clear();
 }
 
 bool
 ProcessGDBRemote::UpdateThreadIDList ()
 {
-    Mutex::Locker locker(m_thread_list.GetMutex());
+    Mutex::Locker locker(m_thread_list_real.GetMutex());
     bool sequence_mutex_unavailable = false;
     m_gdb_comm.GetCurrentThreadIDs (m_thread_ids, sequence_mutex_unavailable);
     if (sequence_mutex_unavailable)
@@ -1323,12 +1323,6 @@ ProcessGDBRemote::UpdateThreadList (ThreadList &old_thread_list, ThreadList &new
         {
             tid_t tid = m_thread_ids[i];
             ThreadSP thread_sp (old_thread_list_copy.RemoveThreadByProtocolID(tid, false));
-            if (thread_sp)
-            {
-                ThreadSP backing_thread_sp (thread_sp->GetBackingThread());
-                if (backing_thread_sp && backing_thread_sp->GetProtocolID() == tid)
-                    thread_sp = backing_thread_sp;
-            }
             if (!thread_sp)
                 thread_sp.reset (new ThreadGDBRemote (*this, tid));
             new_thread_list.AddThread(thread_sp);
@@ -1385,7 +1379,6 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
             std::vector<addr_t> exc_data;
             addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS;
             ThreadSP thread_sp;
-            ThreadSP backing_thread_sp;
             ThreadGDBRemote *gdb_thread = NULL;
 
             while (stop_packet.GetNameColonValue(name, value))
@@ -1404,31 +1397,24 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
                 {
                     // thread in big endian hex
                     lldb::tid_t tid = Args::StringToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16);
-                    // m_thread_list does have its own mutex, but we need to
-                    // hold onto the mutex between the call to m_thread_list.FindThreadByID(...)
-                    // and the m_thread_list.AddThread(...) so it doesn't change on us
-                    Mutex::Locker locker (m_thread_list.GetMutex ());
-                    thread_sp = m_thread_list.FindThreadByProtocolID(tid, false);
+                    // m_thread_list_real does have its own mutex, but we need to
+                    // hold onto the mutex between the call to m_thread_list_real.FindThreadByID(...)
+                    // and the m_thread_list_real.AddThread(...) so it doesn't change on us
+                    Mutex::Locker locker (m_thread_list_real.GetMutex ());
+                    thread_sp = m_thread_list_real.FindThreadByProtocolID(tid, false);
 
-                    if (thread_sp)
-                    {
-                        backing_thread_sp = thread_sp->GetBackingThread();
-                        if (backing_thread_sp)
-                            gdb_thread = static_cast<ThreadGDBRemote *> (backing_thread_sp.get());
-                        else
-                            gdb_thread = static_cast<ThreadGDBRemote *> (thread_sp.get());
-                    }
-                    else
+                    if (!thread_sp)
                     {
                         // Create the thread if we need to
                         thread_sp.reset (new ThreadGDBRemote (*this, tid));
-                        gdb_thread = static_cast<ThreadGDBRemote *> (thread_sp.get());
-                        m_thread_list.AddThread(thread_sp);
+                        m_thread_list_real.AddThread(thread_sp);
                     }
+                    gdb_thread = static_cast<ThreadGDBRemote *> (thread_sp.get());
+
                 }
                 else if (name.compare("threads") == 0)
                 {
-                    Mutex::Locker locker(m_thread_list.GetMutex());
+                    Mutex::Locker locker(m_thread_list_real.GetMutex());
                     m_thread_ids.clear();
                     // A comma separated list of all threads in the current
                     // process that includes the thread for this stop reply
@@ -1508,6 +1494,9 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
 
             if (thread_sp)
             {
+                // Clear the stop info just in case we don't set it to anything
+                thread_sp->SetStopInfo (StopInfoSP());
+
                 gdb_thread->SetThreadDispatchQAddr (thread_dispatch_qaddr);
                 gdb_thread->SetName (thread_name.empty() ? NULL : thread_name.c_str());
                 if (exc_type != 0)
@@ -1610,11 +1599,6 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
                         if (!handled)
                             thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithSignal (*thread_sp, signo));
                     }
-                    else
-                    {
-                        StopInfoSP invalid_stop_info_sp;
-                        thread_sp->SetStopInfo (invalid_stop_info_sp);
-                    }
                     
                     if (!description.empty())
                     {
@@ -1647,7 +1631,7 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
 void
 ProcessGDBRemote::RefreshStateAfterStop ()
 {
-    Mutex::Locker locker(m_thread_list.GetMutex());
+    Mutex::Locker locker(m_thread_list_real.GetMutex());
     m_thread_ids.clear();
     // Set the thread stop info. It might have a "threads" key whose value is
     // a list of all thread IDs in the current process, so m_thread_ids might
@@ -1662,7 +1646,7 @@ ProcessGDBRemote::RefreshStateAfterStop ()
 
     // Let all threads recover from stopping and do any clean up based
     // on the previous thread state (if any).
-    m_thread_list.RefreshStateAfterStop();
+    m_thread_list_real.RefreshStateAfterStop();
     
 }
 
@@ -2330,6 +2314,7 @@ void
 ProcessGDBRemote::Clear()
 {
     m_flags = 0;
+    m_thread_list_real.Clear();
     m_thread_list.Clear();
 }
 
diff --git a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
index 321fe8d819a..40b367c3993 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
@@ -204,27 +204,46 @@ ThreadGDBRemote::GetPrivateStopReason ()
     if (process_sp)
     {
         const uint32_t process_stop_id = process_sp->GetStopID();
-        if (m_thread_stop_reason_stop_id != process_stop_id ||
-            (m_actual_stop_info_sp && !m_actual_stop_info_sp->IsValid()))
+        if (m_thread_stop_reason_stop_id == process_stop_id)
+        {
+            // Our stop info is up to date even if it is empty...
+            return m_actual_stop_info_sp;
+        }
+            
+        if (m_actual_stop_info_sp && m_actual_stop_info_sp->IsValid())
+        {
+            // The stop info is up to date, reset it so everything updates
+            SetStopInfo (m_actual_stop_info_sp);
+        }
+        else
         {
             if (IsStillAtLastBreakpointHit())
-                return m_actual_stop_info_sp;
-
-            // If GetGDBProcess().SetThreadStopInfo() doesn't find a stop reason
-            // for this thread, then m_actual_stop_info_sp will not ever contain
-            // a valid stop reason and the "m_actual_stop_info_sp->IsValid() == false"
-            // check will never be able to tell us if we have the correct stop info
-            // for this thread and we will continually send qThreadStopInfo packets
-            // down to the remote GDB server, so we need to keep our own notion
-            // of the stop ID that m_actual_stop_info_sp is valid for (even if it
-            // contains nothing). We use m_thread_stop_reason_stop_id for this below.
-            m_thread_stop_reason_stop_id = process_stop_id;
-            m_actual_stop_info_sp.reset();
-
-            StringExtractorGDBRemote stop_packet;
-            ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
-            if (gdb_process->GetGDBRemote().GetThreadStopInfo(GetProtocolID(), stop_packet))
-                gdb_process->SetThreadStopInfo (stop_packet);
+            {
+                SetStopInfo(m_actual_stop_info_sp);
+            }
+            else
+            {
+                // If GetGDBProcess().SetThreadStopInfo() doesn't find a stop reason
+                // for this thread, then m_actual_stop_info_sp will not ever contain
+                // a valid stop reason and the "m_actual_stop_info_sp->IsValid() == false"
+                // check will never be able to tell us if we have the correct stop info
+                // for this thread and we will continually send qThreadStopInfo packets
+                // down to the remote GDB server, so we need to keep our own notion
+                // of the stop ID that m_actual_stop_info_sp is valid for (even if it
+                // contains nothing). We use m_thread_stop_reason_stop_id for this below.
+                m_actual_stop_info_sp.reset();
+
+                StringExtractorGDBRemote stop_packet;
+                ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
+                if (gdb_process->GetGDBRemote().GetThreadStopInfo(GetProtocolID(), stop_packet))
+                {
+                    gdb_process->SetThreadStopInfo (stop_packet);
+                }
+                else
+                {
+                    SetStopInfo (StopInfoSP());
+                }
+            }
         }
     }
     return m_actual_stop_info_sp;