1 //===-- QueueItem.h ---------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef liblldb_QueueItem_h_ 11 #define liblldb_QueueItem_h_ 12 13 #include <vector> 14 15 #include "lldb/lldb-private.h" 16 #include "lldb/lldb-enumerations.h" 17 18 #include "lldb/Core/Address.h" 19 #include "lldb/Core/ConstString.h" 20 21 22 namespace lldb_private { 23 24 //------------------------------------------------------------------ 25 // QueueItem: 26 // This class represents a work item enqueued on a libdispatch aka 27 // Grand Central Dispatch (GCD) queue. Most often, this will be a 28 // function or block. 29 // "enqueued" here means that the work item has been added to a queue 30 // but it has not yet started executing. When it is "dequeued", 31 // execution of the item begins. 32 //------------------------------------------------------------------ 33 34 35 class QueueItem : 36 public std::enable_shared_from_this<QueueItem> 37 { 38 public: 39 40 QueueItem (lldb::QueueSP queue_sp); 41 42 ~QueueItem (); 43 44 //------------------------------------------------------------------ 45 /// Get the kind of work item this is 46 /// 47 /// @return 48 /// The type of work item that this QueueItem object 49 /// represents. eQueueItemKindUnknown may be returned. 50 //------------------------------------------------------------------ 51 lldb::QueueItemKind 52 GetKind () const; 53 54 //------------------------------------------------------------------ 55 /// Set the type of work item this is 56 /// 57 /// @param [in] item_kind 58 /// Set the kind of this work item object. 59 //------------------------------------------------------------------ 60 void 61 SetKind (lldb::QueueItemKind item_kind); 62 63 //------------------------------------------------------------------ 64 /// Get the code address that will be executed when this work item 65 /// is executed. 66 /// 67 /// @return 68 /// The address that will be invoked when this work item is 69 /// executed. Not all types of QueueItems will have an 70 /// address associated with them; check that the returned 71 /// Address is valid, or check that the WorkItemKind is a 72 /// kind that involves an address, such as eQueueItemKindFunction 73 /// or eQueueItemKindBlock. 74 //------------------------------------------------------------------ 75 lldb_private::Address & 76 GetAddress (); 77 78 //------------------------------------------------------------------ 79 /// Set the work item address for this object 80 /// 81 /// @param [in] addr 82 /// The address that will be invoked when this work item 83 /// is executed. 84 //------------------------------------------------------------------ 85 void 86 SetAddress (lldb_private::Address addr); 87 88 //------------------------------------------------------------------ 89 /// Check if this QueueItem object is valid 90 /// 91 /// If the weak pointer to the parent Queue cannot be revivified, 92 /// it is invalid. 93 /// 94 /// @return 95 /// True if this object is valid. 96 //------------------------------------------------------------------ 97 bool IsValid()98 IsValid () 99 { 100 return m_queue_wp.lock() != NULL; 101 } 102 103 //------------------------------------------------------------------ 104 /// Get an extended backtrace thread for this queue item, if available 105 /// 106 /// If the backtrace/thread information was collected when this item 107 /// was enqueued, this call will provide it. 108 /// 109 /// @param [in] type 110 /// The type of extended backtrace being requested, e.g. "libdispatch" 111 /// or "pthread". 112 /// 113 /// @return 114 /// A thread shared pointer which will have a reference to an extended 115 /// thread if one was available. 116 //------------------------------------------------------------------ 117 lldb::ThreadSP 118 GetExtendedBacktraceThread (ConstString type); 119 120 void SetItemThatEnqueuedThis(lldb::addr_t address_of_item)121 SetItemThatEnqueuedThis (lldb::addr_t address_of_item) 122 { 123 m_item_that_enqueued_this_ref = address_of_item; 124 } 125 126 lldb::addr_t GetItemThatEnqueuedThis()127 GetItemThatEnqueuedThis () 128 { 129 return m_item_that_enqueued_this_ref; 130 } 131 132 void SetEnqueueingThreadID(lldb::tid_t tid)133 SetEnqueueingThreadID (lldb::tid_t tid) 134 { 135 m_enqueueing_thread_id = tid; 136 } 137 138 lldb::tid_t GetEnqueueingThreadID()139 GetEnqueueingThreadID () 140 { 141 return m_enqueueing_thread_id; 142 } 143 144 void SetEnqueueingQueueID(lldb::queue_id_t qid)145 SetEnqueueingQueueID (lldb::queue_id_t qid) 146 { 147 m_enqueueing_queue_id = qid; 148 } 149 150 lldb::queue_id_t GetEnqueueingQueueID()151 GetEnqueueingQueueID () 152 { 153 return m_enqueueing_queue_id; 154 } 155 156 void SetTargetQueueID(lldb::queue_id_t qid)157 SetTargetQueueID (lldb::queue_id_t qid) 158 { 159 m_target_queue_id = qid; 160 } 161 162 void SetStopID(uint32_t stop_id)163 SetStopID (uint32_t stop_id) 164 { 165 m_stop_id = stop_id; 166 } 167 168 uint32_t GetStopID()169 GetStopID () 170 { 171 return m_stop_id; 172 } 173 174 void SetEnqueueingBacktrace(std::vector<lldb::addr_t> backtrace)175 SetEnqueueingBacktrace (std::vector<lldb::addr_t> backtrace) 176 { 177 m_backtrace = backtrace; 178 } 179 180 std::vector<lldb::addr_t> & GetEnqueueingBacktrace()181 GetEnqueueingBacktrace () 182 { 183 return m_backtrace; 184 } 185 186 void SetThreadLabel(std::string thread_name)187 SetThreadLabel (std::string thread_name) 188 { 189 m_thread_label = thread_name; 190 } 191 192 std::string GetThreadLabel()193 GetThreadLabel () 194 { 195 return m_thread_label; 196 } 197 198 void SetQueueLabel(std::string queue_name)199 SetQueueLabel (std::string queue_name) 200 { 201 m_queue_label = queue_name; 202 } 203 204 std::string GetQueueLabel()205 GetQueueLabel () 206 { 207 return m_queue_label; 208 } 209 210 void SetTargetQueueLabel(std::string queue_name)211 SetTargetQueueLabel (std::string queue_name) 212 { 213 m_target_queue_label = queue_name; 214 } 215 216 protected: 217 lldb::QueueWP m_queue_wp; 218 lldb::QueueItemKind m_kind; 219 lldb_private::Address m_address; 220 221 lldb::addr_t m_item_that_enqueued_this_ref; // a handle that we can pass into libBacktraceRecording 222 // to get the QueueItem that enqueued this item 223 lldb::tid_t m_enqueueing_thread_id; // thread that enqueued this item 224 lldb::queue_id_t m_enqueueing_queue_id; // Queue that enqueued this item, if it was a queue 225 lldb::queue_id_t m_target_queue_id; 226 uint32_t m_stop_id; // indicates when this backtrace was recorded in time 227 std::vector<lldb::addr_t> m_backtrace; 228 std::string m_thread_label; 229 std::string m_queue_label; 230 std::string m_target_queue_label; 231 232 233 private: 234 //------------------------------------------------------------------ 235 // For QueueItem only 236 //------------------------------------------------------------------ 237 238 DISALLOW_COPY_AND_ASSIGN (QueueItem); 239 240 }; 241 242 } // namespace lldb_private 243 244 #endif // liblldb_QueueItem_h_ 245