Add new Queue, QueueItem, Queuelist, SBQueue, SBQueueItem classes to represent

libdispatch aka Grand Central Dispatch (GCD) queues.  Still fleshing out the
documentation and testing of these but the overall API is settling down so it's
a good time to check it in.
<rdar://problem/15600370> 

llvm-svn: 197190

5 files changed, 291 insertions, 0 deletions

diff --git a/lldb/source/Target/CMakeLists.txt b/lldb/source/Target/CMakeLists.txt
index 1ba01ea1dc7..fb7badbae26 100644
--- a/lldb/source/Target/CMakeLists.txt
+++ b/lldb/source/Target/CMakeLists.txt
@@ -13,6 +13,9 @@ add_lldb_library(lldbTarget
   PathMappingList.cpp
   Platform.cpp
   Process.cpp
+  Queue.cpp
+  QueueItem.cpp
+  QueueList.cpp
   RegisterContext.cpp
   SectionLoadHistory.cpp
   SectionLoadList.cpp
diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp
index 1de322aee14..81e12a3b2f7 100644
--- a/lldb/source/Target/Process.cpp
+++ b/lldb/source/Target/Process.cpp
@@ -1017,7 +1017,9 @@ Process::Process(Target &target, Listener &listener) :
     m_mod_id (),
     m_process_unique_id(0),
     m_thread_index_id (0),
+    m_queue_index_id (0),
     m_thread_id_to_index_id_map (),
+    m_queue_id_to_index_id_map (),
     m_exit_status (-1),
     m_exit_string (),
     m_thread_mutex (Mutex::eMutexTypeRecursive),
@@ -1025,6 +1027,8 @@ Process::Process(Target &target, Listener &listener) :
     m_thread_list (this),
     m_extended_thread_list (this),
     m_extended_thread_stop_id (0),
+    m_queue_list (this),
+    m_queue_list_stop_id (0),
     m_notifications (),
     m_image_tokens (),
     m_listener (listener),
@@ -1151,6 +1155,8 @@ Process::Finalize()
     m_thread_list_real.Destroy();
     m_thread_list.Destroy();
     m_extended_thread_list.Destroy();
+    m_queue_list.Clear();
+    m_queue_list_stop_id = 0;
     std::vector<Notifications> empty_notifications;
     m_notifications.swap(empty_notifications);
     m_image_tokens.clear();
@@ -1600,12 +1606,32 @@ Process::UpdateThreadListIfNeeded ()
                     // Clear any extended threads that we may have accumulated previously
                     m_extended_thread_list.Clear();
                     m_extended_thread_stop_id = GetLastNaturalStopID ();
+
+                    m_queue_list.Clear();
+                    m_queue_list_stop_id = GetLastNaturalStopID ();
                 }
             }
         }
     }
 }
 
+void
+Process::UpdateQueueListIfNeeded ()
+{
+    if (m_system_runtime_ap.get())
+    {
+        if (m_queue_list.GetSize() == 0 || m_queue_list_stop_id != GetLastNaturalStopID())
+        {
+            const StateType state = GetPrivateState();
+            if (StateIsStoppedState (state, true))
+            {
+                m_system_runtime_ap->PopulateQueueList (m_queue_list);
+                m_queue_list_stop_id = GetLastNaturalStopID();
+            }
+        }
+    }
+}
+
 ThreadSP
 Process::CreateOSPluginThread (lldb::tid_t tid, lldb::addr_t context)
 {
@@ -1653,6 +1679,39 @@ Process::AssignIndexIDToThread(uint64_t thread_id)
     return result;
 }
 
+bool
+Process::HasAssignedIndexIDToQueue(queue_id_t queue_id)
+{
+    std::map<uint64_t, uint32_t>::iterator iterator = m_queue_id_to_index_id_map.find(queue_id);
+    if (iterator == m_queue_id_to_index_id_map.end())
+    {
+        return false;
+    }
+    else
+    {
+        return true;
+    }
+}
+
+uint32_t
+Process::AssignIndexIDToQueue(queue_id_t queue_id)
+{
+    uint32_t result = 0;
+    std::map<uint64_t, uint32_t>::iterator iterator = m_queue_id_to_index_id_map.find(queue_id);
+    if (iterator == m_queue_id_to_index_id_map.end())
+    {
+        result = ++m_queue_index_id;
+        m_queue_id_to_index_id_map[queue_id] = result;
+    }
+    else
+    {
+        result = iterator->second;
+    }
+    
+    return result;
+}
+
+
 StateType
 Process::GetState()
 {
@@ -5680,6 +5739,10 @@ void
 Process::Flush ()
 {
     m_thread_list.Flush();
+    m_extended_thread_list.Flush();
+    m_extended_thread_stop_id =  0;
+    m_queue_list.Clear();
+    m_queue_list_stop_id = 0;
 }
 
 void
diff --git a/lldb/source/Target/Queue.cpp b/lldb/source/Target/Queue.cpp
new file mode 100644
index 00000000000..27f01975e47
--- /dev/null
+++ b/lldb/source/Target/Queue.cpp
@@ -0,0 +1,68 @@
+//===-- Queue.cpp -----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Queue.h"
+#include "lldb/Target/QueueList.h"
+#include "lldb/Target/Thread.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+Queue::Queue (ProcessSP process_sp, lldb::queue_id_t queue_id, const char *queue_name) :
+    m_process_wp (process_sp),
+    m_queue_id (queue_id),
+    m_queue_name (queue_name),
+    m_enqueued_items()
+{
+    m_index_id = process_sp->AssignIndexIDToQueue (queue_id);
+}
+
+Queue::~Queue ()
+{
+}
+
+queue_id_t
+Queue::GetID ()
+{
+    return m_queue_id;
+}
+
+const char *
+Queue::GetName ()
+{
+    const char *result = NULL;
+    if (m_queue_name.size() > 0)
+        result = m_queue_name.c_str();
+    return result;
+}
+
+uint32_t
+Queue::GetIndexID ()
+{
+    return m_index_id;
+}
+
+std::vector<lldb::ThreadSP>
+Queue::GetThreads ()
+{
+    std::vector<ThreadSP> result;
+    ProcessSP process_sp = m_process_wp.lock();
+    if (process_sp.get ())
+    {
+        for (ThreadSP thread_sp : process_sp->Threads())
+        {
+            if (thread_sp->GetQueueID() == m_queue_id)
+            {
+                result.push_back (thread_sp);
+            }
+        }
+    }
+    return result;
+}
diff --git a/lldb/source/Target/QueueItem.cpp b/lldb/source/Target/QueueItem.cpp
new file mode 100644
index 00000000000..3b8d3a5d9c2
--- /dev/null
+++ b/lldb/source/Target/QueueItem.cpp
@@ -0,0 +1,55 @@
+//===-- QueueItem.cpp -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Target/Queue.h"
+#include "lldb/Target/QueueItem.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+QueueItem::QueueItem (QueueSP queue_sp) :
+    m_queue_wp (queue_sp),
+    m_kind (eQueueItemKindUnknown),
+    m_address ()
+{
+}
+
+QueueItem::~QueueItem ()
+{
+}
+
+QueueItemKind
+QueueItem::GetKind() const
+{
+    return m_kind;
+}
+
+void
+QueueItem::SetKind (QueueItemKind item_kind)
+{
+    m_kind = item_kind;
+}
+
+Address &
+QueueItem::GetAddress () 
+{
+    return m_address;
+}
+
+void
+QueueItem::SetAddress (Address addr)
+{
+    m_address = addr;
+}
+
+ThreadSP
+QueueItem::GetExtendedBacktraceThread (ConstString type)
+{
+    return ThreadSP();
+}
diff --git a/lldb/source/Target/QueueList.cpp b/lldb/source/Target/QueueList.cpp
new file mode 100644
index 00000000000..6134f5cc0b2
--- /dev/null
+++ b/lldb/source/Target/QueueList.cpp
@@ -0,0 +1,102 @@
+//===-- QueueList.cpp -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Queue.h"
+#include "lldb/Target/QueueList.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+QueueList::QueueList (Process *process) :
+    m_process (process),
+    m_stop_id (0),
+    m_queues (),
+    m_mutex ()
+{
+}
+
+QueueList::~QueueList ()
+{
+    Clear();
+}
+
+uint32_t
+QueueList::GetSize ()
+{
+    Mutex::Locker locker (m_mutex);
+    return m_queues.size();
+}
+
+lldb::QueueSP
+QueueList::GetQueueAtIndex (uint32_t idx)
+{
+    Mutex::Locker locker (m_mutex);
+    if (idx < m_queues.size())
+    {
+        return m_queues[idx];
+    }
+    else
+    {
+        return QueueSP();
+    }
+}
+
+void
+QueueList::Clear ()
+{
+    Mutex::Locker locker (m_mutex);
+    m_queues.clear();
+}
+
+void
+QueueList::AddQueue (QueueSP queue_sp)
+{
+    Mutex::Locker locker (m_mutex);
+    if (queue_sp.get ())
+    {
+        m_queues.push_back (queue_sp);
+    }
+}
+
+lldb::QueueSP
+QueueList::FindQueueByID (lldb::queue_id_t qid)
+{
+    QueueSP ret;
+    for (QueueSP queue_sp : Queues())
+    {
+        if (queue_sp->GetID() == qid)
+        {
+            ret = queue_sp;
+            break;
+        }
+    }
+    return ret;
+}
+
+lldb::QueueSP
+QueueList::FindQueueByIndexID (uint32_t index_id)
+{
+    QueueSP ret;
+    for (QueueSP queue_sp : Queues())
+    {
+        if (queue_sp->GetIndexID() == index_id)
+        {
+            ret = queue_sp;
+            break;
+        }
+    }
+    return ret;
+}
+
+lldb_private::Mutex &
+QueueList::GetMutex ()
+{
+    return m_mutex;
+}