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 152