Initial merge of some of the iOS 8 / Mac OS X Yosemite specific

lldb support.  I'll be doing more testing & cleanup but I wanted to
get the initial checkin done.

This adds a new SBExpressionOptions::SetLanguage API for selecting a
language of an expression.

I added adds a new SBThread::GetInfoItemByPathString for retriving
information about a thread from that thread's StructuredData.

I added a new StructuredData class for representing
key-value/array/dictionary information (e.g. JSON formatted data).
Helper functions to read JSON and create a StructuredData object,
and to print a StructuredData object in JSON format are included.

A few Cocoa / Cocoa Touch data formatters were updated by Enrico
to track changes in iOS 8 / Yosemite.

Before we query a thread's extended information, the system runtime may 
provide hints to the remote debug stub that it will use to retrieve values
out of runtime structures.  I added a new SystemRuntime method 
AddThreadExtendedInfoPacketHints which allows the SystemRuntime to add 
key-value type data to the initial request that we send to the remote stub.

The thread-format formatter string can now retrieve values out of a thread's
extended info structured data.  The default thread-format string picks up
two of these - thread.info.activity.name and thread.info.trace_messages.

I added a new "jThreadExtendedInfo" packet in debugserver; I will
add documentation to the lldb-gdb-remote.txt doc soon.  It accepts
JSON formatted arguments (most importantly, "thread":threadnum) and
it returns a variety of information regarding the thread to lldb
in JSON format.  This JSON return is scanned into a StructuredData
object that is associated with the thread; UI layers can query the
thread's StructuredData to see if key-values are present, and if
so, show them to the user.  These key-values are likely to be
specific to different targets with some commonality among many
targets.  For instance, many targets will be able to advertise the
pthread_t value for a thread.

I added an initial rough cut of "thread info" command which will print
the information about a thread from the jThreadExtendedInfo result.
I need to do more work to make this format reasonably.

Han Ming added calls into the pmenergy and pmsample libraries if
debugserver is run on Mac OS X Yosemite to get information about the
inferior's power use.

I added support to debugserver for gathering the Genealogy information
about threads, if it exists, and returning it in the jThreadExtendedInfo
JSON result.

llvm-svn: 210874

8 files changed, 365 insertions, 3 deletions

diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
index 9b9fef98c74..182688dab66 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
@@ -75,6 +75,7 @@ GDBRemoteCommunicationClient::GDBRemoteCommunicationClient(bool is_platform) :
     m_supports_qXfer_libraries_read (eLazyBoolCalculate),
     m_supports_qXfer_libraries_svr4_read (eLazyBoolCalculate),
     m_supports_augmented_libraries_svr4_read (eLazyBoolCalculate),
+    m_supports_jThreadExtendedInfo (eLazyBoolCalculate),
     m_supports_qProcessInfoPID (true),
     m_supports_qfProcessInfo (true),
     m_supports_qUserName (true),
@@ -496,6 +497,24 @@ GDBRemoteCommunicationClient::GetpPacketSupported (lldb::tid_t tid)
 }
 
 bool
+GDBRemoteCommunicationClient::GetThreadExtendedInfoSupported ()
+{
+    if (m_supports_jThreadExtendedInfo == eLazyBoolCalculate)
+    {
+        StringExtractorGDBRemote response;
+        m_supports_jThreadExtendedInfo = eLazyBoolNo;
+        if (SendPacketAndWaitForResponse("jThreadExtendedInfo:", response, false) == PacketResult::Success)
+        {
+            if (response.IsOKResponse())
+            {
+                m_supports_jThreadExtendedInfo = eLazyBoolYes;
+            }
+        }
+    }
+    return m_supports_jThreadExtendedInfo;
+}
+
+bool
 GDBRemoteCommunicationClient::GetxPacketSupported ()
 {
     if (m_supports_x == eLazyBoolCalculate)
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
index 6b1aec53928..1166a6f9025 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
@@ -511,6 +511,9 @@ public:
     bool
     AvoidGPackets(ProcessGDBRemote *process);
 
+    bool
+    GetThreadExtendedInfoSupported();
+
 protected:
 
     PacketResult
@@ -555,6 +558,7 @@ protected:
     lldb_private::LazyBool m_supports_qXfer_libraries_read;
     lldb_private::LazyBool m_supports_qXfer_libraries_svr4_read;
     lldb_private::LazyBool m_supports_augmented_libraries_svr4_read;
+    lldb_private::LazyBool m_supports_jThreadExtendedInfo;
 
     bool
         m_supports_qProcessInfoPID:1,
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index b79a6974455..7adf9165a3e 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -56,6 +56,7 @@
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
+#include "lldb/Target/SystemRuntime.h"
 #include "lldb/Utility/PseudoTerminal.h"
 
 // Project includes
@@ -3149,6 +3150,50 @@ ProcessGDBRemote::GetAuxvData()
     return buf;
 }
 
+StructuredData::ObjectSP
+ProcessGDBRemote::GetExtendedInfoForThread (lldb::tid_t tid)
+{
+    StructuredData::ObjectSP object_sp;
+
+    if (m_gdb_comm.GetThreadExtendedInfoSupported())
+    {
+        StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
+        SystemRuntime *runtime = GetSystemRuntime();
+        if (runtime)
+        {
+            runtime->AddThreadExtendedInfoPacketHints (args_dict);
+        }
+        args_dict->GetAsDictionary()->AddIntegerItem ("thread", tid);
+
+        StreamString packet;
+        packet << "jThreadExtendedInfo:";
+        args_dict->Dump (packet);
+
+        // FIXME the final character of a JSON dictionary, '}', is the escape
+        // character in gdb-remote binary mode.  lldb currently doesn't escape
+        // these characters in its packet output -- so we add the quoted version
+        // of the } character here manually in case we talk to a debugserver which
+        // un-escapes the chracters at packet read time.
+        packet << (char) (0x7d ^ 0x20);
+
+        StringExtractorGDBRemote response;
+        if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, false) == GDBRemoteCommunication::PacketResult::Success)
+        {
+            StringExtractorGDBRemote::ResponseType response_type = response.GetResponseType();
+            if (response_type == StringExtractorGDBRemote::eResponse)
+            {
+                if (!response.Empty())
+                {
+                    // The packet has already had the 0x7d xor quoting stripped out at the
+                    // GDBRemoteCommunication packet receive level.
+                    object_sp = StructuredData::ParseJSON (response.GetStringRef());
+                }
+            }
+        }
+    }
+    return object_sp;
+}
+
 // Establish the largest memory read/write payloads we should use.
 // If the remote stub has a max packet size, stay under that size.
 // 
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
index 1547cb67af5..c7177e91d16 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
@@ -23,6 +23,7 @@
 #include "lldb/Core/Error.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/StringList.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ThreadSafeValue.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
@@ -307,6 +308,9 @@ protected:
     virtual const lldb::DataBufferSP
     GetAuxvData();
 
+    lldb_private::StructuredData::ObjectSP
+    GetExtendedInfoForThread (lldb::tid_t tid);
+
     void
     GetMaxMemorySize();
 
diff --git a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
index 79893cf6612..5c70cb5427c 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
@@ -142,6 +142,23 @@ ThreadGDBRemote::GetQueueLibdispatchQueueAddress ()
     return dispatch_queue_t_addr;
 }
 
+StructuredData::ObjectSP
+ThreadGDBRemote::FetchThreadExtendedInfo ()
+{
+    StructuredData::ObjectSP object_sp;
+    const lldb::user_id_t tid = GetProtocolID();
+    Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
+    if (log)
+        log->Printf ("Fetching extended information for thread %4.4" PRIx64, tid);
+    ProcessSP process_sp (GetProcess());
+    if (process_sp)
+    {
+        ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
+        object_sp = gdb_process->GetExtendedInfoForThread (tid);
+    }
+    return object_sp;
+}
+
 void
 ThreadGDBRemote::WillResume (StateType resume_state)
 {
diff --git a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
index 65d6aa5d95f..a204a917ecb 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
+++ b/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
@@ -12,6 +12,7 @@
 
 #include <string>
 
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 
@@ -86,6 +87,9 @@ public:
         m_thread_dispatch_qaddr = thread_dispatch_qaddr;
     }
 
+    lldb_private::StructuredData::ObjectSP
+    FetchThreadExtendedInfo ();
+
 protected:
     
     friend class ProcessGDBRemote;
diff --git a/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp b/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp
index f3f1fa31cd7..c04c42b1279 100644
--- a/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp
+++ b/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp
@@ -16,6 +16,7 @@
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Core/StreamString.h"
 #include "lldb/Expression/ClangFunction.h"
 #include "lldb/Expression/ClangUtilityFunction.h"
 #include "lldb/Host/FileSpec.h"
@@ -28,7 +29,6 @@
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/Process.h"
 
-
 #include "SystemRuntimeMacOSX.h"
 
 using namespace lldb;
@@ -93,7 +93,13 @@ SystemRuntimeMacOSX::SystemRuntimeMacOSX (Process* process) :
     m_page_to_free_size(0),
     m_lib_backtrace_recording_info(),
     m_dispatch_queue_offsets_addr (LLDB_INVALID_ADDRESS),
-    m_libdispatch_offsets()
+    m_libdispatch_offsets(),
+    m_libpthread_layout_offsets_addr (LLDB_INVALID_ADDRESS),
+    m_libpthread_offsets(),
+    m_dispatch_tsd_indexes_addr (LLDB_INVALID_ADDRESS),
+    m_libdispatch_tsd_indexes(),
+    m_dispatch_voucher_offsets_addr (LLDB_INVALID_ADDRESS),
+    m_libdispatch_voucher_offsets()
 {
 }
 
@@ -214,6 +220,30 @@ SystemRuntimeMacOSX::GetQueueKind (addr_t dispatch_queue_addr)
     return kind;
 }
 
+void
+SystemRuntimeMacOSX::AddThreadExtendedInfoPacketHints (lldb_private::StructuredData::ObjectSP dict_sp)
+{
+    StructuredData::Dictionary *dict = dict_sp->GetAsDictionary();
+    if (dict)
+    {
+        ReadLibpthreadOffsets();
+        if (m_libpthread_offsets.IsValid())
+        {
+            dict->AddIntegerItem ("plo_pthread_tsd_base_offset", m_libpthread_offsets.plo_pthread_tsd_base_offset);
+            dict->AddIntegerItem ("plo_pthread_tsd_base_address_offset", m_libpthread_offsets.plo_pthread_tsd_base_address_offset);
+            dict->AddIntegerItem ("plo_pthread_tsd_entry_size", m_libpthread_offsets.plo_pthread_tsd_entry_size);
+        }
+    
+        ReadLibdispatchTSDIndexes ();
+        if (m_libdispatch_tsd_indexes.IsValid())
+        {
+            dict->AddIntegerItem ("dti_queue_index", m_libdispatch_tsd_indexes.dti_queue_index);
+            dict->AddIntegerItem ("dti_voucher_index", m_libdispatch_tsd_indexes.dti_voucher_index);
+            dict->AddIntegerItem ("dti_qos_class_index", m_libdispatch_tsd_indexes.dti_qos_class_index);
+        }
+    }
+}
+
 bool
 SystemRuntimeMacOSX::SafeToCallFunctionsOnThisThread (ThreadSP thread_sp)
 {
@@ -312,6 +342,152 @@ SystemRuntimeMacOSX::ReadLibdispatchOffsets ()
     }
 }
 
+void
+SystemRuntimeMacOSX::ReadLibpthreadOffsetsAddress ()
+{
+    if (m_libpthread_layout_offsets_addr != LLDB_INVALID_ADDRESS)
+        return;
+
+    static ConstString g_libpthread_layout_offsets_symbol_name ("pthread_layout_offsets");
+    const Symbol *libpthread_layout_offsets_symbol = NULL;
+
+    ModuleSpec libpthread_module_spec (FileSpec("libsystem_pthread.dylib", false));
+    ModuleSP module_sp (m_process->GetTarget().GetImages().FindFirstModule (libpthread_module_spec));
+    if (module_sp)
+    {
+        libpthread_layout_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType 
+                                                           (g_libpthread_layout_offsets_symbol_name, eSymbolTypeData);
+        if (libpthread_layout_offsets_symbol)
+        {
+            m_libpthread_layout_offsets_addr =  libpthread_layout_offsets_symbol->GetAddress().GetLoadAddress(&m_process->GetTarget());
+        }
+    }
+}
+
+void
+SystemRuntimeMacOSX::ReadLibpthreadOffsets ()
+{
+    if (m_libpthread_offsets.IsValid())
+        return;
+
+    ReadLibpthreadOffsetsAddress ();
+
+    if (m_libpthread_layout_offsets_addr != LLDB_INVALID_ADDRESS)
+    {
+        uint8_t memory_buffer[sizeof (struct LibpthreadOffsets)];
+        DataExtractor data (memory_buffer, 
+                            sizeof(memory_buffer), 
+                            m_process->GetByteOrder(), 
+                            m_process->GetAddressByteSize());
+        Error error;
+        if (m_process->ReadMemory (m_libpthread_layout_offsets_addr, memory_buffer, sizeof(memory_buffer), error) == sizeof(memory_buffer))
+        {
+            lldb::offset_t data_offset = 0;
+    
+            // The struct LibpthreadOffsets is a series of uint16_t's - extract them all
+            // in one big go.
+            data.GetU16 (&data_offset, &m_libpthread_offsets.plo_version, sizeof (struct LibpthreadOffsets) / sizeof (uint16_t));
+        }
+    }
+}
+
+void
+SystemRuntimeMacOSX::ReadLibdispatchTSDIndexesAddress ()
+{
+    if (m_dispatch_tsd_indexes_addr != LLDB_INVALID_ADDRESS)
+        return;
+
+    static ConstString g_libdispatch_tsd_indexes_symbol_name ("dispatch_tsd_indexes");
+    const Symbol *libdispatch_tsd_indexes_symbol = NULL;
+
+    ModuleSpec libpthread_module_spec (FileSpec("libdispatch.dylib", false));
+    ModuleSP module_sp (m_process->GetTarget().GetImages().FindFirstModule (libpthread_module_spec));
+    if (module_sp)
+    {
+        libdispatch_tsd_indexes_symbol = module_sp->FindFirstSymbolWithNameAndType 
+                                                           (g_libdispatch_tsd_indexes_symbol_name, eSymbolTypeData);
+        if (libdispatch_tsd_indexes_symbol)
+        {
+            m_dispatch_tsd_indexes_addr =  libdispatch_tsd_indexes_symbol->GetAddress().GetLoadAddress(&m_process->GetTarget());
+        }
+    }
+}
+
+void
+SystemRuntimeMacOSX::ReadLibdispatchTSDIndexes ()
+{
+    if (m_libdispatch_tsd_indexes.IsValid())
+        return;
+
+    ReadLibdispatchTSDIndexesAddress ();
+
+    if (m_dispatch_tsd_indexes_addr != LLDB_INVALID_ADDRESS)
+    {
+        size_t maximum_tsd_indexes_struct_size;
+        Address dti_struct_addr;
+        uint16_t dti_version = 2;
+        if (m_process->GetTarget().ResolveLoadAddress(m_dispatch_tsd_indexes_addr, dti_struct_addr))
+        {
+            Error error;
+            uint16_t version = m_process->GetTarget().ReadUnsignedIntegerFromMemory (dti_struct_addr, false, 2, UINT16_MAX, error);
+            if (error.Success() && dti_version != UINT16_MAX)
+            {
+                dti_version = version;
+            }
+        }
+        if (dti_version == 1)
+        {
+            if (m_process->GetAddressByteSize() == 4)
+            {
+                maximum_tsd_indexes_struct_size = 4 + 4 + 4 + 4;
+            }
+            else
+            {
+                maximum_tsd_indexes_struct_size = 8 + 8 + 8 + 8;
+            }
+        }
+        else
+        {
+            maximum_tsd_indexes_struct_size = 2 + 2 + 2 + 2;
+        }
+
+        uint8_t memory_buffer[maximum_tsd_indexes_struct_size];
+        DataExtractor data (memory_buffer, 
+                            sizeof(memory_buffer), 
+                            m_process->GetByteOrder(), 
+                            m_process->GetAddressByteSize());
+        Error error;
+        if (m_process->ReadMemory (m_dispatch_tsd_indexes_addr, memory_buffer, sizeof(memory_buffer), error) == sizeof(memory_buffer))
+        {
+            lldb::offset_t offset = 0;
+    
+            if (dti_version == 1)
+            {
+                m_libdispatch_tsd_indexes.dti_version = data.GetU16 (&offset);
+                // word alignment to next item
+                if (m_process->GetAddressByteSize() == 4)
+                {
+                    offset += 2;
+                }
+                else
+                {
+                    offset += 6;
+                }
+                m_libdispatch_tsd_indexes.dti_queue_index = data.GetPointer (&offset);
+                m_libdispatch_tsd_indexes.dti_voucher_index = data.GetPointer (&offset);
+                m_libdispatch_tsd_indexes.dti_qos_class_index = data.GetPointer (&offset);
+            }
+            else
+            {
+                m_libdispatch_tsd_indexes.dti_version = data.GetU16 (&offset);
+                m_libdispatch_tsd_indexes.dti_queue_index = data.GetU16 (&offset);
+                m_libdispatch_tsd_indexes.dti_voucher_index = data.GetU16 (&offset);
+                m_libdispatch_tsd_indexes.dti_qos_class_index = data.GetU16 (&offset);
+            }
+        }
+    }
+}
+
 
 ThreadSP
 SystemRuntimeMacOSX::GetExtendedBacktraceThread (ThreadSP real_thread, ConstString type)
diff --git a/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h b/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h
index 30956fa3ece..48d1f7fefb3 100644
--- a/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h
+++ b/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h
@@ -19,10 +19,11 @@
 // Other libraries and framework includes
 
 #include "lldb/Target/SystemRuntime.h"
-#include "lldb/Host/FileSpec.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/ModuleList.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/UUID.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/QueueItem.h"
@@ -108,6 +109,9 @@ public:
     virtual lldb::QueueKind
     GetQueueKind (lldb::addr_t dispatch_queue_addr);
 
+    virtual void
+    AddThreadExtendedInfoPacketHints (lldb_private::StructuredData::ObjectSP dict);
+
     virtual bool
     SafeToCallFunctionsOnThisThread (lldb::ThreadSP thread_sp);
 
@@ -176,6 +180,13 @@ private:
         uint16_t dqo_running;
         uint16_t dqo_running_size;
 
+        uint16_t dqo_suspend_cnt;         // version 5 and later, starting with Mac OS X 10.10/iOS 8
+        uint16_t dqo_suspend_cnt_size;    // version 5 and later, starting with Mac OS X 10.10/iOS 8
+        uint16_t dqo_target_queue;        // version 5 and later, starting with Mac OS X 10.10/iOS 8
+        uint16_t dqo_target_queue_size;   // version 5 and later, starting with Mac OS X 10.10/iOS 8
+        uint16_t dqo_priority;            // version 5 and later, starting with Mac OS X 10.10/iOS 8
+        uint16_t dqo_priority_size;       // version 5 and later, starting with Mac OS X 10.10/iOS 8
+
         LibdispatchOffsets ()
         {
             dqo_version = UINT16_MAX;
@@ -184,6 +195,10 @@ private:
             dqo_label = UINT16_MAX;
             dqo_width = UINT16_MAX;
             dqo_running = UINT16_MAX;
+            dqo_suspend_cnt = UINT16_MAX;
+            dqo_target_queue = UINT16_MAX;
+            dqo_target_queue = UINT16_MAX;
+            dqo_priority = UINT16_MAX;
         };
 
         bool
@@ -199,6 +214,62 @@ private:
         }
     };
 
+    struct LibdispatchVoucherOffsets
+    {
+        uint16_t vo_version;
+        uint16_t vo_activity_ids_count;
+        uint16_t vo_activity_ids_count_size;
+        uint16_t vo_activity_ids_array;
+        uint16_t vo_activity_ids_array_entry_size;
+
+        LibdispatchVoucherOffsets () :
+            vo_version (UINT16_MAX),
+            vo_activity_ids_count (UINT16_MAX),
+            vo_activity_ids_count_size (UINT16_MAX),
+            vo_activity_ids_array (UINT16_MAX),
+            vo_activity_ids_array_entry_size (UINT16_MAX)
+        { }
+
+        bool IsValid () { return vo_version != UINT16_MAX; }
+    };
+
+    struct LibdispatchTSDIndexes
+    {
+        uint16_t dti_version;
+        uint64_t dti_queue_index;
+        uint64_t dti_voucher_index;
+        uint64_t dti_qos_class_index;
+
+        LibdispatchTSDIndexes () :
+            dti_version (UINT16_MAX),
+            dti_queue_index (UINT64_MAX),
+            dti_voucher_index (UINT64_MAX),
+            dti_qos_class_index (UINT64_MAX)
+        { }
+
+        bool IsValid () { return dti_version != UINT16_MAX; }
+    };
+
+    struct LibpthreadOffsets
+    {
+        uint16_t    plo_version;
+        uint16_t    plo_pthread_tsd_base_offset;
+        uint16_t    plo_pthread_tsd_base_address_offset;
+        uint16_t    plo_pthread_tsd_entry_size;
+
+        LibpthreadOffsets () :
+            plo_version (UINT16_MAX),
+            plo_pthread_tsd_base_offset (UINT16_MAX),
+            plo_pthread_tsd_base_address_offset (UINT16_MAX),
+            plo_pthread_tsd_entry_size (UINT16_MAX)
+        {
+        }
+
+        bool IsValid ()
+        {
+            return plo_version != UINT16_MAX;
+        }
+    };
 
     // The libBacktraceRecording function __introspection_dispatch_queue_get_pending_items has
     // two forms.  It can either return a simple array of item_refs (void *) size or it can return
@@ -225,6 +296,18 @@ private:
     void
     ReadLibdispatchOffsets ();
 
+    void
+    ReadLibpthreadOffsetsAddress();
+
+    void
+    ReadLibpthreadOffsets ();
+
+    void
+    ReadLibdispatchTSDIndexesAddress ();
+
+    void
+    ReadLibdispatchTSDIndexes ();
+
     PendingItemsForQueue
     GetPendingItemRefsForQueue (lldb::addr_t queue);
 
@@ -239,9 +322,19 @@ private:
     lldb::addr_t                        m_page_to_free;
     uint64_t                            m_page_to_free_size;
     libBacktraceRecording_info          m_lib_backtrace_recording_info;
+
     lldb::addr_t                        m_dispatch_queue_offsets_addr;
     struct LibdispatchOffsets           m_libdispatch_offsets;
 
+    lldb::addr_t                        m_libpthread_layout_offsets_addr;
+    struct LibpthreadOffsets            m_libpthread_offsets;
+
+    lldb::addr_t                        m_dispatch_tsd_indexes_addr;
+    struct LibdispatchTSDIndexes        m_libdispatch_tsd_indexes;
+
+    lldb::addr_t                        m_dispatch_voucher_offsets_addr;
+    struct LibdispatchVoucherOffsets    m_libdispatch_voucher_offsets;
+
     DISALLOW_COPY_AND_ASSIGN (SystemRuntimeMacOSX);
 };