FDRRecordProducer.cpp Source File (original) (raw)

11#include

13using namespace llvm;

16namespace {

20enum MetadataRecordKinds : uint8_t {

21 NewBufferKind,

22 EndOfBufferKind,

23 NewCPUIdKind,

24 TSCWrapKind,

25 WalltimeMarkerKind,

26 CustomEventMarkerKind,

27 CallArgumentKind,

28 BufferExtentsKind,

29 TypedEventMarkerKind,

30 PidKind,

32 EnumEndMarker,

33};

34}

39 if (T >= static_cast<uint8_t>(MetadataRecordKinds::EnumEndMarker))

40 return createStringError(std::make_error_code(std::errc::invalid_argument),

41 "Invalid metadata record type: %d", T);

42 switch (T) {

43 case MetadataRecordKinds::NewBufferKind:

44 return std::make_unique();

45 case MetadataRecordKinds::EndOfBufferKind:

46 if (Header.Version >= 2)

48 std::make_error_code(std::errc::executable_format_error),

49 "End of buffer records are no longer supported starting version "

50 "2 of the log.");

51 return std::make_unique();

52 case MetadataRecordKinds::NewCPUIdKind:

53 return std::make_unique();

54 case MetadataRecordKinds::TSCWrapKind:

55 return std::make_unique();

56 case MetadataRecordKinds::WalltimeMarkerKind:

57 return std::make_unique();

58 case MetadataRecordKinds::CustomEventMarkerKind:

59 if (Header.Version >= 5)

60 return std::make_unique();

61 return std::make_unique();

62 case MetadataRecordKinds::CallArgumentKind:

63 return std::make_unique();

64 case MetadataRecordKinds::BufferExtentsKind:

65 return std::make_unique();

66 case MetadataRecordKinds::TypedEventMarkerKind:

67 return std::make_unique();

68 case MetadataRecordKinds::PidKind:

69 return std::make_unique();

70 case MetadataRecordKinds::EnumEndMarker:

72 }

74}

77 return FirstByte & 0x01u;

78}

81FileBasedRecordProducer::findNextBufferExtent() {

84 std::unique_ptr R;

85 while (!R) {

86 auto PreReadOffset = OffsetPtr;

87 uint8_t FirstByte = E.getU8(&OffsetPtr);

88 if (OffsetPtr == PreReadOffset)

90 std::make_error_code(std::errc::executable_format_error),

91 "Failed reading one byte from offset %" PRId64 ".", OffsetPtr);

94 auto LoadedType = FirstByte >> 1;

95 if (LoadedType == MetadataRecordKinds::BufferExtentsKind) {

97 if (!MetadataRecordOrErr)

98 return MetadataRecordOrErr.takeError();

100 R = std::move(MetadataRecordOrErr.get());

101 RecordInitializer RI(E, OffsetPtr);

102 if (auto Err = R->apply(RI))

103 return std::move(Err);

104 return std::move(R);

105 }

106 }

107 }

108 llvm_unreachable("Must always terminate with either an error or a record.");

109}

110

112

113 std::unique_ptr R;

114

115

116

117

118

119 if (Header.Version >= 3 && CurrentBufferBytes == 0) {

120

121 auto BufferExtentsOrError = findNextBufferExtent();

122 if (!BufferExtentsOrError)

124 BufferExtentsOrError.takeError(),

126 std::make_error_code(std::errc::executable_format_error),

127 "Failed to find the next BufferExtents record."));

128

129 R = std::move(BufferExtentsOrError.get());

130 assert(R != nullptr);

133 CurrentBufferBytes = BE->size();

134 return std::move(R);

135 }

136

137

138

139

140

141

142

143

144

145

146

147

148 auto PreReadOffset = OffsetPtr;

149 uint8_t FirstByte = E.getU8(&OffsetPtr);

150 if (OffsetPtr == PreReadOffset)

152 std::make_error_code(std::errc::executable_format_error),

153 "Failed reading one byte from offset %" PRId64 ".", OffsetPtr);

154

155

157 auto LoadedType = FirstByte >> 1;

159 if (!MetadataRecordOrErr)

161 MetadataRecordOrErr.takeError(),

163 std::make_error_code(std::errc::executable_format_error),

164 "Encountered an unsupported metadata record (%d) "

165 "at offset %" PRId64 ".",

166 LoadedType, PreReadOffset));

167 R = std::move(MetadataRecordOrErr.get());

168 } else {

169 R = std::make_unique();

170 }

172

173 if (auto Err = R->apply(RI))

174 return std::move(Err);

175

176

177

178

180 CurrentBufferBytes = BE->size();

181 } else if (Header.Version >= 3) {

182 if (OffsetPtr - PreReadOffset > CurrentBufferBytes)

184 std::make_error_code(std::errc::executable_format_error),

185 "Buffer over-read at offset %" PRId64 " (over-read by %" PRId64

186 " bytes); Record Type = %s.",

187 OffsetPtr, (OffsetPtr - PreReadOffset) - CurrentBufferBytes,

189

190 CurrentBufferBytes -= OffsetPtr - PreReadOffset;

191 }

192 assert(R != nullptr);

193 return std::move(R);

194}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static constexpr bool isMetadataIntroducer(uint8_t FirstByte)

Definition FDRRecordProducer.cpp:76

static Expected< std::unique_ptr< Record > > metadataRecordType(const XRayFileHeader &Header, uint8_t T)

Definition FDRRecordProducer.cpp:37

Tagged union holding either a T or a Error.

Expected< std::unique_ptr< Record > > produce() override

This producer encapsulates the logic for loading a File-backed RecordProducer hidden behind a DataExt...

Definition FDRRecordProducer.cpp:111

static LLVM_ABI StringRef kindToString(RecordKind K)

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

This is an optimization pass for GlobalISel generic memory operations.

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)

Create formatted StringError object.

Error joinErrors(Error E1, Error E2)

Concatenate errors.

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.