Changes to lldb and debugserver to reduce extraneous memory reads

at each public stop to improve performance a bit.  Most of the 
information lldb needed was already in the jThreadsInfo response;
complete that information and catch a few cases where we could still
fall back to getting the information via discrete memory reads.


debugserver adds 'associated_with_dispatch_queue' and 'dispatch_queue_t
keys to the jThreadsInfo response for all the threads.  lldb needs the
dispatch_queue_t value.  And associated_with_dispatch_queue helps to
identify which threads definitively don't have any queue information so
lldb doesn't try to do memory reads to get that information just because
it was absent in the jThreadsInfo response.

Remove the queue information from the questionmark (T) packet.  We'll
get the information for all threads via the jThreadsInfo response -
sending the information for the stopping thread (on all the private
stops, plus the less frequent public stop) was unnecessary information
being sent over the wire.

SystemRuntimeMacOSX will try to get information about queues by asking
the Threads for them, instead of reading memory.  

ProcessGDBRemote changes to recognize the new keys being sent in the
jThreadsInfo response.  Changes to ThreadGDBRemote to track the new
information.  Also, when a thread is marked as definitively not 
associated with a libdispatch queue, don't fall back to the system
runtime to try memory reads to find the queue name / kind / ID etc.


<rdar://problem/23309359> 

llvm-svn: 257453

1 files changed, 91 insertions, 16 deletions

diff --git a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
index 9b410d8..a4af12c 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
@@ -41,8 +41,10 @@ ThreadGDBRemote::ThreadGDBRemote (Process &process, lldb::tid_t tid) :
     m_thread_name (),
     m_dispatch_queue_name (),
     m_thread_dispatch_qaddr (LLDB_INVALID_ADDRESS),
-    m_queue_kind(eQueueKindUnknown),
-    m_queue_serial(0)
+    m_dispatch_queue_t (LLDB_INVALID_ADDRESS),
+    m_queue_kind (eQueueKindUnknown),
+    m_queue_serial_number (LLDB_INVALID_QUEUE_ID),
+    m_associated_with_libdispatch_queue (eLazyBoolCalculate)
 {
     ProcessGDBRemoteLog::LogIf(GDBR_LOG_THREAD, "%p: ThreadGDBRemote::ThreadGDBRemote (pid = %i, tid = 0x%4.4x)",
                                this, 
@@ -73,15 +75,19 @@ ThreadGDBRemote::ClearQueueInfo ()
 {
     m_dispatch_queue_name.clear();
     m_queue_kind = eQueueKindUnknown;
-    m_queue_serial = 0;
+    m_queue_serial_number = 0;
+    m_dispatch_queue_t = LLDB_INVALID_ADDRESS;
+    m_associated_with_libdispatch_queue = eLazyBoolCalculate;
 }
 
 void
-ThreadGDBRemote::SetQueueInfo (std::string &&queue_name, QueueKind queue_kind, uint64_t queue_serial)
+ThreadGDBRemote::SetQueueInfo (std::string &&queue_name, QueueKind queue_kind, uint64_t queue_serial, addr_t dispatch_queue_t, LazyBool associated_with_libdispatch_queue)
 {
     m_dispatch_queue_name = queue_name;
     m_queue_kind = queue_kind;
-    m_queue_serial = queue_serial;
+    m_queue_serial_number = queue_serial;
+    m_dispatch_queue_t = dispatch_queue_t;
+    m_associated_with_libdispatch_queue = associated_with_libdispatch_queue;
 }
 
 
@@ -100,7 +106,10 @@ ThreadGDBRemote::GetQueueName ()
     }
     // Always re-fetch the dispatch queue name since it can change
 
-    if (m_thread_dispatch_qaddr != 0 || m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
+    if (m_associated_with_libdispatch_queue == eLazyBoolNo)
+        return nullptr;
+
+    if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
     {
         ProcessSP process_sp (GetProcess());
         if (process_sp)
@@ -118,6 +127,35 @@ ThreadGDBRemote::GetQueueName ()
     return NULL;
 }
 
+QueueKind
+ThreadGDBRemote::GetQueueKind ()
+{
+    // If our cached queue info is valid, then someone called ThreadGDBRemote::SetQueueInfo(...)
+    // with valid information that was gleaned from the stop reply packet. In this case we trust
+    // that the info is valid in m_dispatch_queue_name without refetching it
+    if (CachedQueueInfoIsValid())
+    {
+        return m_queue_kind;
+    }
+
+    if (m_associated_with_libdispatch_queue == eLazyBoolNo)
+        return eQueueKindUnknown;
+
+    if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
+    {
+        ProcessSP process_sp (GetProcess());
+        if (process_sp)
+        {
+            SystemRuntime *runtime = process_sp->GetSystemRuntime ();
+            if (runtime)
+                m_queue_kind = runtime->GetQueueKind (m_thread_dispatch_qaddr);
+            return m_queue_kind;
+        }
+    }
+    return eQueueKindUnknown;
+}
+
+
 queue_id_t
 ThreadGDBRemote::GetQueueID ()
 {
@@ -125,9 +163,12 @@ ThreadGDBRemote::GetQueueID ()
     // with valid information that was gleaned from the stop reply packet. In this case we trust
     // that the info is valid in m_dispatch_queue_name without refetching it
     if (CachedQueueInfoIsValid())
-        return m_queue_serial;
+        return m_queue_serial_number;
+
+    if (m_associated_with_libdispatch_queue == eLazyBoolNo)
+        return LLDB_INVALID_QUEUE_ID;
 
-    if (m_thread_dispatch_qaddr != 0 || m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
+    if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
     {
         ProcessSP process_sp (GetProcess());
         if (process_sp)
@@ -161,20 +202,54 @@ ThreadGDBRemote::GetQueue ()
 addr_t
 ThreadGDBRemote::GetQueueLibdispatchQueueAddress ()
 {
-    addr_t dispatch_queue_t_addr = LLDB_INVALID_ADDRESS;
-    if (m_thread_dispatch_qaddr != 0 || m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
+    if (m_dispatch_queue_t == LLDB_INVALID_ADDRESS)
     {
-        ProcessSP process_sp (GetProcess());
-        if (process_sp)
+        if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
         {
-            SystemRuntime *runtime = process_sp->GetSystemRuntime ();
-            if (runtime)
+            ProcessSP process_sp (GetProcess());
+            if (process_sp)
             {
-                dispatch_queue_t_addr = runtime->GetLibdispatchQueueAddressFromThreadQAddress (m_thread_dispatch_qaddr);
+                SystemRuntime *runtime = process_sp->GetSystemRuntime ();
+                if (runtime)
+                {
+                    m_dispatch_queue_t = runtime->GetLibdispatchQueueAddressFromThreadQAddress (m_thread_dispatch_qaddr);
+                }
             }
         }
     }
-    return dispatch_queue_t_addr;
+    return m_dispatch_queue_t;
+}
+
+void
+ThreadGDBRemote::SetQueueLibdispatchQueueAddress (lldb::addr_t dispatch_queue_t)
+{
+    m_dispatch_queue_t = dispatch_queue_t;
+}
+
+bool
+ThreadGDBRemote::ThreadHasQueueInformation () const
+{
+    if (m_thread_dispatch_qaddr != 0 
+        && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS
+        && m_dispatch_queue_t != LLDB_INVALID_ADDRESS
+        && m_queue_kind != eQueueKindUnknown
+        && m_queue_serial_number != 0)
+    {
+        return true;
+    }
+    return false;
+}
+
+LazyBool
+ThreadGDBRemote::GetAssociatedWithLibdispatchQueue ()
+{
+    return m_associated_with_libdispatch_queue;
+}
+
+void
+ThreadGDBRemote::SetAssociatedWithLibdispatchQueue (LazyBool associated_with_libdispatch_queue)
+{
+    m_associated_with_libdispatch_queue = associated_with_libdispatch_queue;
 }
 
 StructuredData::ObjectSP