EIC code displayed by LXR master/​include/​lldb/​Target/​QueueItem.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:42:54

 //===-- 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

This page was automatically generated by the 2.3.7 LXR engine. The LXR team