llvm/lib/XRay/FDRTraceWriter.cpp

   1 //===- FDRTraceWriter.cpp - XRay FDR Trace Writer ---------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Test a utility that can write out XRay FDR Mode formatted trace files.
  10 //
  11 //===----------------------------------------------------------------------===//
  12 #include "llvm/XRay/FDRTraceWriter.h"
  13 #include <tuple>
  14
  15 namespace llvm {
  16 namespace xray {
  17
  18 namespace {
  19
  20 template <size_t Index> struct IndexedWriter {
  21   template <
  22       class Tuple,
  23       std::enable_if_t<(Index <
  24                         std::tuple_size<std::remove_reference_t<Tuple>>::value),
  25                        int> = 0>
  26   static size_t write(support::endian::Writer &OS, Tuple &&T) {
  27     OS.write(std::get<Index>(T));
  28     return sizeof(std::get<Index>(T)) + IndexedWriter<Index + 1>::write(OS, T);
  29   }
  30
  31   template <
  32       class Tuple,
  33       std::enable_if_t<(Index >=
  34                         std::tuple_size<std::remove_reference_t<Tuple>>::value),
  35                        int> = 0>
  36   static size_t write(support::endian::Writer &OS, Tuple &&) {
  37     return 0;
  38   }
  39 };
  40
  41 template <uint8_t Kind, class... Values>
  42 Error writeMetadata(support::endian::Writer &OS, Values &&... Ds) {
  43   // The first bit in the first byte of metadata records is always set to 1, so
  44   // we ensure this is the case when we write out the first byte of the record.
  45   uint8_t FirstByte = (static_cast<uint8_t>(Kind) << 1) | uint8_t{0x01u};
  46   auto T = std::make_tuple(std::forward<Values>(std::move(Ds))...);
  47   // Write in field order.
  48   OS.write(FirstByte);
  49   auto Bytes = IndexedWriter<0>::write(OS, T);
  50   assert(Bytes <= 15 && "Must only ever write at most 16 byte metadata!");
  51   // Pad out with appropriate numbers of zero's.
  52   for (; Bytes < 15; ++Bytes)
  53     OS.write('\0');
  54   return Error::success();
  55 }
  56
  57 } // namespace
  58
  59 FDRTraceWriter::FDRTraceWriter(raw_ostream &O, const XRayFileHeader &H)
  60     : OS(O, llvm::endianness::native) {
  61   // We need to re-construct a header, by writing the fields we care about for
  62   // traces, in the format that the runtime would have written.
  63   uint32_t BitField =
  64       (H.ConstantTSC ? 0x01 : 0x0) | (H.NonstopTSC ? 0x02 : 0x0);
  65
  66   // For endian-correctness, we need to write these fields in the order they
  67   // appear and that we expect, instead of blasting bytes of the struct through.
  68   OS.write(H.Version);
  69   OS.write(H.Type);
  70   OS.write(BitField);
  71   OS.write(H.CycleFrequency);
  72   ArrayRef<char> FreeFormBytes(H.FreeFormData,
  73                                sizeof(XRayFileHeader::FreeFormData));
  74   OS.write(FreeFormBytes);
  75 }
  76
  77 FDRTraceWriter::~FDRTraceWriter() = default;
  78
  79 Error FDRTraceWriter::visit(BufferExtents &R) {
  80   return writeMetadata<7u>(OS, R.size());
  81 }
  82
  83 Error FDRTraceWriter::visit(WallclockRecord &R) {
  84   return writeMetadata<4u>(OS, R.seconds(), R.nanos());
  85 }
  86
  87 Error FDRTraceWriter::visit(NewCPUIDRecord &R) {
  88   return writeMetadata<2u>(OS, R.cpuid(), R.tsc());
  89 }
  90
  91 Error FDRTraceWriter::visit(TSCWrapRecord &R) {
  92   return writeMetadata<3u>(OS, R.tsc());
  93 }
  94
  95 Error FDRTraceWriter::visit(CustomEventRecord &R) {
  96   if (auto E = writeMetadata<5u>(OS, R.size(), R.tsc(), R.cpu()))
  97     return E;
  98   auto D = R.data();
  99   ArrayRef<char> Bytes(D.data(), D.size());
 100   OS.write(Bytes);
 101   return Error::success();
 102 }
 103
 104 Error FDRTraceWriter::visit(CustomEventRecordV5 &R) {
 105   if (auto E = writeMetadata<5u>(OS, R.size(), R.delta()))
 106     return E;
 107   auto D = R.data();
 108   ArrayRef<char> Bytes(D.data(), D.size());
 109   OS.write(Bytes);
 110   return Error::success();
 111 }
 112
 113 Error FDRTraceWriter::visit(TypedEventRecord &R) {
 114   if (auto E = writeMetadata<8u>(OS, R.size(), R.delta(), R.eventType()))
 115     return E;
 116   auto D = R.data();
 117   ArrayRef<char> Bytes(D.data(), D.size());
 118   OS.write(Bytes);
 119   return Error::success();
 120 }
 121
 122 Error FDRTraceWriter::visit(CallArgRecord &R) {
 123   return writeMetadata<6u>(OS, R.arg());
 124 }
 125
 126 Error FDRTraceWriter::visit(PIDRecord &R) {
 127   return writeMetadata<9u>(OS, R.pid());
 128 }
 129
 130 Error FDRTraceWriter::visit(NewBufferRecord &R) {
 131   return writeMetadata<0u>(OS, R.tid());
 132 }
 133
 134 Error FDRTraceWriter::visit(EndBufferRecord &R) {
 135   return writeMetadata<1u>(OS, 0);
 136 }
 137
 138 Error FDRTraceWriter::visit(FunctionRecord &R) {
 139   // Write out the data in "field" order, to be endian-aware.
 140   uint32_t TypeRecordFuncId = uint32_t{R.functionId() & ~uint32_t{0x0Fu << 28}};
 141   TypeRecordFuncId <<= 3;
 142   TypeRecordFuncId |= static_cast<uint32_t>(R.recordType());
 143   TypeRecordFuncId <<= 1;
 144   TypeRecordFuncId &= ~uint32_t{0x01};
 145   OS.write(TypeRecordFuncId);
 146   OS.write(R.delta());
 147   return Error::success();
 148 }
 149
 150 } // namespace xray
 151 } // namespace llvm