[trace][intel pt] Create a class for the libipt decoder wrapper

[wallace]

Summary

As we soon will need to decode multiple raw traces for the same thread,
having a class that encapsulates the decoding of a single raw trace is
a stepping stone that will make the coming features easier to implement.

So, I'm creating a LibiptDecoder class with that purpose. I refactored
the code and it's now much more readable. Besides that, more comments
were added. With this new structure, it's also easier to implement unit
tests.

[wallace]

nits

[jj10306]

Overall looks good, just a couple cosmetic things and comments about the plan for multi-buffer, single thread decoding

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

42

"for a single thread"
thinking ahead for the multi-CPU buffer case - this class will be responsible for decoding a single trace buffer, not necessarily a single thread's buffer, right? Also, come multi-buffer time, the notion of DecodeThread in this class will need to be changed to DecodedBuffer or something similar that decouples the decoder from a particular thread.

No need to change this now but wanted to make sure I'm understanding the plan correctly.

104

113

153

254

nice custom deleter (:

lldb/source/Plugins/Trace/intel-pt/LibiptDecoder.h

24

If this file is just a wrapper around Libipt and doesn’t have any context about how LLDB gets a trace (from the aux buffer or a file), should we rename it to ‘DecodeTrace’ and the caller is responsible for providing the trace data in a byte buffer?
In the case of in memory trace, the caller already has the byte buffer. In the case of a file, they could mmap the file and cast it to the appropriate type?

[wallace]

thanks for the gotchas

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

42

Also, come multi-buffer time, the notion of DecodeThread in this class will need to be changed to DecodedBuffer or something similar that decouples the decoder from a particular thread.

Not necessarily. A possibility is that the constructor doesn't accept a DecodedThread. Instead, we could create a new method DecodeUntilThreadIsScheduledOut(decoded_thread, end_tsc_for_this_thread). If we have something like that, we ask this decoder to put all the instructions into the given DecodedThread until a TSC mark is reached, which signals the end of a continuous execution of this thread.

lldb/source/Plugins/Trace/intel-pt/LibiptDecoder.h

24

DecodeTrace is definitely a better name because now we are not showing anymore whether the data comes from a file or just from memory

[wallace]

address comments

lldb/source/Plugins/Trace/intel-pt/CMakeLists.txt

 
 lldb_tablegen(TraceIntelPTCommandOptions.inc -gen-lldb-option-defs
   SOURCE TraceIntelPTOptions.td
   TARGET TraceIntelPTOptionsGen)
 
 add_lldb_library(lldbPluginTraceIntelPT PLUGIN
   CommandObjectTraceStartIntelPT.cpp
   DecodedThread.cpp
-  IntelPTDecoder.cpp
+  LibiptDecoder.cpp
+  ThreadDecoder.cpp
   TraceCursorIntelPT.cpp
   TraceIntelPT.cpp
   TraceIntelPTJSONStructs.cpp
   TraceIntelPTSessionFileParser.cpp
   TraceIntelPTSessionSaver.cpp
 
   LINK_LIBS
     lldbCore

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

 //===-- DecodedThread.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 "DecodedThread.h"
 
 #include <intel-pt.h>
-#include <memory>
 
 #include "TraceCursorIntelPT.h"
-#include "lldb/Utility/StreamString.h"
+
+#include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 char IntelPTError::ID;
 

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

-//===-- IntelPTDecoder.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 "IntelPTDecoder.h"
-
-#include "llvm/Support/MemoryBuffer.h"
-
-#include "../common/ThreadPostMortemTrace.h"
-#include "DecodedThread.h"
-#include "TraceIntelPT.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Core/Section.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Utility/StringExtractor.h"
-#include <utility>
-
-using namespace lldb;
-using namespace lldb_private;
-using namespace lldb_private::trace_intel_pt;
-using namespace llvm;
-
-/// Move the decoder forward to the next synchronization point (i.e. next PSB
-/// packet).
-///
-/// Once the decoder is at that sync. point, it can start decoding instructions.
-///
-/// \return
-///   A negative number with the libipt error if we couldn't synchronize.
-///   Otherwise, a positive number with the synchronization status will be
-///   returned.
-static int FindNextSynchronizationPoint(pt_insn_decoder &decoder) {
-  // Try to sync the decoder. If it fails, then get
-  // the decoder_offset and try to sync again from
-  // the next synchronization point. If the
-  // new_decoder_offset is same as decoder_offset
-  // then we can't move to the next synchronization
-  // point. Otherwise, keep resyncing until either
-  // end of trace stream (eos) is reached or
-  // pt_insn_sync_forward() passes.
-  int errcode = pt_insn_sync_forward(&decoder);
-
-  if (errcode != -pte_eos && errcode < 0) {
-    uint64_t decoder_offset = 0;
-    int errcode_off = pt_insn_get_offset(&decoder, &decoder_offset);
-    if (errcode_off >= 0) { // we could get the offset
-      while (true) {
-        errcode = pt_insn_sync_forward(&decoder);
-        if (errcode >= 0 || errcode == -pte_eos)
-          break;
-
-        uint64_t new_decoder_offset = 0;
-        errcode_off = pt_insn_get_offset(&decoder, &new_decoder_offset);
-        if (errcode_off < 0)
-          break; // We can't further synchronize.
-        else if (new_decoder_offset <= decoder_offset) {
-          // We tried resyncing the decoder and
-          // decoder didn't make any progress because
-          // the offset didn't change. We will not
-          // make any progress further. Hence,
-          // stopping in this situation.
-          break;
-        }
-        // We'll try again starting from a new offset.
-        decoder_offset = new_decoder_offset;
-      }
-    }
-  }
-
-  return errcode;
-}
-
-/// Before querying instructions, we need to query the events associated that
-/// instruction e.g. timing events like ptev_tick, or paging events like
-/// ptev_paging.
-///
-/// \return
-///   0 if there were no errors processing the events, or a negative libipt
-///   error code in case of errors.
-static int ProcessPTEvents(pt_insn_decoder &decoder, int errcode) {
-  while (errcode & pts_event_pending) {
-    pt_event event;
-    errcode = pt_insn_event(&decoder, &event, sizeof(event));
-    if (errcode < 0)
-      return errcode;
-  }
-  return 0;
-}
-
-// Simple struct used by the decoder to keep the state of the most
-// recent TSC and a flag indicating whether TSCs are enabled, not enabled
-// or we just don't yet.
-struct TscInfo {
-  uint64_t tsc = 0;
-  LazyBool has_tsc = eLazyBoolCalculate;
-
-  explicit operator bool() const { return has_tsc == eLazyBoolYes; }
-};
-
-/// Query the decoder for the most recent TSC timestamp and update
-/// tsc_info accordingly.
-void RefreshTscInfo(TscInfo &tsc_info, pt_insn_decoder &decoder,
-                    DecodedThread &decoded_thread) {
-  if (tsc_info.has_tsc == eLazyBoolNo)
-    return;
-
-  uint64_t new_tsc;
-  if (int tsc_error = pt_insn_time(&decoder, &new_tsc, nullptr, nullptr)) {
-    if (tsc_error == -pte_no_time) {
-      // We now know that the trace doesn't support TSC, so we won't try again.
-      // See
-      // https://github.com/intel/libipt/blob/master/doc/man/pt_qry_time.3.md
-      tsc_info.has_tsc = eLazyBoolNo;
-    } else {
-      // We don't add TSC decoding errors in the decoded trace itself to prevent
-      // creating unnecessary gaps, but we can count how many of these errors
-      // happened. In this case we reuse the previous correct TSC we saw, as
-      // it's better than no TSC at all.
-      decoded_thread.RecordTscError(tsc_error);
-    }
-  } else {
-    tsc_info.tsc = new_tsc;
-    tsc_info.has_tsc = eLazyBoolYes;
-  }
-}
-
-static void AppendError(DecodedThread &decoded_thread, Error &&error,
-                        TscInfo &tsc_info) {
-  if (tsc_info)
-    decoded_thread.AppendError(std::move(error), tsc_info.tsc);
-  else
-    decoded_thread.AppendError(std::move(error));
-}
-
-static void AppendInstruction(DecodedThread &decoded_thread,
-                              const pt_insn &insn, TscInfo &tsc_info) {
-  if (tsc_info)
-    decoded_thread.AppendInstruction(insn, tsc_info.tsc);
-  else
-    decoded_thread.AppendInstruction(insn);
-}
-
-/// Decode all the instructions from a configured decoder.
-/// The decoding flow is based on
-/// https://github.com/intel/libipt/blob/master/doc/howto_libipt.md#the-instruction-flow-decode-loop
-/// but with some relaxation to allow for gaps in the trace.
-///
-/// Error codes returned by libipt while decoding are:
-/// - 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
-///
-/// \param[in] decoder
-///   A configured libipt \a pt_insn_decoder.
-static void DecodeInstructions(pt_insn_decoder &decoder,
-                               DecodedThread &decoded_thread) {
-
-  TscInfo tsc_info;
-  // We have this "global" errcode because if it's positive, we'll need
-  // its bits later to process events.
-  int errcode;
-
-  while (true) {
-    if ((errcode = FindNextSynchronizationPoint(decoder)) < 0) {
-      // We signal a gap only if it's not "end of stream"
-      if (errcode != -pte_eos)
-        AppendError(decoded_thread, make_error<IntelPTError>(errcode),
-                    tsc_info);
-      break;
-    }
-
-    // We have synchronized, so we can start decoding
-    // instructions and events.
-    while (true) {
-      if ((errcode = ProcessPTEvents(decoder, errcode)) < 0) {
-        AppendError(decoded_thread, make_error<IntelPTError>(errcode),
-                    tsc_info);
-        break;
-      }
-
-      // We refresh the TSC that might have changed after processing the events.
-      // See
-      // https://github.com/intel/libipt/blob/master/doc/man/pt_evt_next.3.md
-      RefreshTscInfo(tsc_info, decoder, decoded_thread);
-
-      pt_insn insn;
-      if ((errcode = pt_insn_next(&decoder, &insn, sizeof(insn))) < 0) {
-        // We signal a gap only if it's not "end of stream"
-        if (errcode != -pte_eos)
-          AppendError(decoded_thread,
-                      make_error<IntelPTError>(errcode, insn.ip), tsc_info);
-        break;
-      }
-      AppendInstruction(decoded_thread, insn, tsc_info);
-    }
-  }
-}
-
-/// 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;
-}
-
-static void DecodeInMemoryTrace(DecodedThreadSP &decoded_thread_sp,
-                                TraceIntelPT &trace_intel_pt,
-                                MutableArrayRef<uint8_t> buffer) {
-  Expected<pt_cpu> cpu_info = trace_intel_pt.GetCPUInfo();
-  if (!cpu_info) {
-    return decoded_thread_sp->AppendError(cpu_info.takeError());
-  }
-
-  pt_config config;
-  pt_config_init(&config);
-  config.cpu = *cpu_info;
-
-  if (int errcode = pt_cpu_errata(&config.errata, &config.cpu))
-    return decoded_thread_sp->AppendError(make_error<IntelPTError>(errcode));
-
-  config.begin = buffer.data();
-  config.end = buffer.data() + buffer.size();
-
-  pt_insn_decoder *decoder = pt_insn_alloc_decoder(&config);
-  if (!decoder)
-    return decoded_thread_sp->AppendError(make_error<IntelPTError>(-pte_nomem));
-
-  pt_image *image = pt_insn_get_image(decoder);
-
-  int errcode =
-      pt_image_set_callback(image, ReadProcessMemory,
-                            decoded_thread_sp->GetThread()->GetProcess().get());
-  assert(errcode == 0);
-  (void)errcode;
-
-  DecodeInstructions(*decoder, *decoded_thread_sp);
-  pt_insn_free_decoder(decoder);
-}
-// ---------------------------
-
-DecodedThreadSP ThreadDecoder::Decode() {
-  if (!m_decoded_thread.hasValue())
-    m_decoded_thread = DoDecode();
-  return *m_decoded_thread;
-}
-
-// LiveThreadDecoder ====================
-
-LiveThreadDecoder::LiveThreadDecoder(Thread &thread, TraceIntelPT &trace)
-    : m_thread_sp(thread.shared_from_this()), m_trace(trace) {}
-
-DecodedThreadSP LiveThreadDecoder::DoDecode() {
-  DecodedThreadSP decoded_thread_sp =
-      std::make_shared<DecodedThread>(m_thread_sp);
-
-  Expected<std::vector<uint8_t>> buffer =
-      m_trace.GetLiveThreadBuffer(m_thread_sp->GetID());
-  if (!buffer) {
-    decoded_thread_sp->AppendError(buffer.takeError());
-    return decoded_thread_sp;
-  }
-
-  decoded_thread_sp->SetRawTraceSize(buffer->size());
-  DecodeInMemoryTrace(decoded_thread_sp, m_trace,
-                      MutableArrayRef<uint8_t>(*buffer));
-  return decoded_thread_sp;
-}
-
-// PostMortemThreadDecoder =======================
-
-PostMortemThreadDecoder::PostMortemThreadDecoder(
-    const lldb::ThreadPostMortemTraceSP &trace_thread, TraceIntelPT &trace)
-    : m_trace_thread(trace_thread), m_trace(trace) {}
-
-DecodedThreadSP PostMortemThreadDecoder::DoDecode() {
-  DecodedThreadSP decoded_thread_sp =
-      std::make_shared<DecodedThread>(m_trace_thread);
-
-  ErrorOr<std::unique_ptr<MemoryBuffer>> trace_or_error =
-      MemoryBuffer::getFile(m_trace_thread->GetTraceFile().GetPath());
-  if (std::error_code err = trace_or_error.getError()) {
-    decoded_thread_sp->AppendError(errorCodeToError(err));
-    return decoded_thread_sp;
-  }
-
-  MemoryBuffer &trace = **trace_or_error;
-  MutableArrayRef<uint8_t> trace_data(
-      // The libipt library does not modify the trace buffer, hence the
-      // following cast is safe.
-      reinterpret_cast<uint8_t *>(const_cast<char *>(trace.getBufferStart())),
-      trace.getBufferSize());
-  decoded_thread_sp->SetRawTraceSize(trace_data.size());
-
-  DecodeInMemoryTrace(decoded_thread_sp, m_trace, trace_data);
-  return decoded_thread_sp;
-}

lldb/source/Plugins/Trace/intel-pt/LibiptDecoder.h

+//===-- LibiptDecoder.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_SOURCE_PLUGINS_TRACE_LIBIPT_DECODER_H
+#define LLDB_SOURCE_PLUGINS_TRACE_LIBIPT_DECODER_H
+
+#include "intel-pt.h"
+
+#include "DecodedThread.h"
+#include "forward-declarations.h"
+
+namespace lldb_private {
+namespace trace_intel_pt {
+
+/// Decode a raw Intel PT trace given in \p buffer and append the decoded
+/// instructions and errors in \p decoded_thread. It uses the low level libipt
+/// library underneath.
+void DecodeTrace(DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
+                 llvm::MutableArrayRef<uint8_t> buffer);
+
+} // namespace trace_intel_pt
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_TRACE_LIBIPT_DECODER_H

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

+//===-- 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"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::trace_intel_pt;
+using namespace llvm;
+
+// Simple struct used by the decoder to keep the state of the most
+// recent TSC and a flag indicating whether TSCs are enabled, not enabled
+// or we just don't yet.
+struct TscInfo {
+  uint64_t tsc = 0;
+  LazyBool has_tsc = eLazyBoolCalculate;
+
+  explicit operator bool() const { return has_tsc == eLazyBoolYes; }
+};
+
+static inline bool IsLibiptError(int libipt_status) {
+  return libipt_status < 0;
+}
+
+static inline bool IsEndOfStream(int libipt_status) {
+  return libipt_status == -pte_eos;
+}
+
+static inline bool IsTscUnavailable(int libipt_status) {
+  return libipt_status == -pte_no_time;
+}
+
+/// Class that decodes a raw buffer for a single thread using the low level
+/// libipt library.
+///
+/// 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 LibiptDecoder {
+public:
+  /// \param[in] decoder
+  ///     A well configured decoder. Using the current state of that decoder,
+  ///     decoding will start at its next valid PSB. It's not assumed that the
+  ///     decoder is already pointing at a valid PSB.
+  ///
+  /// \param[in] decoded_thread
+  ///     A \a DecodedThread object where the decoded instructions will be
+  ///     appended to. It might have already some instructions.
+  LibiptDecoder(pt_insn_decoder &decoder, DecodedThread &decoded_thread)
+      : m_decoder(decoder), m_decoded_thread(decoded_thread) {}
+
+  /// Decode all the instructions until the end of the trace.
+  /// The decoding flow is based on
+  /// https://github.com/intel/libipt/blob/master/doc/howto_libipt.md#the-instruction-flow-decode-loop
+  /// but with some relaxation to allow for gaps in the trace.
+  void DecodeUntilEndOfTrace() {
+    int status = pte_ok;
+    while (!IsLibiptError(status = FindNextSynchronizationPoint())) {
+      // We have synchronized, so we can start decoding instructions and
+      // events.
+      // Multiple loops indicate gaps in the trace.
+      DecodeInstructionsAndEvents(status);
+    }
+  }
+
+private:
+  /// Decode all the instructions and events until an error is found or the end
+  /// of the trace is reached.
+  ///
+  /// \param[in] status
+  ///   The status that was result of synchronizing to the most recent PSB.
+  void DecodeInstructionsAndEvents(int status) {
+    pt_insn insn;
+    while (ProcessPTEvents(status)) {
+      status = pt_insn_next(&m_decoder, &insn, sizeof(insn));
+      // The status returned by pt_insn_next will need to be processed by
+      // ProcessPTEvents in the next loop.
+      if (FoundErrors(status, insn.ip))
+        break;
+      AppendInstruction(insn);
+    }
+  }
+
+  /// Move the decoder forward to the next synchronization point (i.e. next PSB
+  /// packet).
+  ///
+  /// Once the decoder is at that synchronization point, it can start decoding
+  /// instructions.
+  ///
+  /// \return
+  ///   The libipt decoder status after moving to the next PSB. Negative if
+  ///   no PSB was found.
+  int FindNextSynchronizationPoint() {
+    // Try to sync the decoder. If it fails, then get the decoder_offset and
+    // try to sync again from the next synchronization point. If the
+    // new_decoder_offset is same as decoder_offset then we can't move to the
+    // next synchronization point. Otherwise, keep resyncing until either end
+    // of trace stream (eos) is reached or pt_insn_sync_forward() passes.
+    int status = pt_insn_sync_forward(&m_decoder);
+
+    if (!IsEndOfStream(status) && IsLibiptError(status)) {
+      uint64_t decoder_offset = 0;
+      int errcode_off = pt_insn_get_offset(&m_decoder, &decoder_offset);
+      if (!IsLibiptError(errcode_off)) { // we could get the offset
+        while (true) {
+          status = pt_insn_sync_forward(&m_decoder);
+          if (!IsLibiptError(status) || IsEndOfStream(status))
+            break;
+
+          uint64_t new_decoder_offset = 0;
+          errcode_off = pt_insn_get_offset(&m_decoder, &new_decoder_offset);
+          if (IsLibiptError(errcode_off))
+            break; // We can't further synchronize.
+          else if (new_decoder_offset <= decoder_offset) {
+            // We tried resyncing the decoder and it didn't make any progress
+            // because the offset didn't change. We will not make any further
+            // progress. Hence, we stop in this situation.
+            break;
+          }
+          // We'll try again starting from a new offset.
+          decoder_offset = new_decoder_offset;
+        }
+      }
+    }
+
+    // We make this call to record any synchronization errors.
+    FoundErrors(status);
+    return status;
+  }
+
+  /// Before querying instructions, we need to query the events associated that
+  /// instruction e.g. timing events like ptev_tick, or paging events like
+  /// ptev_paging.
+  ///
+  /// \return
+  ///   \b true if we could process the events, \b false if errors were found.
+  bool ProcessPTEvents(int status) {
+    while (status & pts_event_pending) {
+      pt_event event;
+      status = pt_insn_event(&m_decoder, &event, sizeof(event));
+      if (IsLibiptError(status))
+        break;
+    }
+
+    // We refresh the TSC that might have changed after processing the events.
+    // See
+    // https://github.com/intel/libipt/blob/master/doc/man/pt_evt_next.3.md
+    RefreshTscInfo();
+    return !FoundErrors(status);
+  }
+
+  /// Query the decoder for the most recent TSC timestamp and update
+  /// the inner tsc information accordingly.
+  void RefreshTscInfo() {
+    if (m_tsc_info.has_tsc == eLazyBoolNo)
+      return;
+
+    uint64_t new_tsc;
+    int tsc_status;
+    if (IsLibiptError(tsc_status = pt_insn_time(&m_decoder, &new_tsc, nullptr,
+                                                nullptr))) {
+      if (IsTscUnavailable(tsc_status)) {
+        // We now know that the trace doesn't support TSC, so we won't try
+        // again.
+        // See
+        // https://github.com/intel/libipt/blob/master/doc/man/pt_qry_time.3.md
+        m_tsc_info.has_tsc = eLazyBoolNo;
+      } else {
+        // We don't add TSC decoding errors in the decoded trace itself to
+        // prevent creating unnecessary gaps, but we can count how many of
+        // these errors happened. In this case we reuse the previous correct
+        // TSC we saw, as it's better than no TSC at all.
+        m_decoded_thread.RecordTscError(tsc_status);
+      }
+    } else {
+      m_tsc_info.tsc = new_tsc;
+      m_tsc_info.has_tsc = eLazyBoolYes;
+    }
+  }
+
+  /// Check if the given libipt status signals any errors. If errors were found,
+  /// they will be recorded in the decoded trace.
+  ///
+  /// \param[in] ip
+  ///     An optional ip address can be passed if the error is associated with
+  ///     the decoding of a specific instruction.
+  ///
+  /// \return
+  ///     \b true if errors were found, \b false otherwise.
+  bool FoundErrors(int status, lldb::addr_t ip = LLDB_INVALID_ADDRESS) {
+    if (!IsLibiptError(status))
+      return false;
+
+    // We signal a gap only if it's not "end of stream", as that's not a proper
+    // error.
+    if (!IsEndOfStream(status)) {
+      if (m_tsc_info) {
+        m_decoded_thread.AppendError(make_error<IntelPTError>(status, ip),
+                                     m_tsc_info.tsc);
+      } else {
+        m_decoded_thread.AppendError(make_error<IntelPTError>(status, ip));
+      }
+    }
+    return true;
+  }
+
+  void AppendInstruction(const pt_insn &insn) {
+    if (m_tsc_info)
+      m_decoded_thread.AppendInstruction(insn, m_tsc_info.tsc);
+    else
+      m_decoded_thread.AppendInstruction(insn);
+  }
+
+private:
+  pt_insn_decoder &m_decoder;
+  DecodedThread &m_decoded_thread;
+  TscInfo m_tsc_info;
+};
+
+/// 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;
+}
+
+// RAII deleter for libipt's decoder
+auto DecoderDeleter = [](pt_insn_decoder *decoder) {
+  pt_insn_free_decoder(decoder);
+};
+
+using PtInsnDecoderUP =
+    std::unique_ptr<pt_insn_decoder, decltype(DecoderDeleter)>;
+
+static Expected<PtInsnDecoderUP>
+CreateInstructionDecoder(DecodedThread &decoded_thread,
+                         TraceIntelPT &trace_intel_pt,
+                         MutableArrayRef<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 = pte_ok;
+
+  if (IsLibiptError(status = pt_cpu_errata(&config.errata, &config.cpu)))
+    return make_error<IntelPTError>(status);
+
+  config.begin = buffer.data();
+  config.end = buffer.data() + buffer.size();
+
+  pt_insn_decoder *decoder_ptr = pt_insn_alloc_decoder(&config);
+  if (!decoder_ptr)
+    return make_error<IntelPTError>(-pte_nomem);
+  PtInsnDecoderUP decoder_up(decoder_ptr, DecoderDeleter);
+
+  pt_image *image = pt_insn_get_image(decoder_ptr);
+  Process *process = decoded_thread.GetThread()->GetProcess().get();
+
+  if (IsLibiptError(
+          status = pt_image_set_callback(image, ReadProcessMemory, process)))
+    return make_error<IntelPTError>(status);
+  return decoder_up;
+}
+
+void lldb_private::trace_intel_pt::DecodeTrace(
+    DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
+    MutableArrayRef<uint8_t> buffer) {
+  Expected<PtInsnDecoderUP> decoder_up =
+      CreateInstructionDecoder(decoded_thread, trace_intel_pt, buffer);
+  if (!decoder_up)
+    return decoded_thread.AppendError(decoder_up.takeError());
+
+  LibiptDecoder libipt_decoder(*decoder_up.get(), decoded_thread);
+  libipt_decoder.DecodeUntilEndOfTrace();
+}

lldb/source/Plugins/Trace/intel-pt/ThreadDecoder.h

-//===-- IntelPTDecoder.h --======--------------------------------*- C++ -*-===//
+//===-- ThreadDecoder.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_SOURCE_PLUGINS_TRACE_INTEL_PT_DECODER_H
-#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_DECODER_H
+#ifndef LLDB_SOURCE_PLUGINS_TRACE_THREAD_DECODER_H
+#define LLDB_SOURCE_PLUGINS_TRACE_THREAD_DECODER_H
 
 #include "intel-pt.h"
 
 #include "DecodedThread.h"
 #include "forward-declarations.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/FileSpec.h"
 
private:
 
   lldb::ThreadSP m_thread_sp;
   TraceIntelPT &m_trace;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
-#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_DECODER_H
+#endif // LLDB_SOURCE_PLUGINS_TRACE_THREAD_DECODER_H

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

+//===-- ThreadDecoder.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 "ThreadDecoder.h"
+
+#include "llvm/Support/MemoryBuffer.h"
+
+#include "../common/ThreadPostMortemTrace.h"
+#include "LibiptDecoder.h"
+#include "TraceIntelPT.h"
+
+#include <utility>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::trace_intel_pt;
+using namespace llvm;
+
+// ThreadDecoder ====================
+
+DecodedThreadSP ThreadDecoder::Decode() {
+  if (!m_decoded_thread.hasValue())
+    m_decoded_thread = DoDecode();
+  return *m_decoded_thread;
+}
+
+// LiveThreadDecoder ====================
+
+LiveThreadDecoder::LiveThreadDecoder(Thread &thread, TraceIntelPT &trace)
+    : m_thread_sp(thread.shared_from_this()), m_trace(trace) {}
+
+DecodedThreadSP LiveThreadDecoder::DoDecode() {
+  DecodedThreadSP decoded_thread_sp =
+      std::make_shared<DecodedThread>(m_thread_sp);
+
+  Expected<std::vector<uint8_t>> buffer =
+      m_trace.GetLiveThreadBuffer(m_thread_sp->GetID());
+  if (!buffer) {
+    decoded_thread_sp->AppendError(buffer.takeError());
+    return decoded_thread_sp;
+  }
+
+  decoded_thread_sp->SetRawTraceSize(buffer->size());
+  DecodeTrace(*decoded_thread_sp, m_trace, MutableArrayRef<uint8_t>(*buffer));
+  return decoded_thread_sp;
+}
+
+// PostMortemThreadDecoder =======================
+
+PostMortemThreadDecoder::PostMortemThreadDecoder(
+    const lldb::ThreadPostMortemTraceSP &trace_thread, TraceIntelPT &trace)
+    : m_trace_thread(trace_thread), m_trace(trace) {}
+
+DecodedThreadSP PostMortemThreadDecoder::DoDecode() {
+  DecodedThreadSP decoded_thread_sp =
+      std::make_shared<DecodedThread>(m_trace_thread);
+
+  ErrorOr<std::unique_ptr<MemoryBuffer>> trace_or_error =
+      MemoryBuffer::getFile(m_trace_thread->GetTraceFile().GetPath());
+  if (std::error_code err = trace_or_error.getError()) {
+    decoded_thread_sp->AppendError(errorCodeToError(err));
+    return decoded_thread_sp;
+  }
+
+  MemoryBuffer &trace = **trace_or_error;
+  MutableArrayRef<uint8_t> trace_data(
+      // The libipt library does not modify the trace buffer, hence the
+      // following cast is safe.
+      reinterpret_cast<uint8_t *>(const_cast<char *>(trace.getBufferStart())),
+      trace.getBufferSize());
+  decoded_thread_sp->SetRawTraceSize(trace_data.size());
+
+  DecodeTrace(*decoded_thread_sp, m_trace, trace_data);
+  return decoded_thread_sp;
+}

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

 //===-- TraceCursorIntelPT.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_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACECURSORINTELPT_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACECURSORINTELPT_H
 
-#include "IntelPTDecoder.h"
+#include "ThreadDecoder.h"
 #include "TraceIntelPTSessionFileParser.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 class TraceCursorIntelPT : public TraceCursor {
 public:
   TraceCursorIntelPT(lldb::ThreadSP thread_sp,

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.h

 //===-- TraceIntelPT.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_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPT_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPT_H
 
-#include "IntelPTDecoder.h"
+#include "ThreadDecoder.h"
 #include "TraceIntelPTSessionFileParser.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-types.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {