clang-r433403/include/lldb/Target/QueueItem.h

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