//===-- LibiptDecoder.cpp --======-----------------------------------------===//
// 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
//
//===----------------------------------------------------------------------===//
#include "LibiptDecoder.h"
#include "TraceIntelPT.h"
#include "lldb/Target/Process.h"
#include <optional>
using namespace lldb;
using namespace lldb_private;
using namespace lldb_private::trace_intel_pt;
using namespace llvm;
bool IsLibiptError(int status) { return status < 0; }
bool IsEndOfStream(int status) {
assert(status >= 0 && "We can't check if we reached the end of the stream if "
"we got a failed status");
return status & pts_eos;
}
bool HasEvents(int status) {
assert(status >= 0 && "We can't check for events if we got a failed status");
return status & pts_event_pending;
}
// RAII deleter for libipt's decoders
auto InsnDecoderDeleter = [](pt_insn_decoder *decoder) {
pt_insn_free_decoder(decoder);
};
auto QueryDecoderDeleter = [](pt_query_decoder *decoder) {
pt_qry_free_decoder(decoder);
};
using PtInsnDecoderUP =
std::unique_ptr<pt_insn_decoder, decltype(InsnDecoderDeleter)>;
using PtQueryDecoderUP =
std::unique_ptr<pt_query_decoder, decltype(QueryDecoderDeleter)>;
/// Create a basic configuration object limited to a given buffer that can be
/// used for many different decoders.
static Expected<pt_config> CreateBasicLibiptConfig(TraceIntelPT &trace_intel_pt,
ArrayRef<uint8_t> buffer) {
Expected<pt_cpu> cpu_info = trace_intel_pt.GetCPUInfo();
if (!cpu_info)
return cpu_info.takeError();
pt_config config;
pt_config_init(&config);
config.cpu = *cpu_info;
int status = pt_cpu_errata(&config.errata, &config.cpu);
if (IsLibiptError(status))
return make_error<IntelPTError>(status);
// The libipt library does not modify the trace buffer, hence the
// following casts are safe.
config.begin = const_cast<uint8_t *>(buffer.data());
config.end = const_cast<uint8_t *>(buffer.data() + buffer.size());
return config;
}
/// Callback used by libipt for reading the process memory.
///
/// More information can be found in
/// https://github.com/intel/libipt/blob/master/doc/man/pt_image_set_callback.3.md
static int ReadProcessMemory(uint8_t *buffer, size_t size,
const pt_asid * /* unused */, uint64_t pc,
void *context) {
Process *process = static_cast<Process *>(context);
Status error;
int bytes_read = process->ReadMemory(pc, buffer, size, error);
if (error.Fail())
return -pte_nomap;
return bytes_read;
}
/// Set up the memory image callback for the given decoder.
static Error SetupMemoryImage(pt_insn_decoder *decoder, Process &process) {
pt_image *image = pt_insn_get_image(decoder);
int status = pt_image_set_callback(image, ReadProcessMemory, &process);
if (IsLibiptError(status))
return make_error<IntelPTError>(status);
return Error::success();
}
/// Create an instruction decoder for the given buffer and the given process.
static Expected<PtInsnDecoderUP>
CreateInstructionDecoder(TraceIntelPT &trace_intel_pt, ArrayRef<uint8_t> buffer,
Process &process) {
Expected<pt_config> config = CreateBasicLibiptConfig(trace_intel_pt, buffer);
if (!config)
return config.takeError();
pt_insn_decoder *decoder_ptr = pt_insn_alloc_decoder(&*config);
if (!decoder_ptr)
return make_error<IntelPTError>(-pte_nomem);
PtInsnDecoderUP decoder_up(decoder_ptr, InsnDecoderDeleter);
if (Error err = SetupMemoryImage(decoder_ptr, process))
return std::move(err);
return decoder_up;
}
/// Create a query decoder for the given buffer. The query decoder is the
/// highest level decoder that operates directly on packets and doesn't perform
/// actual instruction decoding. That's why it can be useful for inspecting a
/// raw trace without pinning it to a particular process.
static Expected<PtQueryDecoderUP>
CreateQueryDecoder(TraceIntelPT &trace_intel_pt, ArrayRef<uint8_t> buffer) {
Expected<pt_config> config = CreateBasicLibiptConfig(trace_intel_pt, buffer);
if (!config)
return config.takeError();
pt_query_decoder *decoder_ptr = pt_qry_alloc_decoder(&*config);
if (!decoder_ptr)
return make_error<IntelPTError>(-pte_nomem);
return PtQueryDecoderUP(decoder_ptr, QueryDecoderDeleter);
}
/// Class used to identify anomalies in traces, which should often indicate a
/// fatal error in the trace.
class PSBBlockAnomalyDetector {
public:
PSBBlockAnomalyDetector(pt_insn_decoder &decoder,
TraceIntelPT &trace_intel_pt,
DecodedThread &decoded_thread)
: m_decoder(decoder), m_decoded_thread(decoded_thread) {
m_infinite_decoding_loop_threshold =
trace_intel_pt.GetGlobalProperties()
.GetInfiniteDecodingLoopVerificationThreshold();
m_extremely_large_decoding_threshold =
trace_intel_pt.GetGlobalProperties()
.GetExtremelyLargeDecodingThreshold();
m_next_infinite_decoding_loop_threshold =
m_infinite_decoding_loop_threshold;
}
/// \return
/// An \a llvm::Error if an anomaly that includes the last instruction item
/// in the trace, or \a llvm::Error::success otherwise.
Error DetectAnomaly() {
RefreshPacketOffset();
uint64_t insn_added_since_last_packet_offset =
m_decoded_thread.GetTotalInstructionCount() -
m_insn_count_at_last_packet_offset;
// We want to check if we might have fallen in an infinite loop. As this
// check is not a no-op, we want to do it when we have a strong suggestion
// that things went wrong. First, we check how many instructions we have
// decoded since we processed an Intel PT packet for the last time. This
// number should be low, because at some point we should see branches, jumps
// or interrupts that require a new packet to be processed. Once we reach
// certain threshold we start analyzing the trace.
//
// We use the number of decoded instructions since the last Intel PT packet
// as a proxy because, in fact, we don't expect a single packet to give,
// say, 100k instructions. That would mean that there are 100k sequential
// instructions without any single branch, which is highly unlikely, or that
// we found an infinite loop using direct jumps, e.g.
//
// 0x0A: nop or pause
// 0x0C: jump to 0x0A
//
// which is indeed code that is found in the kernel. I presume we reach
// this kind of code in the decoder because we don't handle self-modified
// code in post-mortem kernel traces.
//
// We are right now only signaling the anomaly as a trace error, but it
// would be more conservative to also discard all the trace items found in
// this PSB. I prefer not to do that for the time being to give more
// exposure to this kind of anomalies and help debugging. Discarding the
// trace items would just make investigation harded.
//
// Finally, if the user wants to see if a specific thread has an anomaly,
// it's enough to run the `thread trace dump info` command and look for the
// count of this kind of errors.
if (insn_added_since_last_packet_offset >=
m_extremely_large_decoding_threshold) {
// In this case, we have decoded a massive amount of sequential
// instructions that don't loop. Honestly I wonder if this will ever
// happen, but better safe than sorry.
return createStringError(
inconvertibleErrorCode(),
"anomalous trace: possible infinite trace detected");
}
if (insn_added_since_last_packet_offset ==
m_next_infinite_decoding_loop_threshold) {
if (std::optional<uint64_t> loop_size = TryIdentifyInfiniteLoop()) {
return createStringError(
inconvertibleErrorCode(),
"anomalous trace: possible infinite loop detected of size %" PRIu64,
*loop_size);
}
m_next_infinite_decoding_loop_threshold *= 2;
}
return Error::success();
}
private:
std::optional<uint64_t> TryIdentifyInfiniteLoop() {
// The infinite decoding loops we'll encounter are due to sequential
// instructions that repeat themselves due to direct jumps, therefore in a
// cycle each individual address will only appear once. We use this
// information to detect cycles by finding the last 2 ocurrences of the last
// instruction added to the trace. Then we traverse the trace making sure
// that these two instructions where the ends of a repeating loop.
// This is a utility that returns the most recent instruction index given a
// position in the trace. If the given position is an instruction, that
// position is returned. It skips non-instruction items.
auto most_recent_insn_index =
[&](uint64_t item_index) -> std::optional<uint64_t> {
while (true) {
if (m_decoded_thread.GetItemKindByIndex(item_index) ==
lldb::eTraceItemKindInstruction) {
return item_index;
}
if (item_index == 0)
return std::nullopt;
item_index--;
}
return std::nullopt;
};
// Similar to most_recent_insn_index but skips the starting position.
auto prev_insn_index = [&](uint64_t item_index) -> std::optional<uint64_t> {
if (item_index == 0)
return std::nullopt;
return most_recent_insn_index(item_index - 1);
};
// We first find the most recent instruction.
std::optional<uint64_t> last_insn_index_opt =
*prev_insn_index(m_decoded_thread.GetItemsCount());
if (!last_insn_index_opt)
return std::nullopt;
uint64_t last_insn_index = *last_insn_index_opt;
// We then find the most recent previous occurrence of that last
// instruction.
std::optional<uint64_t> last_insn_copy_index =
prev_insn_index(last_insn_index);
uint64_t loop_size = 1;
while (last_insn_copy_index &&
m_decoded_thread.GetInstructionLoadAddress(*last_insn_copy_index) !=
m_decoded_thread.GetInstructionLoadAddress(last_insn_index)) {
last_insn_copy_index = prev_insn_index(*last_insn_copy_index);
loop_size++;
}
if (!last_insn_copy_index)
return std::nullopt;
// Now we check if the segment between these last positions of the last
// instruction address is in fact a repeating loop.
uint64_t loop_elements_visited = 1;
uint64_t insn_index_a = last_insn_index,
insn_index_b = *last_insn_copy_index;
while (loop_elements_visited < loop_size) {
if (std::optional<uint64_t> prev = prev_insn_index(insn_index_a))
insn_index_a = *prev;
else
return std::nullopt;
if (std::optional<uint64_t> prev = prev_insn_index(insn_index_b))
insn_index_b = *prev;
else
return std::nullopt;
if (m_decoded_thread.GetInstructionLoadAddress(insn_index_a) !=
m_decoded_thread.GetInstructionLoadAddress(insn_index_b))
return std::nullopt;
loop_elements_visited++;
}
return loop_size;
}
// Refresh the internal counters if a new packet offset has been visited
void RefreshPacketOffset() {
lldb::addr_t new_packet_offset;
if (!IsLibiptError(pt_insn_get_offset(&m_decoder, &new_packet_offset)) &&
new_packet_offset != m_last_packet_offset) {
m_last_packet_offset = new_packet_offset;
m_next_infinite_decoding_loop_threshold =
m_infinite_decoding_loop_threshold;
m_insn_count_at_last_packet_offset =
m_decoded_thread.GetTotalInstructionCount();
}
}
pt_insn_decoder &m_decoder;
DecodedThread &m_decoded_thread;
lldb::addr_t m_last_packet_offset = LLDB_INVALID_ADDRESS;
uint64_t m_insn_count_at_last_packet_offset = 0;
uint64_t m_infinite_decoding_loop_threshold;
uint64_t m_next_infinite_decoding_loop_threshold;
uint64_t m_extremely_large_decoding_threshold;
};
/// Class that decodes a raw buffer for a single PSB block using the low level
/// libipt library. It assumes that kernel and user mode instructions are not
/// mixed in the same PSB block.
///
/// Throughout this code, the status of the decoder will be used to identify
/// events needed to be processed or errors in the decoder. The values can be
/// - negative: actual errors
/// - positive or zero: not an error, but a list of bits signaling the status
/// of the decoder, e.g. whether there are events that need to be decoded or
/// not.
class PSBBlockDecoder {
public:
/// \param[in] decoder
/// A decoder configured to start and end within the boundaries of the
/// given \p psb_block.
///
/// \param[in] psb_block
/// The PSB block to decode.
///
/// \param[in] next_block_ip
/// The starting ip at the next PSB block of the same thread if available.
///
/// \param[in] decoded_thread
/// A \a DecodedThread object where the decoded instructions will be
/// appended to. It might have already some instructions.
///
/// \param[in] tsc_upper_bound
/// Maximum allowed value of TSCs decoded from this PSB block.
/// Any of this PSB's data occurring after this TSC will be excluded.
PSBBlockDecoder(PtInsnDecoderUP &&decoder_up, const PSBBlock &psb_block,
std::optional<lldb::addr_t> next_block_ip,
DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
std::optional<DecodedThread::TSC> tsc_upper_bound)
: m_decoder_up(std::move(decoder_up)), m_psb_block(psb_block),
m_next_block_ip(next_block_ip), m_decoded_thread(decoded_thread),
m_anomaly_detector(*m_decoder_up, trace_intel_pt, decoded_thread),
m_tsc_upper_bound(tsc_upper_bound) {}
/// \param[in] trace_intel_pt
/// The main Trace object that own the PSB block.
///
/// \param[in] decoder
/// A decoder configured to start and end within the boundaries of the
/// given \p psb_block.
///
/// \param[in] psb_block
/// The PSB block to decode.
///
/// \param[in] buffer
/// The raw intel pt trace for this block.
///
/// \param[in] process
/// The process to decode. It provides the memory image to use for
/// decoding.
///
/// \param[in] next_block_ip
/// The starting ip at the next PSB block of the same thread if available.
///
/// \param[in] decoded_thread
/// A \a DecodedThread object where the decoded instructions will be
/// appended to. It might have already some instructions.
static Expected<PSBBlockDecoder>
Create(TraceIntelPT &trace_intel_pt, const PSBBlock &psb_block,
ArrayRef<uint8_t> buffer, Process &process,
std::optional<lldb::addr_t> next_block_ip,
DecodedThread &decoded_thread,
std::optional<DecodedThread::TSC> tsc_upper_bound) {
Expected<PtInsnDecoderUP> decoder_up =
CreateInstructionDecoder(trace_intel_pt, buffer, process);
if (!decoder_up)
return decoder_up.takeError();
return PSBBlockDecoder(std::move(*decoder_up), psb_block, next_block_ip,
decoded_thread, trace_intel_pt, tsc_upper_bound);
}
void DecodePSBBlock() {
int status = pt_insn_sync_forward(m_decoder_up.get());
assert(status >= 0 &&
"Synchronization shouldn't fail because this PSB was previously "
"decoded correctly.");
// We emit a TSC before a sync event to more easily associate a timestamp to
// the sync event. If present, the current block's TSC would be the first
// TSC we'll see when processing events.
if (m_psb_block.tsc)
m_decoded_thread.NotifyTsc(*m_psb_block.tsc);
m_decoded_thread.NotifySyncPoint(m_psb_block.psb_offset);
DecodeInstructionsAndEvents(status);
}
private:
/// Append an instruction and return \b false if and only if a serious anomaly
/// has been detected.
bool AppendInstructionAndDetectAnomalies(const pt_insn &insn) {
m_decoded_thread.AppendInstruction(insn);
if (Error err = m_anomaly_detector.DetectAnomaly()) {
m_decoded_thread.AppendCustomError(toString(std::move(err)),
/*fatal=*/true);
return false;
}
return true;
}
/// Decode all the instructions and events of the given PSB block. The
/// decoding loop might stop abruptly if an infinite decoding loop is
/// detected.
void DecodeInstructionsAndEvents(int status) {
pt_insn insn;
while (true) {
status = ProcessPTEvents(status);
if (IsLibiptError(status))
return;
else if (IsEndOfStream(status))
break;
// The status returned by pt_insn_next will need to be processed
// by ProcessPTEvents in the next loop if it is not an error.
std::memset(&insn, 0, sizeof insn);
status = pt_insn_next(m_decoder_up.get(), &insn, sizeof(insn));
if (IsLibiptError(status)) {
m_decoded_thread.AppendError(IntelPTError(status, insn.ip));
return;
} else if (IsEndOfStream(status)) {
break;
}
if (!AppendInstructionAndDetectAnomalies(insn))
return;
}
// We need to keep querying non-branching instructions until we hit the
// starting point of the next PSB. We won't see events at this point. This
// is based on
// https://github.com/intel/libipt/blob/master/doc/howto_libipt.md#parallel-decode
if (m_next_block_ip && insn.ip != 0) {
while (insn.ip != *m_next_block_ip) {
if (!AppendInstructionAndDetectAnomalies(insn))
return;
status = pt_insn_next(m_decoder_up.get(), &insn, sizeof(insn));
if (IsLibiptError(status)) {
m_decoded_thread.AppendError(IntelPTError(status, insn.ip));
return;
}
}
}
}
/// Process the TSC of a decoded PT event. Specifically, check if this TSC
/// is below the TSC upper bound for this PSB. If the TSC exceeds the upper
/// bound, return an error to abort decoding. Otherwise add the it to the
/// underlying DecodedThread and decoding should continue as expected.
///
/// \param[in] tsc
/// The TSC of the a decoded event.
Error ProcessPTEventTSC(DecodedThread::TSC tsc) {
if (m_tsc_upper_bound && tsc >= *m_tsc_upper_bound) {
// This event and all the remaining events of this PSB have a TSC
// outside the range of the "owning" ThreadContinuousExecution. For
// now we drop all of these events/instructions, future work can
// improve upon this by determining the "owning"
// ThreadContinuousExecution of the remaining PSB data.
std::string err_msg = formatv("decoding truncated: TSC {0} exceeds "
"maximum TSC value {1}, will skip decoding"
" the remaining data of the PSB",
tsc, *m_tsc_upper_bound)
.str();
uint64_t offset;
int status = pt_insn_get_offset(m_decoder_up.get(), &offset);
if (!IsLibiptError(status)) {
err_msg = formatv("{2} (skipping {0} of {1} bytes)", offset,
m_psb_block.size, err_msg)
.str();
}
m_decoded_thread.AppendCustomError(err_msg);
return createStringError(inconvertibleErrorCode(), err_msg);
} else {
m_decoded_thread.NotifyTsc(tsc);
return Error::success();
}
}
/// Before querying instructions, we need to query the events associated with
/// that instruction, e.g. timing and trace disablement events.
///
/// \param[in] status
/// The status gotten from the previous instruction decoding or PSB
/// synchronization.
///
/// \return
/// The pte_status after decoding events.
int ProcessPTEvents(int status) {
while (HasEvents(status)) {
pt_event event;
std::memset(&event, 0, sizeof event);
status = pt_insn_event(m_decoder_up.get(), &event, sizeof(event));
if (IsLibiptError(status)) {
m_decoded_thread.AppendError(IntelPTError(status));
return status;
}
if (event.has_tsc) {
if (Error err = ProcessPTEventTSC(event.tsc)) {
consumeError(std::move(err));
return -pte_internal;
}
}
switch (event.type) {
case ptev_disabled:
// The CPU paused tracing the program, e.g. due to ip filtering.
m_decoded_thread.AppendEvent(lldb::eTraceEventDisabledHW);
break;
case ptev_async_disabled:
// The kernel or user code paused tracing the program, e.g.
// a breakpoint or a ioctl invocation pausing the trace, or a
// context switch happened.
m_decoded_thread.AppendEvent(lldb::eTraceEventDisabledSW);
break;
case ptev_overflow:
// The CPU internal buffer had an overflow error and some instructions
// were lost. A OVF packet comes with an FUP packet (harcoded address)
// according to the documentation, so we'll continue seeing instructions
// after this event.
m_decoded_thread.AppendError(IntelPTError(-pte_overflow));
break;
default:
break;
}
}
return status;
}
private:
PtInsnDecoderUP m_decoder_up;
PSBBlock m_psb_block;
std::optional<lldb::addr_t> m_next_block_ip;
DecodedThread &m_decoded_thread;
PSBBlockAnomalyDetector m_anomaly_detector;
std::optional<DecodedThread::TSC> m_tsc_upper_bound;
};
Error lldb_private::trace_intel_pt::DecodeSingleTraceForThread(
DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
ArrayRef<uint8_t> buffer) {
Expected<std::vector<PSBBlock>> blocks =
SplitTraceIntoPSBBlock(trace_intel_pt, buffer, /*expect_tscs=*/false);
if (!blocks)
return blocks.takeError();
for (size_t i = 0; i < blocks->size(); i++) {
PSBBlock &block = blocks->at(i);
Expected<PSBBlockDecoder> decoder = PSBBlockDecoder::Create(
trace_intel_pt, block, buffer.slice(block.psb_offset, block.size),
*decoded_thread.GetThread()->GetProcess(),
i + 1 < blocks->size() ? blocks->at(i + 1).starting_ip : std::nullopt,
decoded_thread, std::nullopt);
if (!decoder)
return decoder.takeError();
decoder->DecodePSBBlock();
}
return Error::success();
}
Error lldb_private::trace_intel_pt::DecodeSystemWideTraceForThread(
DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
const DenseMap<lldb::cpu_id_t, llvm::ArrayRef<uint8_t>> &buffers,
const std::vector<IntelPTThreadContinousExecution> &executions) {
bool has_seen_psbs = false;
for (size_t i = 0; i < executions.size(); i++) {
const IntelPTThreadContinousExecution &execution = executions[i];
auto variant = execution.thread_execution.variant;
// We emit the first valid tsc
if (execution.psb_blocks.empty()) {
decoded_thread.NotifyTsc(execution.thread_execution.GetLowestKnownTSC());
} else {
assert(execution.psb_blocks.front().tsc &&
"per cpu decoding expects TSCs");
decoded_thread.NotifyTsc(
std::min(execution.thread_execution.GetLowestKnownTSC(),
*execution.psb_blocks.front().tsc));
}
// We then emit the CPU, which will be correctly associated with a tsc.
decoded_thread.NotifyCPU(execution.thread_execution.cpu_id);
// If we haven't seen a PSB yet, then it's fine not to show errors
if (has_seen_psbs) {
if (execution.psb_blocks.empty()) {
decoded_thread.AppendCustomError(
formatv("Unable to find intel pt data a thread "
"execution on cpu id = {0}",
execution.thread_execution.cpu_id)
.str());
}
// A hinted start is a non-initial execution that doesn't have a switch
// in. An only end is an initial execution that doesn't have a switch in.
// Any of those cases represent a gap because we have seen a PSB before.
if (variant == ThreadContinuousExecution::Variant::HintedStart ||
variant == ThreadContinuousExecution::Variant::OnlyEnd) {
decoded_thread.AppendCustomError(
formatv("Unable to find the context switch in for a thread "
"execution on cpu id = {0}",
execution.thread_execution.cpu_id)
.str());
}
}
for (size_t j = 0; j < execution.psb_blocks.size(); j++) {
const PSBBlock &psb_block = execution.psb_blocks[j];
Expected<PSBBlockDecoder> decoder = PSBBlockDecoder::Create(
trace_intel_pt, psb_block,
buffers.lookup(execution.thread_execution.cpu_id)
.slice(psb_block.psb_offset, psb_block.size),
*decoded_thread.GetThread()->GetProcess(),
j + 1 < execution.psb_blocks.size()
? execution.psb_blocks[j + 1].starting_ip
: std::nullopt,
decoded_thread, execution.thread_execution.GetEndTSC());
if (!decoder)
return decoder.takeError();
has_seen_psbs = true;
decoder->DecodePSBBlock();
}
// If we haven't seen a PSB yet, then it's fine not to show errors
if (has_seen_psbs) {
// A hinted end is a non-ending execution that doesn't have a switch out.
// An only start is an ending execution that doesn't have a switch out.
// Any of those cases represent a gap if we still have executions to
// process and we have seen a PSB before.
if (i + 1 != executions.size() &&
(variant == ThreadContinuousExecution::Variant::OnlyStart ||
variant == ThreadContinuousExecution::Variant::HintedEnd)) {
decoded_thread.AppendCustomError(
formatv("Unable to find the context switch out for a thread "
"execution on cpu id = {0}",
execution.thread_execution.cpu_id)
.str());
}
}
}
return Error::success();
}
bool IntelPTThreadContinousExecution::operator<(
const IntelPTThreadContinousExecution &o) const {
// As the context switch might be incomplete, we look first for the first real
// PSB packet, which is a valid TSC. Otherwise, We query the thread execution
// itself for some tsc.
auto get_tsc = [](const IntelPTThreadContinousExecution &exec) {
return exec.psb_blocks.empty() ? exec.thread_execution.GetLowestKnownTSC()
: exec.psb_blocks.front().tsc;
};
return get_tsc(*this) < get_tsc(o);
}
Expected<std::vector<PSBBlock>>
lldb_private::trace_intel_pt::SplitTraceIntoPSBBlock(
TraceIntelPT &trace_intel_pt, llvm::ArrayRef<uint8_t> buffer,
bool expect_tscs) {
// This follows
// https://github.com/intel/libipt/blob/master/doc/howto_libipt.md#parallel-decode
Expected<PtQueryDecoderUP> decoder_up =
CreateQueryDecoder(trace_intel_pt, buffer);
if (!decoder_up)
return decoder_up.takeError();
pt_query_decoder *decoder = decoder_up.get().get();
std::vector<PSBBlock> executions;
while (true) {
uint64_t maybe_ip = LLDB_INVALID_ADDRESS;
int decoding_status = pt_qry_sync_forward(decoder, &maybe_ip);
if (IsLibiptError(decoding_status))
break;
uint64_t psb_offset;
int offset_status = pt_qry_get_sync_offset(decoder, &psb_offset);
assert(offset_status >= 0 &&
"This can't fail because we were able to synchronize");
std::optional<uint64_t> ip;
if (!(pts_ip_suppressed & decoding_status))
ip = maybe_ip;
std::optional<uint64_t> tsc;
// Now we fetch the first TSC that comes after the PSB.
while (HasEvents(decoding_status)) {
pt_event event;
decoding_status = pt_qry_event(decoder, &event, sizeof(event));
if (IsLibiptError(decoding_status))
break;
if (event.has_tsc) {
tsc = event.tsc;
break;
}
}
if (IsLibiptError(decoding_status)) {
// We continue to the next PSB. This effectively merges this PSB with the
// previous one, and that should be fine because this PSB might be the
// direct continuation of the previous thread and it's better to show an
// error in the decoded thread than to hide it. If this is the first PSB,
// we are okay losing it. Besides that, an error at processing events
// means that we wouldn't be able to get any instruction out of it.
continue;
}
if (expect_tscs && !tsc)
return createStringError(inconvertibleErrorCode(),
"Found a PSB without TSC.");
executions.push_back({
psb_offset,
tsc,
0,
ip,
});
}
if (!executions.empty()) {
// We now adjust the sizes of each block
executions.back().size = buffer.size() - executions.back().psb_offset;
for (int i = (int)executions.size() - 2; i >= 0; i--) {
executions[i].size =
executions[i + 1].psb_offset - executions[i].psb_offset;
}
}
return executions;
}
Expected<std::optional<uint64_t>>
lldb_private::trace_intel_pt::FindLowestTSCInTrace(TraceIntelPT &trace_intel_pt,
ArrayRef<uint8_t> buffer) {
Expected<PtQueryDecoderUP> decoder_up =
CreateQueryDecoder(trace_intel_pt, buffer);
if (!decoder_up)
return decoder_up.takeError();
pt_query_decoder *decoder = decoder_up.get().get();
uint64_t ip = LLDB_INVALID_ADDRESS;
int status = pt_qry_sync_forward(decoder, &ip);
if (IsLibiptError(status))
return std::nullopt;
while (HasEvents(status)) {
pt_event event;
status = pt_qry_event(decoder, &event, sizeof(event));
if (IsLibiptError(status))
return std::nullopt;
if (event.has_tsc)
return event.tsc;
}
return std::nullopt;
}
