[XRay] Use TSC delta encoding for custom/typed events

[dberris]

Summary

This change updates the version number for FDR logs to 5, and update the
trace processing to support changes in the custom event records.

In the runtime, since we're already writing down the record preamble to
handle CPU migrations and TSC wraparound, we can use the same TSC delta
encoding in the custom event and typed event records that we use in
function event records. We do the same change to typed events (which
were unsupported before this change in the trace processing) which now
show up in the trace.

Future changes should increase our testing coverage to make custom and
typed events as first class entities in the FDR mode log processing
tools.

This change is also a good example of how we end up supporting new
record types in the FDR mode implementation. This shows the places where
new record types are added and supported.

Depends on D54139.

[mboerger]

compiler-rt/lib/xray/xray_fdr_logging.cc

157

why'd you not add dots at the end, these comments are all sentences.

llvm/lib/XRay/RecordInitializer.cpp

178

why assert and not return an error?

[dberris]

Address comments by @mboerger.

llvm/lib/XRay/RecordInitializer.cpp

178

This invariant is required for the following math to make sense (getting the difference between the OffsetPtr and BeginOffset). Throughout LLVM, these invariants are checked through assertions, and aren't really recoverable errors from the caller's perspective.

[mboerger]

LGTM

compiler-rt/lib/xray/xray_fdr_controller.h

 
 #include "xray/xray_interface.h"
 #include "xray/xray_records.h"
 #include "xray_buffer_queue.h"
 #include "xray_fdr_log_writer.h"
 
 namespace __xray {
 
-template <size_t Version = 3> class FDRController {
+template <size_t Version = 5> class FDRController {
   BufferQueue *BQ;
   BufferQueue::Buffer &B;
   FDRLogWriter &W;
   int (*WallClockReader)(clockid_t, struct timespec *) = 0;
   uint64_t CycleThreshold = 0;
 
   uint64_t LastFunctionEntryTSC = 0;
   uint64_t LatestTSC = 0;
if (finalized()) {
       BQ->releaseBuffer(B); // ignore result.
       return false;
     }
 
     return BQ->releaseBuffer(B) == BufferQueue::ErrorCode::Ok;
   }
 
   enum class PreambleResult { NoChange, WroteMetadata, InvalidBuffer };
-  PreambleResult functionPreamble(uint64_t TSC,
-                                  uint16_t CPU) XRAY_NEVER_INSTRUMENT {
+  PreambleResult recordPreamble(uint64_t TSC,
     if (UNLIKELY(LatestCPU != CPU || LatestTSC == 0)) {
       // We update our internal tracking state for the Latest TSC and CPU we've
       // seen, then write out the appropriate metadata and function records.
       LatestTSC = TSC;
       LatestCPU = CPU;
 
       if (B.Generation != BQ->generation())
         return PreambleResult::InvalidBuffer;
FDRController(BufferQueue *BQ, BufferQueue::Buffer &B, FDRLogWriter &W,
         CycleThreshold(C) {}
 
   bool functionEnter(int32_t FuncId, uint64_t TSC,
                      uint16_t CPU) XRAY_NEVER_INSTRUMENT {
     if (finalized() ||
         !prepareBuffer(sizeof(MetadataRecord) + sizeof(FunctionRecord)))
       return returnBuffer();
 
-    auto PreambleStatus = functionPreamble(TSC, CPU);
+    auto PreambleStatus = recordPreamble(TSC, CPU);
     if (PreambleStatus == PreambleResult::InvalidBuffer)
       return returnBuffer();
 
     UndoableFunctionEnters = (PreambleStatus == PreambleResult::WroteMetadata)
                                  ? 1
                                  : UndoableFunctionEnters + 1;
     auto Delta = TSC - LatestTSC;
     LastFunctionEntryTSC = TSC;
     LatestTSC = TSC;
     return W.writeFunction(FDRLogWriter::FunctionRecordKind::Enter,
                            mask(FuncId), Delta);
   }
 
   bool functionTailExit(int32_t FuncId, uint64_t TSC,
                         uint16_t CPU) XRAY_NEVER_INSTRUMENT {
     if (finalized())
       return returnBuffer();
 
     if (!prepareBuffer(sizeof(MetadataRecord) + sizeof(FunctionRecord)))
       return returnBuffer();
 
-    auto PreambleStatus = functionPreamble(TSC, CPU);
+    auto PreambleStatus = recordPreamble(TSC, CPU);
     if (PreambleStatus == PreambleResult::InvalidBuffer)
       return returnBuffer();
 
     if (PreambleStatus == PreambleResult::NoChange &&
         UndoableFunctionEnters != 0 &&
         TSC - LastFunctionEntryTSC < CycleThreshold)
       return rewindRecords(FuncId, TSC, CPU);
 
     UndoableTailExits = UndoableFunctionEnters ? UndoableTailExits + 1 : 0;
     UndoableFunctionEnters = 0;
     auto Delta = TSC - LatestTSC;
     LatestTSC = TSC;
     return W.writeFunction(FDRLogWriter::FunctionRecordKind::TailExit,
                            mask(FuncId), Delta);
   }
 
   bool functionEnterArg(int32_t FuncId, uint64_t TSC, uint16_t CPU,
                         uint64_t Arg) XRAY_NEVER_INSTRUMENT {
     if (finalized() ||
         !prepareBuffer((2 * sizeof(MetadataRecord)) + sizeof(FunctionRecord)) ||
-        functionPreamble(TSC, CPU) == PreambleResult::InvalidBuffer)
+        recordPreamble(TSC, CPU) == PreambleResult::InvalidBuffer)
       return returnBuffer();
 
     auto Delta = TSC - LatestTSC;
     LatestTSC = TSC;
     LastFunctionEntryTSC = 0;
     UndoableFunctionEnters = 0;
     UndoableTailExits = 0;
 
     W.writeFunction(FDRLogWriter::FunctionRecordKind::EnterArg, mask(FuncId),
                     Delta);
     return W.writeMetadata<MetadataRecord::RecordKinds::CallArgument>(Arg);
   }
 
   bool functionExit(int32_t FuncId, uint64_t TSC,
                     uint16_t CPU) XRAY_NEVER_INSTRUMENT {
     if (finalized() ||
         !prepareBuffer(sizeof(MetadataRecord) + sizeof(FunctionRecord)))
       return returnBuffer();
 
-    auto PreambleStatus = functionPreamble(TSC, CPU);
+    auto PreambleStatus = recordPreamble(TSC, CPU);
     if (PreambleStatus == PreambleResult::InvalidBuffer)
       return returnBuffer();
 
     if (PreambleStatus == PreambleResult::NoChange &&
         UndoableFunctionEnters != 0 &&
         TSC - LastFunctionEntryTSC < CycleThreshold)
       return rewindRecords(FuncId, TSC, CPU);
 
     auto Delta = TSC - LatestTSC;
     LatestTSC = TSC;
     UndoableFunctionEnters = 0;
     UndoableTailExits = 0;
     return W.writeFunction(FDRLogWriter::FunctionRecordKind::Exit, mask(FuncId),
                            Delta);
   }
 
   bool customEvent(uint64_t TSC, uint16_t CPU, const void *Event,
                    int32_t EventSize) XRAY_NEVER_INSTRUMENT {
     if (finalized() ||
         !prepareBuffer((2 * sizeof(MetadataRecord)) + EventSize) ||
-        functionPreamble(TSC, CPU) == PreambleResult::InvalidBuffer)
+        recordPreamble(TSC, CPU) == PreambleResult::InvalidBuffer)
       return returnBuffer();
 
-    LatestTSC = 0;
+    auto Delta = TSC - LatestTSC;
+    LatestTSC = TSC;
     UndoableFunctionEnters = 0;
     UndoableTailExits = 0;
-    return W.writeCustomEvent(TSC, CPU, Event, EventSize);
+    return W.writeCustomEvent(Delta, Event, EventSize);
   }
 
   bool typedEvent(uint64_t TSC, uint16_t CPU, uint16_t EventType,
                   const void *Event, int32_t EventSize) XRAY_NEVER_INSTRUMENT {
     if (finalized() ||
         !prepareBuffer((2 * sizeof(MetadataRecord)) + EventSize) ||
-        functionPreamble(TSC, CPU) == PreambleResult::InvalidBuffer)
+        recordPreamble(TSC, CPU) == PreambleResult::InvalidBuffer)
       return returnBuffer();
 
-    LatestTSC = 0;
+    auto Delta = TSC - LatestTSC;
+    LatestTSC = TSC;
     UndoableFunctionEnters = 0;
     UndoableTailExits = 0;
-    return W.writeTypedEvent(TSC, EventType, Event, EventSize);
+    return W.writeTypedEvent(Delta, EventType, Event, EventSize);
   }
 
   bool flush() XRAY_NEVER_INSTRUMENT {
     if (finalized()) {
       returnBuffer(); // ignore result.
       return true;
     }
     return returnBuffer();
   }
 };
 
 } // namespace __xray
 
 #endif // COMPILER-RT_LIB_XRAY_XRAY_FDR_CONTROLLER_H_

compiler-rt/lib/xray/xray_fdr_log_writer.h

bool writeFunction(FunctionRecordKind Kind, int32_t FuncId, int32_t Delta) {
     R.Type = 0;
     R.RecordKind = uint8_t(Kind);
     R.FuncId = FuncId;
     R.TSCDelta = Delta;
     writeRecord(R);
     return true;
   }
 
-  bool writeCustomEvent(uint64_t TSC, uint16_t CPU, const void *Event,
-                        int32_t EventSize) {
+  bool writeCustomEvent(int32_t Delta, const void *Event, int32_t EventSize) {
     // We write the metadata record and the custom event data into the buffer
     // first, before we atomically update the extents for the buffer. This
     // allows us to ensure that any threads reading the extents of the buffer
     // will only ever see the full metadata and custom event payload accounted
     // (no partial writes accounted).
     MetadataRecord R =
         createMetadataRecord<MetadataRecord::RecordKinds::CustomEventMarker>(
-            EventSize, TSC, CPU);
+            EventSize, Delta);
     NextRecord = reinterpret_cast<char *>(internal_memcpy(
                      NextRecord, reinterpret_cast<char *>(&R), sizeof(R))) +
                  sizeof(R);
     NextRecord = reinterpret_cast<char *>(
                      internal_memcpy(NextRecord, Event, EventSize)) +
                  EventSize;
     atomic_fetch_add(&Buffer.Extents, sizeof(R) + EventSize,
                      memory_order_acq_rel);
     return true;
   }
 
-  bool writeTypedEvent(uint64_t TSC, uint16_t EventType, const void *Event,
+  bool writeTypedEvent(int32_t Delta, uint16_t EventType, const void *Event,
                        int32_t EventSize) {
     // We do something similar when writing out typed events, see
     // writeCustomEvent(...) above for details.
     MetadataRecord R =
         createMetadataRecord<MetadataRecord::RecordKinds::TypedEventMarker>(
-            EventSize, TSC, EventType);
+            EventSize, Delta, EventType);
     NextRecord = reinterpret_cast<char *>(internal_memcpy(
                      NextRecord, reinterpret_cast<char *>(&R), sizeof(R))) +
                  sizeof(R);
     NextRecord = reinterpret_cast<char *>(
                      internal_memcpy(NextRecord, Event, EventSize)) +
                  EventSize;
     atomic_fetch_add(&Buffer.Extents, EventSize, memory_order_acq_rel);
     return true;

compiler-rt/lib/xray/xray_fdr_logging.cc

 #include "xray_utils.h"
 
 namespace __xray {
 
 static atomic_sint32_t LoggingStatus = {
     XRayLogInitStatus::XRAY_LOG_UNINITIALIZED};
 
 namespace {
+
 // Group together thread-local-data in a struct, then hide it behind a function
 // call so that it can be initialized on first use instead of as a global. We
 // force the alignment to 64-bytes for x86 cache line alignment, as this
 // structure is used in the hot path of implementation.
 struct alignas(64) ThreadLocalData {
   BufferQueue::Buffer Buffer{};
   BufferQueue *BQ = nullptr;
 
static ThreadLocalData &getThreadLocalData() {
   return *reinterpret_cast<ThreadLocalData *>(&TLDStorage);
 }
 
 static XRayFileHeader &fdrCommonHeaderInfo() {
   static std::aligned_storage<sizeof(XRayFileHeader)>::type HStorage;
   static pthread_once_t OnceInit = PTHREAD_ONCE_INIT;
   static bool TSCSupported = true;
   static uint64_t CycleFrequency = NanosecondsPerSecond;
-  pthread_once(&OnceInit, +[] {
+  pthread_once(
+      &OnceInit, +[] {
         XRayFileHeader &H = reinterpret_cast<XRayFileHeader &>(HStorage);
         // Version 2 of the log writes the extents of the buffer, instead of
         // relying on an end-of-buffer record.
         // Version 3 includes PID metadata record
         // Version 4 includes CPU data in the custom event records
-    H.Version = 4;
+        // Version 5 uses relative deltas for custom and typed event records,
+        // and removes the CPU data in custom event records (similar to how
+        // function records use deltas instead of full TSCs and rely on other
+        // metadata records for TSC wraparound and CPU migration)
+        H.Version = 5;
         H.Type = FileTypes::FDR_LOG;
 
         // Test for required CPU features and cache the cycle frequency
         TSCSupported = probeRequiredCPUFeatures();
         if (TSCSupported)
           CycleFrequency = getTSCFrequency();
         H.CycleFrequency = CycleFrequency;
 
         // FIXME: Actually check whether we have 'constant_tsc' and
         // 'nonstop_tsc' before setting the values in the header.
         H.ConstantTSC = 1;
         H.NonstopTSC = 1;
       });
   return reinterpret_cast<XRayFileHeader &>(HStorage);
 }
 
 // This is the iterator implementation, which knows how to handle FDR-mode
 // specific buffers. This is used as an implementation of the iterator function
 // needed by __xray_set_buffer_iterator(...). It maintains a global state of the
 // buffer iteration for the currently installed FDR mode buffers. In particular:
 //
XRayBuffer fdrIterator(const XRayBuffer B) {
   }
 
   // We use a global scratch-pad for the header information, which only gets
   // initialized the first time this function is called. We'll update one part
   // of this information with some relevant data (in particular the number of
   // buffers to expect).
   static std::aligned_storage<sizeof(XRayFileHeader)>::type HeaderStorage;
   static pthread_once_t HeaderOnce = PTHREAD_ONCE_INIT;
-  pthread_once(&HeaderOnce, +[] {
-    reinterpret_cast<XRayFileHeader &>(HeaderStorage) = fdrCommonHeaderInfo();
+  pthread_once(
+      &HeaderOnce, +[] {
+        reinterpret_cast<XRayFileHeader &>(HeaderStorage) =
+            fdrCommonHeaderInfo();
       });
 
   // We use a convenience alias for code referring to Header from here on out.
   auto &Header = reinterpret_cast<XRayFileHeader &>(HeaderStorage);
   if (B.Data == nullptr && B.Size == 0) {
     Header.FdrData = FdrAdditionalHeaderData{BQ->ConfiguredBufferSize()};
     return XRayBuffer{static_cast<void *>(&Header), sizeof(Header)};
   }
 
static TSCAndCPU getTimestamp() XRAY_NEVER_INSTRUMENT {
   // We want to get the TSC as early as possible, so that we can check whether
   // we've seen this CPU before. We also do it before we load anything else,
   // to allow for forward progress with the scheduling.
   TSCAndCPU Result;
 
   // Test once for required CPU features
   static pthread_once_t OnceProbe = PTHREAD_ONCE_INIT;
   static bool TSCSupported = true;
-  pthread_once(&OnceProbe, +[] { TSCSupported = probeRequiredCPUFeatures(); });
+  pthread_once(
+      &OnceProbe, +[] { TSCSupported = probeRequiredCPUFeatures(); });
 
   if (TSCSupported) {
     Result.TSC = __xray::readTSC(Result.CPU);
   } else {
     // FIXME: This code needs refactoring as it appears in multiple locations
     timespec TS;
     int result = clock_gettime(CLOCK_REALTIME, &TS);
     if (result != 0) {
void fdrLoggingHandleCustomEvent(void *Event,
   if (!Guard)
     return;
 
   // Complain when we ever get at least one custom event that's larger than what
   // we can possibly support.
   if (EventSize >
       static_cast<std::size_t>(std::numeric_limits<int32_t>::max())) {
     static pthread_once_t Once = PTHREAD_ONCE_INIT;
-    pthread_once(&Once, +[] {
+    pthread_once(
+        &Once, +[] {
           Report("Custom event size too large; truncating to %d.\n",
                  std::numeric_limits<int32_t>::max());
         });
   }
 
   auto &TLD = getThreadLocalData();
   if (!setupTLD(TLD))
     return;
 
   int32_t ReducedEventSize = static_cast<int32_t>(EventSize);
   TLD.Controller->customEvent(TSC, CPU, Event, ReducedEventSize);
void fdrLoggingHandleTypedEvent(
   if (!Guard)
     return;
 
   // Complain when we ever get at least one typed event that's larger than what
   // we can possibly support.
   if (EventSize >
       static_cast<std::size_t>(std::numeric_limits<int32_t>::max())) {
     static pthread_once_t Once = PTHREAD_ONCE_INIT;
-    pthread_once(&Once, +[] {
+    pthread_once(
+        &Once, +[] {
           Report("Typed event size too large; truncating to %d.\n",
                  std::numeric_limits<int32_t>::max());
         });
   }
 
   auto &TLD = getThreadLocalData();
   if (!setupTLD(TLD))
     return;
 
   int32_t ReducedEventSize = static_cast<int32_t>(EventSize);
   TLD.Controller->typedEvent(TSC, CPU, EventType, Event, ReducedEventSize);
if (BQ == nullptr) {
     if (BQ->init(BufferSize, BufferMax) != BufferQueue::ErrorCode::Ok) {
       if (Verbosity())
         Report("Failed to re-initialize global buffer queue. Init failed.\n");
       return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED;
     }
   }
 
   static pthread_once_t OnceInit = PTHREAD_ONCE_INIT;
-  pthread_once(&OnceInit, +[] {
+  pthread_once(
+      &OnceInit, +[] {
         atomic_store(&TicksPerSec,
                      probeRequiredCPUFeatures() ? getTSCFrequency()
                                                 : __xray::NanosecondsPerSecond,
                      memory_order_release);
-    pthread_key_create(&Key, +[](void *TLDPtr) {
+        pthread_key_create(
+            &Key, +[](void *TLDPtr) {
               if (TLDPtr == nullptr)
                 return;
               auto &TLD = *reinterpret_cast<ThreadLocalData *>(TLDPtr);
               if (TLD.BQ == nullptr)
                 return;
               if (TLD.Buffer.Data == nullptr)
                 return;
               auto EC = TLD.BQ->releaseBuffer(TLD.Buffer);
               if (EC != BufferQueue::ErrorCode::Ok)
-        Report("At thread exit, failed to release buffer at %p; error=%s\n",
+                Report("At thread exit, failed to release buffer at %p; "
+                       "error=%s\n",
                        TLD.Buffer.Data, BufferQueue::getErrorString(EC));
             });
       });
 
   atomic_store(&ThresholdTicks,
                atomic_load_relaxed(&TicksPerSec) *
                    fdrFlags()->func_duration_threshold_us / 1000000,
                memory_order_release);
   // Arg1 handler should go in first to avoid concurrent code accidentally
   // falling back to arg0 when it should have ran arg1.
   __xray_set_handler_arg1(fdrLoggingHandleArg1);

llvm/include/llvm/XRay/BlockIndexer.h

public:
   Error visit(NewCPUIDRecord &) override;
   Error visit(TSCWrapRecord &) override;
   Error visit(CustomEventRecord &) override;
   Error visit(CallArgRecord &) override;
   Error visit(PIDRecord &) override;
   Error visit(NewBufferRecord &) override;
   Error visit(EndBufferRecord &) override;
   Error visit(FunctionRecord &) override;
+  Error visit(CustomEventRecordV5 &) override;
+  Error visit(TypedEventRecord &) override;
 
   /// The flush() function will clear out the current state of the visitor, to
   /// allow for explicitly flushing a block's records to the currently
   /// recognized thread and process combination.
   Error flush();
 };
 
 } // namespace xray
 } // namespace llvm
 
 #endif // LLVM_LIB_XRAY_BLOCKINDEXER_H_

llvm/include/llvm/XRay/BlockPrinter.h

public:
   Error visit(NewCPUIDRecord &) override;
   Error visit(TSCWrapRecord &) override;
   Error visit(CustomEventRecord &) override;
   Error visit(CallArgRecord &) override;
   Error visit(PIDRecord &) override;
   Error visit(NewBufferRecord &) override;
   Error visit(EndBufferRecord &) override;
   Error visit(FunctionRecord &) override;
+  Error visit(CustomEventRecordV5 &) override;
+  Error visit(TypedEventRecord &) override;
 
   void reset() { CurrentState = State::Start; }
 };
 
 } // namespace xray
 } // namespace llvm
 
 #endif // LLVM_INCLUDE_LLVM_XRAY_BLOCKPRINTER_H_

llvm/include/llvm/XRay/BlockVerifier.h

enum class State : std::size_t {
     Unknown,
     BufferExtents,
     NewBuffer,
     WallClockTime,
     PIDEntry,
     NewCPUId,
     TSCWrap,
     CustomEvent,
+    TypedEvent,
     Function,
     CallArg,
     EndOfBuffer,
     StateMax,
   };
 
 private:
   // We keep track of the current record seen by the verifier.
public:
   Error visit(NewCPUIDRecord &) override;
   Error visit(TSCWrapRecord &) override;
   Error visit(CustomEventRecord &) override;
   Error visit(CallArgRecord &) override;
   Error visit(PIDRecord &) override;
   Error visit(NewBufferRecord &) override;
   Error visit(EndBufferRecord &) override;
   Error visit(FunctionRecord &) override;
+  Error visit(CustomEventRecordV5 &) override;
+  Error visit(TypedEventRecord &) override;
 
   Error verify();
   void reset();
 };
 
 } // namespace xray
 } // namespace llvm
 
 #endif // LLVM_INCLUDE_LLVM_XRAY_BLOCKVERIFIER_H_

llvm/include/llvm/XRay/FDRRecords.h

enum class MetadataType : unsigned {
     WallClockTime,
     NewCPUId,
     TSCWrap,
     CustomEvent,
     CallArg,
     PIDEntry,
     NewBuffer,
     EndOfBuffer,
+    TypedEvent,
   };
 
   Type type() const override { return Type::Metadata; }
 
   // All metadata records must know to provide the type of their open
   // metadata record.
   virtual MetadataType metadataType() const = 0;
 
public:
   int32_t size() const { return Size; }
   uint64_t tsc() const { return TSC; }
   uint16_t cpu() const { return CPU; }
   StringRef data() const { return Data; }
 
   Error apply(RecordVisitor &V) override;
 };
 
+class CustomEventRecordV5 : public MetadataRecord {
+  int32_t Size = 0;
+  int32_t Delta = 0;
+  std::string Data{};
+  friend class RecordInitializer;
+
+public:
+  CustomEventRecordV5() = default;
+  explicit CustomEventRecordV5(int32_t S, int32_t D, std::string P)
+      : MetadataRecord(), Size(S), Delta(D), Data(std::move(P)) {}
+
+  MetadataType metadataType() const override {
+    return MetadataType::CustomEvent;
+  }
+
+  int32_t size() const { return Size; }
+  int32_t delta() const { return Delta; }
+  StringRef data() const { return Data; }
+
+  Error apply(RecordVisitor &V) override;
+};
+
+class TypedEventRecord : public MetadataRecord {
+  int32_t Size = 0;
+  int32_t Delta = 0;
+  uint16_t EventType = 0;
+  std::string Data{};
+  friend class RecordInitializer;
+
+public:
+  TypedEventRecord() = default;
+  explicit TypedEventRecord(int32_t S, int32_t D, uint16_t E, std::string P)
+      : MetadataRecord(), Size(S), Delta(D), Data(std::move(P)) {}
+
+  MetadataType metadataType() const override {
+    return MetadataType::TypedEvent;
+  }
+
+  int32_t size() const { return Size; }
+  int32_t delta() const { return Delta; }
+  uint16_t eventType() const { return EventType; }
+  StringRef data() const { return Data; }
+
+  Error apply(RecordVisitor &V) override;
+};
+
 class CallArgRecord : public MetadataRecord {
   uint64_t Arg;
   friend class RecordInitializer;
 
 public:
   CallArgRecord() = default;
   explicit CallArgRecord(uint64_t A) : MetadataRecord(), Arg(A) {}
 
public:
   virtual Error visit(NewCPUIDRecord &) = 0;
   virtual Error visit(TSCWrapRecord &) = 0;
   virtual Error visit(CustomEventRecord &) = 0;
   virtual Error visit(CallArgRecord &) = 0;
   virtual Error visit(PIDRecord &) = 0;
   virtual Error visit(NewBufferRecord &) = 0;
   virtual Error visit(EndBufferRecord &) = 0;
   virtual Error visit(FunctionRecord &) = 0;
+  virtual Error visit(CustomEventRecordV5 &) = 0;
+  virtual Error visit(TypedEventRecord &) = 0;
 };
 
 class RecordInitializer : public RecordVisitor {
   DataExtractor &E;
   uint32_t &OffsetPtr;
   uint16_t Version;
 
 public:
-  static constexpr uint16_t DefaultVersion = 4u;
+  static constexpr uint16_t DefaultVersion = 5u;
 
   explicit RecordInitializer(DataExtractor &DE, uint32_t &OP, uint16_t V)
       : RecordVisitor(), E(DE), OffsetPtr(OP), Version(V) {}
 
   explicit RecordInitializer(DataExtractor &DE, uint32_t &OP)
       : RecordInitializer(DE, OP, DefaultVersion) {}
 
   Error visit(BufferExtents &) override;
   Error visit(WallclockRecord &) override;
   Error visit(NewCPUIDRecord &) override;
   Error visit(TSCWrapRecord &) override;
   Error visit(CustomEventRecord &) override;
   Error visit(CallArgRecord &) override;
   Error visit(PIDRecord &) override;
   Error visit(NewBufferRecord &) override;
   Error visit(EndBufferRecord &) override;
   Error visit(FunctionRecord &) override;
+  Error visit(CustomEventRecordV5 &) override;
+  Error visit(TypedEventRecord &) override;
 };
 
 } // namespace xray
 } // namespace llvm
 
 #endif // LLVM_LIB_XRAY_FDRRECORDS_H_

llvm/include/llvm/XRay/FDRTraceExpander.h

public:
   Error visit(NewCPUIDRecord &) override;
   Error visit(TSCWrapRecord &) override;
   Error visit(CustomEventRecord &) override;
   Error visit(CallArgRecord &) override;
   Error visit(PIDRecord &) override;
   Error visit(NewBufferRecord &) override;
   Error visit(EndBufferRecord &) override;
   Error visit(FunctionRecord &) override;
+  Error visit(CustomEventRecordV5 &) override;
+  Error visit(TypedEventRecord &) override;
 
   // Must be called after all the records have been processed, to handle the
   // most recent record generated.
   Error flush();
 };
 
 } // namespace xray
 } // namespace llvm
 
 #endif // INCLUDE_LLVM_XRAY_FDRTRACEEXPANDER_H_

llvm/include/llvm/XRay/FDRTraceWriter.h

public:
   Error visit(NewCPUIDRecord &) override;
   Error visit(TSCWrapRecord &) override;
   Error visit(CustomEventRecord &) override;
   Error visit(CallArgRecord &) override;
   Error visit(PIDRecord &) override;
   Error visit(NewBufferRecord &) override;
   Error visit(EndBufferRecord &) override;
   Error visit(FunctionRecord &) override;
+  Error visit(CustomEventRecordV5 &) override;
+  Error visit(TypedEventRecord &) override;
 
 private:
   support::endian::Writer OS;
 };
 
 } // namespace xray
 } // namespace llvm
 
 #endif // LLVM_INCLUDE_LLVM_XRAY_FDRTRACEWRITER_H_

llvm/include/llvm/XRay/RecordPrinter.h

public:
   Error visit(NewCPUIDRecord &) override;
   Error visit(TSCWrapRecord &) override;
   Error visit(CustomEventRecord &) override;
   Error visit(CallArgRecord &) override;
   Error visit(PIDRecord &) override;
   Error visit(NewBufferRecord &) override;
   Error visit(EndBufferRecord &) override;
   Error visit(FunctionRecord &) override;
+  Error visit(CustomEventRecordV5 &) override;
+  Error visit(TypedEventRecord &) override;
 };
 
 } // namespace xray
 } // namespace llvm
 
 #endif // LLVM_INCLUDE_LLVM_XRAY_RECORDPRINTER_H

llvm/include/llvm/XRay/XRayRecord.h

 // xray project.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_XRAY_XRAY_RECORD_H
 #define LLVM_XRAY_XRAY_RECORD_H
 
 #include <cstdint>
 #include <vector>
+#include <string>
 
 namespace llvm {
 namespace xray {
 
 /// XRay traces all have a header providing some top-matter information useful
 /// to help tools determine how to interpret the information available in the
 /// trace.
 struct XRayFileHeader {

llvm/lib/XRay/BlockIndexer.cpp

Error BlockIndexer::visit(TSCWrapRecord &R) {
   return Error::success();
 }
 
 Error BlockIndexer::visit(CustomEventRecord &R) {
   CurrentBlock.Records.push_back(&R);
   return Error::success();
 }
 
+Error BlockIndexer::visit(CustomEventRecordV5 &R) {
+  CurrentBlock.Records.push_back(&R);
+  return Error::success();
+}
+
+Error BlockIndexer::visit(TypedEventRecord &R) {
+  CurrentBlock.Records.push_back(&R);
+  return Error::success();
+}
+
 Error BlockIndexer::visit(CallArgRecord &R) {
   CurrentBlock.Records.push_back(&R);
   return Error::success();
 }
 
 Error BlockIndexer::visit(PIDRecord &R) {
   CurrentBlock.ProcessID = R.pid();
   CurrentBlock.Records.push_back(&R);

llvm/lib/XRay/BlockPrinter.cpp

Error BlockPrinter::visit(CustomEventRecord &R) {
   if (CurrentState == State::Metadata)
     OS << "\n";
   CurrentState = State::CustomEvent;
   OS << "*  ";
   auto E = RP.visit(R);
   return E;
 }
 
+Error BlockPrinter::visit(CustomEventRecordV5 &R) {
+  if (CurrentState == State::Metadata)
+    OS << "\n";
+  CurrentState = State::CustomEvent;
+  OS << "*  ";
+  auto E = RP.visit(R);
+  return E;
+}
+
+Error BlockPrinter::visit(TypedEventRecord &R) {
+  if (CurrentState == State::Metadata)
+    OS << "\n";
+  CurrentState = State::CustomEvent;
+  OS << "*  ";
+  auto E = RP.visit(R);
+  return E;
+}
+
 // Function call printing.
 Error BlockPrinter::visit(FunctionRecord &R) {
   if (CurrentState == State::Metadata)
     OS << "\n";
   CurrentState = State::Function;
   OS << "-  ";
   auto E = RP.visit(R);
   return E;

llvm/lib/XRay/BlockVerifier.cpp

StringRef recordToString(BlockVerifier::State R) {
   case BlockVerifier::State::CustomEvent:
     return "CustomEvent";
   case BlockVerifier::State::Function:
     return "Function";
   case BlockVerifier::State::CallArg:
     return "CallArg";
   case BlockVerifier::State::EndOfBuffer:
     return "EndOfBuffer";
+  case BlockVerifier::State::TypedEvent:
+    return "TypedEvent";
   case BlockVerifier::State::StateMax:
   case BlockVerifier::State::Unknown:
     return "Unknown";
   }
   llvm_unreachable("Unkown state!");
 }
 
 struct Transition {
static constexpr std::array<const Transition, number(State::StateMax)>
                        {State::WallClockTime,
                         {mask(State::PIDEntry) | mask(State::NewCPUId)}},
 
                        {State::PIDEntry, {mask(State::NewCPUId)}},
 
                        {State::NewCPUId,
                         {mask(State::NewCPUId) | mask(State::TSCWrap) |
                          mask(State::CustomEvent) | mask(State::Function) |
-                         mask(State::EndOfBuffer)}},
+                         mask(State::EndOfBuffer) | mask(State::TypedEvent)}},
 
                        {State::TSCWrap,
                         {mask(State::TSCWrap) | mask(State::NewCPUId) |
                          mask(State::CustomEvent) | mask(State::Function) |
-                         mask(State::EndOfBuffer)}},
+                         mask(State::EndOfBuffer) | mask(State::TypedEvent)}},
 
                        {State::CustomEvent,
                         {mask(State::CustomEvent) | mask(State::TSCWrap) |
                          mask(State::NewCPUId) | mask(State::Function) |
-                         mask(State::EndOfBuffer)}},
+                         mask(State::EndOfBuffer) | mask(State::TypedEvent)}},
+
+                       {State::TypedEvent,
+                        {mask(State::TypedEvent) | mask(State::TSCWrap) |
+                         mask(State::NewCPUId) | mask(State::Function) |
+                         mask(State::EndOfBuffer) | mask(State::CustomEvent)}},
 
                        {State::Function,
                         {mask(State::Function) | mask(State::TSCWrap) |
                          mask(State::NewCPUId) | mask(State::CustomEvent) |
-                         mask(State::CallArg) | mask(State::EndOfBuffer)}},
+                         mask(State::CallArg) | mask(State::EndOfBuffer) |
+                         mask(State::TypedEvent)}},
 
                        {State::CallArg,
                         {mask(State::CallArg) | mask(State::Function) |
                          mask(State::TSCWrap) | mask(State::NewCPUId) |
-                         mask(State::CustomEvent) | mask(State::EndOfBuffer)}},
+                         mask(State::CustomEvent) | mask(State::EndOfBuffer) |
+                         mask(State::TypedEvent)}},
 
                        {State::EndOfBuffer, {}}}};
 
   if (CurrentRecord >= State::StateMax)
     return createStringError(
         std::make_error_code(std::errc::executable_format_error),
         "BUG (BlockVerifier): Cannot find transition table entry for %s, "
         "transitioning to %s.",

 Error BlockVerifier::visit(TSCWrapRecord &) {
   return transition(State::TSCWrap);
 }
 
 Error BlockVerifier::visit(CustomEventRecord &) {
   return transition(State::CustomEvent);
 }
 
+Error BlockVerifier::visit(CustomEventRecordV5 &) {
+  return transition(State::CustomEvent);
+}
+
+Error BlockVerifier::visit(TypedEventRecord &) {
+  return transition(State::TypedEvent);
+}
+
 Error BlockVerifier::visit(CallArgRecord &) {
   return transition(State::CallArg);
 }
 
 Error BlockVerifier::visit(PIDRecord &) { return transition(State::PIDEntry); }
 
 Error BlockVerifier::visit(NewBufferRecord &) {
   return transition(State::NewBuffer);
 }
 
 Error BlockVerifier::visit(EndBufferRecord &) {
   return transition(State::EndOfBuffer);
 }
 
 Error BlockVerifier::visit(FunctionRecord &) {
   return transition(State::Function);
 }
 
 Error BlockVerifier::verify() {
   // The known terminal conditions are the following:
   switch (CurrentRecord) {
   case State::EndOfBuffer:
   case State::NewCPUId:
   case State::CustomEvent:
+  case State::TypedEvent:
   case State::Function:
   case State::CallArg:
   case State::TSCWrap:
     return Error::success();
   default:
     return createStringError(
         std::make_error_code(std::errc::executable_format_error),
         "BlockVerifier: Invalid terminal condition %s, malformed block.",
         recordToString(CurrentRecord).data());
   }
 }
 
 void BlockVerifier::reset() { CurrentRecord = State::Unknown; }
 
 } // namespace xray
 } // namespace llvm

llvm/lib/XRay/FDRRecordProducer.cpp

case MetadataRecordKinds::EndOfBufferKind:
     return make_unique<EndBufferRecord>();
   case MetadataRecordKinds::NewCPUIdKind:
     return make_unique<NewCPUIDRecord>();
   case MetadataRecordKinds::TSCWrapKind:
     return make_unique<TSCWrapRecord>();
   case MetadataRecordKinds::WalltimeMarkerKind:
     return make_unique<WallclockRecord>();
   case MetadataRecordKinds::CustomEventMarkerKind:
+    if (Header.Version >= 5)
+      return make_unique<CustomEventRecordV5>();
     return make_unique<CustomEventRecord>();
   case MetadataRecordKinds::CallArgumentKind:
     return make_unique<CallArgRecord>();
   case MetadataRecordKinds::BufferExtentsKind:
     return make_unique<BufferExtents>();
   case MetadataRecordKinds::TypedEventMarkerKind:
-    return createStringError(std::make_error_code(std::errc::invalid_argument),
-                             "Encountered an unsupported TypedEventMarker.");
+    return make_unique<TypedEventRecord>();
   case MetadataRecordKinds::PidKind:
     return make_unique<PIDRecord>();
   case MetadataRecordKinds::EnumEndMarker:
     llvm_unreachable("Invalid MetadataRecordKind");
   }
   llvm_unreachable("Unhandled MetadataRecordKinds enum value");
 }
 

llvm/lib/XRay/FDRRecords.cpp

 Error NewCPUIDRecord::apply(RecordVisitor &V) { return V.visit(*this); }
 Error TSCWrapRecord::apply(RecordVisitor &V) { return V.visit(*this); }
 Error CustomEventRecord::apply(RecordVisitor &V) { return V.visit(*this); }
 Error CallArgRecord::apply(RecordVisitor &V) { return V.visit(*this); }
 Error PIDRecord::apply(RecordVisitor &V) { return V.visit(*this); }
 Error NewBufferRecord::apply(RecordVisitor &V) { return V.visit(*this); }
 Error EndBufferRecord::apply(RecordVisitor &V) { return V.visit(*this); }
 Error FunctionRecord::apply(RecordVisitor &V) { return V.visit(*this); }
+Error CustomEventRecordV5::apply(RecordVisitor &V) { return V.visit(*this); }
+Error TypedEventRecord::apply(RecordVisitor &V) { return V.visit(*this); }
 
 } // namespace xray
 } // namespace llvm

llvm/lib/XRay/FDRTraceExpander.cpp

if (!IgnoringRecords) {
     CurrentRecord.Type = RecordTypes::CUSTOM_EVENT;
     std::copy(R.data().begin(), R.data().end(),
               std::back_inserter(CurrentRecord.Data));
     BuildingRecord = true;
   }
   return Error::success();
 }
 
+Error TraceExpander::visit(CustomEventRecordV5 &R) {
+  resetCurrentRecord();
+  if (!IgnoringRecords) {
+    BaseTSC += R.delta();
+    CurrentRecord.TSC = BaseTSC;
+    CurrentRecord.CPU = CPUId;
+    CurrentRecord.PId = PID;
+    CurrentRecord.TId = TID;
+    CurrentRecord.Type = RecordTypes::CUSTOM_EVENT;
+    std::copy(R.data().begin(), R.data().end(),
+              std::back_inserter(CurrentRecord.Data));
+    BuildingRecord = true;
+  }
+  return Error::success();
+}
+
+Error TraceExpander::visit(TypedEventRecord &R) {
+  resetCurrentRecord();
+  if (!IgnoringRecords) {
+    BaseTSC += R.delta();
+    CurrentRecord.TSC = BaseTSC;
+    CurrentRecord.CPU = CPUId;
+    CurrentRecord.PId = PID;
+    CurrentRecord.TId = TID;
+    CurrentRecord.RecordType = R.eventType();
+    CurrentRecord.Type = RecordTypes::TYPED_EVENT;
+    std::copy(R.data().begin(), R.data().end(),
+              std::back_inserter(CurrentRecord.Data));
+    BuildingRecord = true;
+  }
+  return Error::success();
+}
+
 Error TraceExpander::visit(CallArgRecord &R) {
   CurrentRecord.CallArgs.push_back(R.arg());
   CurrentRecord.Type = RecordTypes::ENTER_ARG;
   return Error::success();
 }
 
 Error TraceExpander::visit(PIDRecord &R) {
   PID = R.pid();

llvm/lib/XRay/FDRTraceWriter.cpp

Error FDRTraceWriter::visit(CustomEventRecord &R) {
   if (auto E = writeMetadata<5u>(OS, R.size(), R.tsc(), R.cpu()))
     return E;
   auto D = R.data();
   ArrayRef<char> Bytes(D.data(), D.size());
   OS.write(Bytes);
   return Error::success();
 }
 
+Error FDRTraceWriter::visit(CustomEventRecordV5 &R) {
+  if (auto E = writeMetadata<5u>(OS, R.size(), R.delta()))
+    return E;
+  auto D = R.data();
+  ArrayRef<char> Bytes(D.data(), D.size());
+  OS.write(Bytes);
+  return Error::success();
+}
+
+Error FDRTraceWriter::visit(TypedEventRecord &R) {
+  if (auto E = writeMetadata<7u>(OS, R.size(), R.delta(), R.eventType()))
+    return E;
+  auto D = R.data();
+  ArrayRef<char> Bytes(D.data(), D.size());
+  OS.write(Bytes);
+  return Error::success();
+}
+
 Error FDRTraceWriter::visit(CallArgRecord &R) {
   return writeMetadata<6u>(OS, R.arg());
 }
 
 Error FDRTraceWriter::visit(PIDRecord &R) {
   return writeMetadata<9u>(OS, R.pid());
 }
 

llvm/lib/XRay/FileHeaderReader.cpp

return createStringError(
         OffsetPtr);
 
   std::memcpy(&FileHeader.FreeFormData,
               HeaderExtractor.getData().bytes_begin() + OffsetPtr, 16);
 
   // Manually advance the offset pointer 16 bytes, after getting a raw memcpy
   // from the underlying data.
   OffsetPtr += 16;
-  if (FileHeader.Version < 1 || FileHeader.Version > 4)
-    return createStringError(std::make_error_code(std::errc::invalid_argument),
-                             "Unsupported XRay file version: %d at offset %d",
-                             FileHeader.Version, OffsetPtr);
   return std::move(FileHeader);
 }
 
 } // namespace xray
 } // namespace llvm

llvm/lib/XRay/RecordInitializer.cpp

if (E.getU8(&OffsetPtr, Buffer.data(), R.Size) != Buffer.data())
     return createStringError(
         std::make_error_code(std::errc::invalid_argument),
         "Failed reading data into buffer of size %d at offset %d.", R.Size,
         OffsetPtr);
   R.Data.assign(Buffer.begin(), Buffer.end());
   return Error::success();
 }
 
+Error RecordInitializer::visit(CustomEventRecordV5 &R) {
+  if (!E.isValidOffsetForDataOfSize(OffsetPtr,
+                                    MetadataRecord::kMetadataBodySize))
+    return createStringError(std::make_error_code(std::errc::bad_address),
+                             "Invalid offset for a custom event record (%d).",
+                             OffsetPtr);
+
+  auto BeginOffset = OffsetPtr;
+  auto PreReadOffset = OffsetPtr;
+
+  R.Size = E.getSigned(&OffsetPtr, sizeof(int32_t));
+  if (PreReadOffset == OffsetPtr)
+    return createStringError(
+        std::make_error_code(std::errc::invalid_argument),
+        "Cannot read a custom event record size field offset %d.", OffsetPtr);
+
+  PreReadOffset = OffsetPtr;
+  R.Delta = E.getSigned(&OffsetPtr, sizeof(int32_t));
+  if (PreReadOffset == OffsetPtr)
+    return createStringError(
+        std::make_error_code(std::errc::invalid_argument),
+        "Cannot read a custom event record TSC delta field at offset %d.",
+        OffsetPtr);
+
+  assert(OffsetPtr > BeginOffset &&
+         OffsetPtr - BeginOffset <= MetadataRecord::kMetadataBodySize);
+  OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
+
+  // Next we read in a fixed chunk of data from the given offset.
+  if (!E.isValidOffsetForDataOfSize(OffsetPtr, R.Size))
+    return createStringError(
+        std::make_error_code(std::errc::bad_address),
+        "Cannot read %d bytes of custom event data from offset %d.", R.Size,
+        OffsetPtr);
+
+  std::vector<uint8_t> Buffer;
+  Buffer.resize(R.Size);
+  if (E.getU8(&OffsetPtr, Buffer.data(), R.Size) != Buffer.data())
+    return createStringError(
+        std::make_error_code(std::errc::invalid_argument),
+        "Failed reading data into buffer of size %d at offset %d.", R.Size,
+        OffsetPtr);
+  R.Data.assign(Buffer.begin(), Buffer.end());
+  return Error::success();
+}
+
+Error RecordInitializer::visit(TypedEventRecord &R) {
+  if (!E.isValidOffsetForDataOfSize(OffsetPtr,
+                                    MetadataRecord::kMetadataBodySize))
+    return createStringError(std::make_error_code(std::errc::bad_address),
+                             "Invalid offset for a typed event record (%d).",
+                             OffsetPtr);
+
+  auto BeginOffset = OffsetPtr;
+  auto PreReadOffset = OffsetPtr;
+
+  R.Size = E.getSigned(&OffsetPtr, sizeof(int32_t));
+  if (PreReadOffset == OffsetPtr)
+    return createStringError(
+        std::make_error_code(std::errc::invalid_argument),
+        "Cannot read a typed event record size field offset %d.", OffsetPtr);
+
+  PreReadOffset = OffsetPtr;
+  R.Delta = E.getSigned(&OffsetPtr, sizeof(int32_t));
+  if (PreReadOffset == OffsetPtr)
+    return createStringError(
+        std::make_error_code(std::errc::invalid_argument),
+        "Cannot read a typed event record TSC delta field at offset %d.",
+        OffsetPtr);
+
+  PreReadOffset = OffsetPtr;
+  R.EventType = E.getU16(&OffsetPtr);
+  if (PreReadOffset == OffsetPtr)
+    return createStringError(
+        std::make_error_code(std::errc::invalid_argument),
+        "Cannot read a typed event record type field at offset %d.", OffsetPtr);
+
+  assert(OffsetPtr > BeginOffset &&
+         OffsetPtr - BeginOffset <= MetadataRecord::kMetadataBodySize);
+  OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
+
+  // Next we read in a fixed chunk of data from the given offset.
+  if (!E.isValidOffsetForDataOfSize(OffsetPtr, R.Size))
+    return createStringError(
+        std::make_error_code(std::errc::bad_address),
+        "Cannot read %d bytes of custom event data from offset %d.", R.Size,
+        OffsetPtr);
+
+  std::vector<uint8_t> Buffer;
+  Buffer.resize(R.Size);
+  if (E.getU8(&OffsetPtr, Buffer.data(), R.Size) != Buffer.data())
+    return createStringError(
+        std::make_error_code(std::errc::invalid_argument),
+        "Failed reading data into buffer of size %d at offset %d.", R.Size,
+        OffsetPtr);
+  R.Data.assign(Buffer.begin(), Buffer.end());
+  return Error::success();
+}
+
 Error RecordInitializer::visit(CallArgRecord &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
                                     MetadataRecord::kMetadataBodySize))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a call argument record (%d).",
                              OffsetPtr);
 
   auto PreReadOffset = OffsetPtr;

llvm/lib/XRay/RecordPrinter.cpp

 Error RecordPrinter::visit(CustomEventRecord &R) {
   OS << formatv(
             "<Custom Event: tsc = {0}, cpu = {1}, size = {2}, data = '{3}'>",
             R.tsc(), R.cpu(), R.size(), R.data())
      << Delim;
   return Error::success();
 }
 
+Error RecordPrinter::visit(CustomEventRecordV5 &R) {
+  OS << formatv("<Custom Event: delta = +{0}, size = {1}, data = '{2}'>",
+                R.delta(), R.size(), R.data())
+     << Delim;
+  return Error::success();
+}
+
+Error RecordPrinter::visit(TypedEventRecord &R) {
+  OS << formatv(
+            "<Typed Event: delta = +{0}, type = {1}, size = {2}, data = '{3}'",
+            R.delta(), R.eventType(), R.size(), R.data())
+     << Delim;
+  return Error::success();
+}
+
 Error RecordPrinter::visit(CallArgRecord &R) {
   OS << formatv("<Call Argument: data = {0} (hex = {0:x})>", R.arg()) << Delim;
   return Error::success();
 }
 
 Error RecordPrinter::visit(PIDRecord &R) {
   OS << formatv("<PID: {0}>", R.pid()) << Delim;
   return Error::success();

llvm/lib/XRay/Trace.cpp

 ///                in the buffer. This is measured from the start of the buffer
 ///                and must always be at least 48 (bytes).
 ///
 /// In Version 3, we make the following changes:
 ///
 /// ThreadBuffer: BufferExtents NewBuffer WallClockTime Pid NewCPUId
 ///               FunctionSequence
 /// EOB: *deprecated*
+///
+/// In Version 4, we make the following changes:
+///
+/// CustomEventRecord now includes the CPU data.
+///
+/// In Version 5, we make the following changes:
+///
+/// CustomEventRecord and TypedEventRecord now use TSC delta encoding similar to
+/// what FunctionRecord instances use, and we no longer need to include the CPU
+/// id in the CustomEventRecord.
+///
 Error loadFDRLog(StringRef Data, bool IsLittleEndian,
                  XRayFileHeader &FileHeader, std::vector<XRayRecord> &Records) {
 
   if (Data.size() < 32)
     return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Not enough bytes for an XRay FDR log.");
   DataExtractor DE(Data, IsLittleEndian, 8);
 
case NAIVE_FORMAT:
     } else {
       return make_error<StringError>(
           Twine("Unsupported version for Basic/Naive Mode logging: ") +
               Twine(Version),
           std::make_error_code(std::errc::executable_format_error));
     }
     break;
   case FLIGHT_DATA_RECORDER_FORMAT:
-    if (Version >= 1 && Version <= 4) {
+    if (Version >= 1 && Version <= 5) {
       if (auto E = loadFDRLog(DE.getData(), DE.isLittleEndian(), T.FileHeader,
                               T.Records))
         return std::move(E);
     } else {
       return make_error<StringError>(
           Twine("Unsupported version for FDR Mode logging: ") + Twine(Version),
           std::make_error_code(std::errc::executable_format_error));
     }

llvm/unittests/XRay/FDRRecordsTest.cpp

TEST(XRayFDRTest, BuilderAndBlockIndexer) {
   // ensure we find the same records in the blocks we deduce.
   auto Block0 = LogBuilder()
                     .add<BufferExtents>(100)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 1)
                     .add<PIDRecord>(1)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
+                    .add<CustomEventRecordV5>(1, 4, "XRAY")
+                    .add<TypedEventRecord>(1, 4, 2, "XRAY")
                     .consume();
   auto Block1 = LogBuilder()
                     .add<BufferExtents>(100)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 2)
                     .add<PIDRecord>(1)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
+                    .add<CustomEventRecordV5>(1, 4, "XRAY")
+                    .add<TypedEventRecord>(1, 4, 2, "XRAY")
                     .consume();
   auto Block2 = LogBuilder()
                     .add<BufferExtents>(100)
                     .add<NewBufferRecord>(2)
                     .add<WallclockRecord>(1, 3)
                     .add<PIDRecord>(1)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
+                    .add<CustomEventRecordV5>(1, 4, "XRAY")
+                    .add<TypedEventRecord>(1, 4, 2, "XRAY")
                     .consume();
   BlockIndexer::Index Index;
   BlockIndexer Indexer(Index);
   for (auto B : {std::ref(Block0), std::ref(Block1), std::ref(Block2)}) {
     for (auto &R : B.get())
       ASSERT_FALSE(errorToBool(R->apply(Indexer)));
     ASSERT_FALSE(errorToBool(Indexer.flush()));
   }
TEST(XRayFDRTest, IndexAndVerifyBlocks) {
   auto Block0 = LogBuilder()
                     .add<BufferExtents>(64)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 1)
                     .add<PIDRecord>(1)
                     .add<NewCPUIDRecord>(1, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
+                    .add<CustomEventRecordV5>(1, 4, "XRAY")
+                    .add<TypedEventRecord>(1, 4, 2, "XRAY")
                     .consume();
   auto Block1 = LogBuilder()
                     .add<BufferExtents>(64)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 1)
                     .add<PIDRecord>(1)
                     .add<NewCPUIDRecord>(1, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
+                    .add<CustomEventRecordV5>(1, 4, "XRAY")
+                    .add<TypedEventRecord>(1, 4, 2, "XRAY")
                     .consume();
   auto Block2 = LogBuilder()
                     .add<BufferExtents>(64)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 1)
                     .add<PIDRecord>(1)
                     .add<NewCPUIDRecord>(1, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
+                    .add<CustomEventRecordV5>(1, 4, "XRAY")
+                    .add<TypedEventRecord>(1, 4, 2, "XRAY")
                     .consume();
 
   // First, index the records in different blocks.
   BlockIndexer::Index Index;
   BlockIndexer Indexer(Index);
   for (auto B : {std::ref(Block0), std::ref(Block1), std::ref(Block2)}) {
     for (auto &R : B.get())
       ASSERT_FALSE(errorToBool(R->apply(Indexer)));