| //===-- QueueItem.h ---------------------------------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLDB_TARGET_QUEUEITEM_H |
| #define LLDB_TARGET_QUEUEITEM_H |
| |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "lldb/lldb-enumerations.h" |
| #include "lldb/lldb-forward.h" |
| #include "lldb/lldb-private.h" |
| |
| #include "lldb/Core/Address.h" |
| #include "lldb/Utility/ConstString.h" |
| |
| namespace lldb_private { |
| |
| // QueueItem: |
| // This class represents a work item enqueued on a libdispatch aka Grand |
| // Central Dispatch (GCD) queue. Most often, this will be a function or block. |
| // "enqueued" here means that the work item has been added to a queue but it |
| // has not yet started executing. When it is "dequeued", execution of the item |
| // begins. |
| |
| class QueueItem : public std::enable_shared_from_this<QueueItem> { |
| public: |
| QueueItem(lldb::QueueSP queue_sp, lldb::ProcessSP process_sp, |
| lldb::addr_t item_ref, lldb_private::Address address); |
| |
| ~QueueItem(); |
| |
| /// Get the kind of work item this is |
| /// |
| /// \return |
| /// The type of work item that this QueueItem object |
| /// represents. eQueueItemKindUnknown may be returned. |
| lldb::QueueItemKind GetKind(); |
| |
| /// Set the type of work item this is |
| /// |
| /// \param [in] item_kind |
| /// Set the kind of this work item object. |
| void SetKind(lldb::QueueItemKind item_kind); |
| |
| /// Get the code address that will be executed when this work item |
| /// is executed. |
| /// |
| /// \return |
| /// The address that will be invoked when this work item is |
| /// executed. Not all types of QueueItems will have an |
| /// address associated with them; check that the returned |
| /// Address is valid, or check that the WorkItemKind is a |
| /// kind that involves an address, such as eQueueItemKindFunction |
| /// or eQueueItemKindBlock. |
| lldb_private::Address &GetAddress(); |
| |
| /// Set the work item address for this object |
| /// |
| /// \param [in] addr |
| /// The address that will be invoked when this work item |
| /// is executed. |
| void SetAddress(lldb_private::Address addr); |
| |
| /// Check if this QueueItem object is valid |
| /// |
| /// If the weak pointer to the parent Queue cannot be revivified, |
| /// it is invalid. |
| /// |
| /// \return |
| /// True if this object is valid. |
| bool IsValid() { return m_queue_wp.lock() != nullptr; } |
| |
| /// Get an extended backtrace thread for this queue item, if available |
| /// |
| /// If the backtrace/thread information was collected when this item |
| /// was enqueued, this call will provide it. |
| /// |
| /// \param [in] type |
| /// The type of extended backtrace being requested, e.g. "libdispatch" |
| /// or "pthread". |
| /// |
| /// \return |
| /// A thread shared pointer which will have a reference to an extended |
| /// thread if one was available. |
| lldb::ThreadSP GetExtendedBacktraceThread(ConstString type); |
| |
| void SetItemThatEnqueuedThis(lldb::addr_t address_of_item) { |
| m_item_that_enqueued_this_ref = address_of_item; |
| } |
| |
| lldb::addr_t GetItemThatEnqueuedThis(); |
| |
| void SetEnqueueingThreadID(lldb::tid_t tid) { m_enqueueing_thread_id = tid; } |
| |
| lldb::tid_t GetEnqueueingThreadID(); |
| |
| void SetEnqueueingQueueID(lldb::queue_id_t qid) { |
| m_enqueueing_queue_id = qid; |
| } |
| |
| lldb::queue_id_t GetEnqueueingQueueID(); |
| |
| void SetTargetQueueID(lldb::queue_id_t qid) { m_target_queue_id = qid; } |
| |
| void SetStopID(uint32_t stop_id) { m_stop_id = stop_id; } |
| |
| uint32_t GetStopID(); |
| |
| void SetEnqueueingBacktrace(std::vector<lldb::addr_t> backtrace) { |
| m_backtrace = backtrace; |
| } |
| |
| std::vector<lldb::addr_t> &GetEnqueueingBacktrace(); |
| |
| void SetThreadLabel(std::string thread_name) { m_thread_label = thread_name; } |
| |
| std::string GetThreadLabel(); |
| |
| void SetQueueLabel(std::string queue_name) { m_queue_label = queue_name; } |
| |
| std::string GetQueueLabel(); |
| |
| void SetTargetQueueLabel(std::string queue_name) { |
| m_target_queue_label = queue_name; |
| } |
| |
| lldb::ProcessSP GetProcessSP(); |
| |
| protected: |
| void FetchEntireItem(); |
| |
| lldb::QueueWP m_queue_wp; |
| lldb::ProcessWP m_process_wp; |
| |
| lldb::addr_t m_item_ref; // the token we can be used to fetch more information |
| // about this queue item |
| lldb_private::Address m_address; |
| bool m_have_fetched_entire_item; |
| |
| lldb::QueueItemKind m_kind; |
| lldb::addr_t m_item_that_enqueued_this_ref; // a handle that we can pass into |
| // libBacktraceRecording |
| // to get the QueueItem that enqueued this item |
| lldb::tid_t m_enqueueing_thread_id; // thread that enqueued this item |
| lldb::queue_id_t |
| m_enqueueing_queue_id; // Queue that enqueued this item, if it was a queue |
| lldb::queue_id_t m_target_queue_id; |
| uint32_t m_stop_id; // indicates when this backtrace was recorded in time |
| std::vector<lldb::addr_t> m_backtrace; |
| std::string m_thread_label; |
| std::string m_queue_label; |
| std::string m_target_queue_label; |
| |
| private: |
| QueueItem(const QueueItem &) = delete; |
| const QueueItem &operator=(const QueueItem &) = delete; |
| }; |
| |
| } // namespace lldb_private |
| |
| #endif // LLDB_TARGET_QUEUEITEM_H |