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

11 files changed, 740 insertions, 1 deletions

diff --git a/lldb/source/API/CMakeLists.txt b/lldb/source/API/CMakeLists.txt
index ac7a484978f..560167e2853 100644
--- a/lldb/source/API/CMakeLists.txt
+++ b/lldb/source/API/CMakeLists.txt
@@ -30,6 +30,8 @@ add_lldb_library(lldbAPI
   SBModuleSpec.cpp
   SBPlatform.cpp
   SBProcess.cpp
+  SBQueue.cpp
+  SBQueueItem.cpp
   SBSection.cpp
   SBSourceManager.cpp
   SBStream.cpp
diff --git a/lldb/source/API/SBProcess.cpp b/lldb/source/API/SBProcess.cpp
index 557006f2434..235388b5f25 100644
--- a/lldb/source/API/SBProcess.cpp
+++ b/lldb/source/API/SBProcess.cpp
@@ -535,6 +535,53 @@ SBProcess::GetThreadAtIndex (size_t index)
 }
 
 uint32_t
+SBProcess::GetNumQueues ()
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+
+    uint32_t num_queues = 0;
+    ProcessSP process_sp(GetSP());
+    if (process_sp)
+    {
+        Process::StopLocker stop_locker;
+        
+        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        num_queues = process_sp->GetQueueList().GetSize();
+    }
+
+    if (log)
+        log->Printf ("SBProcess(%p)::GetNumQueues () => %d", process_sp.get(), num_queues);
+
+    return num_queues;
+}
+
+SBQueue
+SBProcess::GetQueueAtIndex (size_t index)
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+
+    SBQueue sb_queue;
+    QueueSP queue_sp;
+    ProcessSP process_sp(GetSP());
+    if (process_sp)
+    {
+        Process::StopLocker stop_locker;
+        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index);
+        sb_queue.SetQueue (queue_sp);
+    }
+
+    if (log)
+    {
+        log->Printf ("SBProcess(%p)::GetQueueAtIndex (index=%d) => SBQueue(%p)",
+                     process_sp.get(), (uint32_t) index, queue_sp.get());
+    }
+
+    return sb_queue;
+}
+
+
+uint32_t
 SBProcess::GetStopID(bool include_expression_stops)
 {
     ProcessSP process_sp(GetSP());
diff --git a/lldb/source/API/SBQueue.cpp b/lldb/source/API/SBQueue.cpp
new file mode 100644
index 00000000000..58e3fcc495f
--- /dev/null
+++ b/lldb/source/API/SBQueue.cpp
@@ -0,0 +1,256 @@
+//===-- SBQueue.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/lldb-python.h"
+
+#include "lldb/API/SBQueue.h"
+
+#include "lldb/API/SBProcess.h"
+#include "lldb/API/SBThread.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Queue.h"
+#include "lldb/Target/QueueItem.h"
+#include "lldb/Target/Thread.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+//----------------------------------------------------------------------
+// Constructors
+//----------------------------------------------------------------------
+SBQueue::SBQueue () :
+    m_queue_wp(),
+    m_threads(),
+    m_thread_list_fetched(false),
+    m_items(),
+    m_queue_items_fetched(false)
+{
+}
+
+SBQueue::SBQueue (const QueueSP& queue_sp) :
+    m_queue_wp(queue_sp),
+    m_threads(),
+    m_thread_list_fetched(false),
+    m_items(),
+    m_queue_items_fetched(false)
+{
+}
+
+//----------------------------------------------------------------------
+// Destructor
+//----------------------------------------------------------------------
+SBQueue::~SBQueue()
+{
+    m_threads.clear();
+    m_items.clear();
+}
+
+bool
+SBQueue::IsValid() const
+{
+    QueueSP queue_sp = m_queue_wp.lock();
+    return queue_sp.get() != NULL;
+}
+
+
+void
+SBQueue::Clear ()
+{
+    m_queue_wp.reset();
+    m_thread_list_fetched = false;
+    m_threads.clear();
+    m_queue_items_fetched = false;
+    m_items.clear();
+}
+
+
+void
+SBQueue::SetQueue (const QueueSP& queue_sp)
+{
+    m_queue_wp = queue_sp;
+    m_thread_list_fetched = false;
+    m_threads.clear();
+    m_queue_items_fetched = false;
+    m_items.clear();
+}
+
+lldb::queue_id_t
+SBQueue::GetQueueID () const
+{
+    queue_id_t result = LLDB_INVALID_QUEUE_ID;
+    QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp)
+    {
+        result = queue_sp->GetID();
+    }
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+    if (log)
+        log->Printf ("SBQueue(%p)::GetQueueID () => 0x%" PRIx64, this, result);
+    return result;
+}
+
+uint32_t
+SBQueue::GetIndexID () const
+{
+    uint32_t result = LLDB_INVALID_INDEX32;
+    QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp)
+    {
+        result = queue_sp->GetIndexID();
+    }
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+    if (log)
+        log->Printf ("SBQueue(%p)::GetIndexID () => %d", this, result);
+    return result;
+}
+
+const char *
+SBQueue::GetName () const
+{
+    const char *name = NULL;
+    QueueSP queue_sp = m_queue_wp.lock ();
+    if (queue_sp.get())
+    {
+        name = queue_sp->GetName();
+    }
+
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+    if (log)
+        log->Printf ("SBQueue(%p)::GetName () => %s", this, name ? name : "NULL");
+
+    return name;
+}
+
+void
+SBQueue::FetchThreads ()
+{
+    if (m_thread_list_fetched == false)
+    {
+        QueueSP queue_sp = m_queue_wp.lock();
+        if (queue_sp)
+        {
+            Process::StopLocker stop_locker;
+            if (stop_locker.TryLock (&queue_sp->GetProcess()->GetRunLock()))
+            {
+                const std::vector<ThreadSP> thread_list(queue_sp->GetThreads());
+                m_thread_list_fetched = true;
+                const uint32_t num_threads = thread_list.size();
+                for (uint32_t idx = 0; idx < num_threads; ++idx)
+                {
+                    ThreadSP thread_sp = thread_list[idx];
+                    if (thread_sp && thread_sp->IsValid())
+                    {
+                        m_threads.push_back (thread_sp);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void
+SBQueue::FetchItems ()
+{
+    if (m_queue_items_fetched == false)
+    {
+        QueueSP queue_sp = m_queue_wp.lock();
+        if (queue_sp)
+        {
+            Process::StopLocker stop_locker;
+            if (stop_locker.TryLock (&queue_sp->GetProcess()->GetRunLock()))
+            {
+                const std::vector<QueueItemSP> queue_items(queue_sp->GetItems());
+                m_queue_items_fetched = true;
+                const uint32_t num_items = queue_items.size();
+                for (uint32_t idx = 0; idx < num_items; ++idx)
+                {
+                    QueueItemSP item = queue_items[idx];
+                    if (item && item->IsValid())
+                    {
+                        m_items.push_back (item);
+                    }
+                }
+            }
+        }
+    }
+}
+
+uint32_t
+SBQueue::GetNumThreads ()
+{
+    uint32_t result = 0;
+
+    FetchThreads();
+    if (m_thread_list_fetched)
+    {
+        result = m_threads.size();
+    }
+    return result;
+}
+
+SBThread
+SBQueue::GetThreadAtIndex (uint32_t idx)
+{
+    FetchThreads();
+
+    SBThread sb_thread;
+    QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp && idx < m_threads.size())
+    {
+        ProcessSP process_sp = queue_sp->GetProcess();
+        if (process_sp)
+        {
+            ThreadSP thread_sp = m_threads[idx].lock();
+            if (thread_sp)
+            {
+                sb_thread.SetThread (thread_sp);
+            }
+        }
+    }
+    return sb_thread;
+}
+
+
+uint32_t
+SBQueue::GetNumItems ()
+{
+    uint32_t result = 0;
+    FetchItems();
+
+    if (m_queue_items_fetched)
+    {
+        result = m_items.size();
+    }
+    return result;
+}
+
+SBQueueItem
+SBQueue::GetItemAtIndex (uint32_t idx)
+{
+    SBQueueItem result;
+    FetchItems();
+    if (m_queue_items_fetched && idx < m_items.size())
+    {
+        result.SetQueueItem (m_items[idx]);
+    }
+    return result;
+}
+
+SBProcess
+SBQueue::GetProcess ()
+{
+    SBProcess result;
+    QueueSP queue_sp = m_queue_wp.lock();
+    if (queue_sp)
+    {
+        result.SetSP (queue_sp->GetProcess());
+    }
+    return result;
+}
diff --git a/lldb/source/API/SBQueueItem.cpp b/lldb/source/API/SBQueueItem.cpp
new file mode 100644
index 00000000000..b68c40b3e02
--- /dev/null
+++ b/lldb/source/API/SBQueueItem.cpp
@@ -0,0 +1,119 @@
+//===-- SBQueueItem.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/lldb-python.h"
+#include "lldb/lldb-forward.h"
+
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBQueueItem.h"
+#include "lldb/API/SBThread.h"
+#include "lldb/Core/Address.h"
+#include "lldb/Target/QueueItem.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+//----------------------------------------------------------------------
+// Constructors
+//----------------------------------------------------------------------
+SBQueueItem::SBQueueItem () :
+    m_queue_item_sp()
+{
+}
+
+SBQueueItem::SBQueueItem (const QueueItemSP& queue_item_sp) :
+    m_queue_item_sp (queue_item_sp)
+{
+}
+
+//----------------------------------------------------------------------
+// Destructor
+//----------------------------------------------------------------------
+SBQueueItem::~SBQueueItem()
+{
+    m_queue_item_sp.reset();
+}
+
+bool
+SBQueueItem::IsValid() const
+{
+    return m_queue_item_sp.get() != NULL;
+}
+
+
+void
+SBQueueItem::Clear ()
+{
+    m_queue_item_sp.reset();
+}
+
+
+void
+SBQueueItem::SetQueueItem (const QueueItemSP& queue_item_sp)
+{
+    m_queue_item_sp = queue_item_sp;
+}
+
+
+lldb::QueueItemKind
+SBQueueItem::GetKind () const
+{
+    QueueItemKind result = eQueueItemKindUnknown;
+    if (m_queue_item_sp)
+    {
+        result = m_queue_item_sp->GetKind ();
+    }
+    return result;
+}
+
+void
+SBQueueItem::SetKind (lldb::QueueItemKind kind)
+{
+    if (m_queue_item_sp)
+    {
+        m_queue_item_sp->SetKind (kind);
+    }
+}
+
+SBAddress
+SBQueueItem::GetAddress () const
+{
+    SBAddress result;
+    if (m_queue_item_sp)
+    {
+        result.SetAddress (&m_queue_item_sp->GetAddress());
+    }
+    return result;
+}
+
+void
+SBQueueItem::SetAddress (SBAddress addr)
+{
+    if (m_queue_item_sp)
+    {
+        m_queue_item_sp->SetAddress (addr.ref());
+    }
+}
+
+SBThread
+SBQueueItem::GetExtendedBacktraceThread (const char *type)
+{
+    SBThread result;
+    if (m_queue_item_sp)
+    {
+        ThreadSP thread_sp;
+        ConstString type_const (type);
+        thread_sp = m_queue_item_sp->GetExtendedBacktraceThread (type_const);
+        if (thread_sp)
+        {
+            result.SetThread (thread_sp);
+        }
+    }
+    return result;
+}
diff --git a/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp b/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp
index 388264a2d95..5756e7071d7 100644
--- a/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp
+++ b/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp
@@ -22,10 +22,11 @@
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "Plugins/Process/Utility/HistoryThread.h"
+#include "lldb/Target/Queue.h"
+#include "lldb/Target/QueueList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
-
 #include "SystemRuntimeMacOSX.h"
 
 using namespace lldb;
@@ -443,6 +444,26 @@ SystemRuntimeMacOSX::GetExtendedBacktraceThread (ThreadSP original_thread_sp, Co
     return new_extended_thread_sp;
 }
 
+void
+SystemRuntimeMacOSX::PopulateQueueList (lldb_private::QueueList &queue_list)
+{
+    // For now, iterate over the threads and see what queue each thread is associated with.
+    // If we haven't already added this queue, add it to the QueueList.
+    // (a single libdispatch queue may be using multiple threads simultaneously.)
+
+    for (ThreadSP thread_sp : m_process->Threads())
+    {
+        if (thread_sp->GetQueueID() != LLDB_INVALID_QUEUE_ID)
+        {
+            if (queue_list.FindQueueByID (thread_sp->GetQueueID()).get() == NULL)
+            {
+                QueueSP queue_sp (new Queue(m_process->shared_from_this(), thread_sp->GetQueueID(), thread_sp->GetQueueName()));
+                queue_list.AddQueue (queue_sp);
+            }
+        }
+    }
+}
+
 
 void
 SystemRuntimeMacOSX::Initialize()
diff --git a/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h b/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h
index c472bee8572..4c684fee7b2 100644
--- a/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h
+++ b/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h
@@ -104,6 +104,9 @@ private:
     SystemRuntimeMacOSX::ArchivedBacktrace
     GetLibdispatchExtendedBacktrace (lldb::ThreadSP thread);
 
+    void
+    PopulateQueueList (lldb_private::QueueList &queue_list);
+
 protected:
     lldb::user_id_t m_break_id;
     mutable lldb_private::Mutex m_mutex;
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;
+}