lldb/source/Plugins/Trace/intel-pt/TraceCursorIntelPT.cpp

   1 //===-- TraceCursorIntelPT.cpp --------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "TraceCursorIntelPT.h"
  10 #include "DecodedThread.h"
  11 #include "TraceIntelPT.h"
  12 #include <cstdlib>
  13 #include <optional>
  14
  15 using namespace lldb;
  16 using namespace lldb_private;
  17 using namespace lldb_private::trace_intel_pt;
  18 using namespace llvm;
  19
  20 TraceCursorIntelPT::TraceCursorIntelPT(
  21     ThreadSP thread_sp, DecodedThreadSP decoded_thread_sp,
  22     const std::optional<LinuxPerfZeroTscConversion> &tsc_conversion,
  23     std::optional<uint64_t> beginning_of_time_nanos)
  24     : TraceCursor(thread_sp), m_decoded_thread_sp(decoded_thread_sp),
  25       m_tsc_conversion(tsc_conversion),
  26       m_beginning_of_time_nanos(beginning_of_time_nanos) {
  27   Seek(0, lldb::eTraceCursorSeekTypeEnd);
  28 }
  29
  30 void TraceCursorIntelPT::Next() {
  31   m_pos += IsForwards() ? 1 : -1;
  32   ClearTimingRangesIfInvalid();
  33 }
  34
  35 void TraceCursorIntelPT::ClearTimingRangesIfInvalid() {
  36   if (m_tsc_range_calculated) {
  37     if (!m_tsc_range || m_pos < 0 || !m_tsc_range->InRange(m_pos)) {
  38       m_tsc_range = None;
  39       m_tsc_range_calculated = false;
  40     }
  41   }
  42
  43   if (m_nanoseconds_range_calculated) {
  44     if (!m_nanoseconds_range || m_pos < 0 ||
  45         !m_nanoseconds_range->InRange(m_pos)) {
  46       m_nanoseconds_range = None;
  47       m_nanoseconds_range_calculated = false;
  48     }
  49   }
  50 }
  51
  52 const std::optional<DecodedThread::TSCRange> &
  53 TraceCursorIntelPT::GetTSCRange() const {
  54   if (!m_tsc_range_calculated) {
  55     m_tsc_range_calculated = true;
  56     m_tsc_range = m_decoded_thread_sp->GetTSCRangeByIndex(m_pos);
  57   }
  58   return m_tsc_range;
  59 }
  60
  61 const std::optional<DecodedThread::NanosecondsRange> &
  62 TraceCursorIntelPT::GetNanosecondsRange() const {
  63   if (!m_nanoseconds_range_calculated) {
  64     m_nanoseconds_range_calculated = true;
  65     m_nanoseconds_range =
  66         m_decoded_thread_sp->GetNanosecondsRangeByIndex(m_pos);
  67   }
  68   return m_nanoseconds_range;
  69 }
  70
  71 bool TraceCursorIntelPT::Seek(int64_t offset,
  72                               lldb::TraceCursorSeekType origin) {
  73   switch (origin) {
  74   case lldb::eTraceCursorSeekTypeBeginning:
  75     m_pos = offset;
  76     break;
  77   case lldb::eTraceCursorSeekTypeEnd:
  78     m_pos = m_decoded_thread_sp->GetItemsCount() - 1 + offset;
  79     break;
  80   case lldb::eTraceCursorSeekTypeCurrent:
  81     m_pos += offset;
  82   }
  83
  84   ClearTimingRangesIfInvalid();
  85
  86   return HasValue();
  87 }
  88
  89 bool TraceCursorIntelPT::HasValue() const {
  90   return m_pos >= 0 &&
  91          static_cast<uint64_t>(m_pos) < m_decoded_thread_sp->GetItemsCount();
  92 }
  93
  94 lldb::TraceItemKind TraceCursorIntelPT::GetItemKind() const {
  95   return m_decoded_thread_sp->GetItemKindByIndex(m_pos);
  96 }
  97
  98 llvm::StringRef TraceCursorIntelPT::GetError() const {
  99   return m_decoded_thread_sp->GetErrorByIndex(m_pos);
 100 }
 101
 102 lldb::addr_t TraceCursorIntelPT::GetLoadAddress() const {
 103   return m_decoded_thread_sp->GetInstructionLoadAddress(m_pos);
 104 }
 105
 106 std::optional<uint64_t> TraceCursorIntelPT::GetHWClock() const {
 107   if (const std::optional<DecodedThread::TSCRange> &range = GetTSCRange())
 108     return range->tsc;
 109   return std::nullopt;
 110 }
 111
 112 std::optional<double> TraceCursorIntelPT::GetWallClockTime() const {
 113   if (const std::optional<DecodedThread::NanosecondsRange> &range =
 114           GetNanosecondsRange())
 115     return range->GetInterpolatedTime(m_pos, *m_beginning_of_time_nanos,
 116                                       *m_tsc_conversion);
 117   return std::nullopt;
 118 }
 119
 120 lldb::cpu_id_t TraceCursorIntelPT::GetCPU() const {
 121   return m_decoded_thread_sp->GetCPUByIndex(m_pos);
 122 }
 123
 124 lldb::TraceEvent TraceCursorIntelPT::GetEventType() const {
 125   return m_decoded_thread_sp->GetEventByIndex(m_pos);
 126 }
 127
 128 bool TraceCursorIntelPT::GoToId(user_id_t id) {
 129   if (!HasId(id))
 130     return false;
 131   m_pos = id;
 132   ClearTimingRangesIfInvalid();
 133   return true;
 134 }
 135
 136 bool TraceCursorIntelPT::HasId(lldb::user_id_t id) const {
 137   return id < m_decoded_thread_sp->GetItemsCount();
 138 }
 139
 140 user_id_t TraceCursorIntelPT::GetId() const { return m_pos; }
 141
 142 std::optional<std::string> TraceCursorIntelPT::GetSyncPointMetadata() const {
 143   return formatv("offset = 0x{0:x}",
 144                  m_decoded_thread_sp->GetSyncPointOffsetByIndex(m_pos))
 145       .str();
 146 }