Movatterモバイル変換

Go to the documentation of this file.

1//===- BlockVerifier.cpp - FDR Block Verifier -----------------------------===//

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#include "llvm/XRay/BlockVerifier.h"

9#include "llvm/Support/Error.h"

11#include <bitset>

13namespacellvm {

14namespacexray {

15namespace{

17constexprunsignedlonglongmask(BlockVerifier::State S) {

18return 1uLL <<static_cast<std::size_t>(S);

19}

21constexpr std::size_t number(BlockVerifier::State S) {

22returnstatic_cast<std::size_t>(S);

23}

25StringRef recordToString(BlockVerifier::State R) {

26switch (R) {

27caseBlockVerifier::State::BufferExtents:

28return"BufferExtents";

29caseBlockVerifier::State::NewBuffer:

30return"NewBuffer";

31caseBlockVerifier::State::WallClockTime:

32return"WallClockTime";

33caseBlockVerifier::State::PIDEntry:

34return"PIDEntry";

35caseBlockVerifier::State::NewCPUId:

36return"NewCPUId";

37caseBlockVerifier::State::TSCWrap:

38return"TSCWrap";

39caseBlockVerifier::State::CustomEvent:

40return"CustomEvent";

41caseBlockVerifier::State::Function:

42return"Function";

43caseBlockVerifier::State::CallArg:

44return"CallArg";

45caseBlockVerifier::State::EndOfBuffer:

46return"EndOfBuffer";

47caseBlockVerifier::State::TypedEvent:

48return"TypedEvent";

49caseBlockVerifier::State::StateMax:

50caseBlockVerifier::State::Unknown:

51return"Unknown";

52 }

53llvm_unreachable("Unkown state!");

54}

56structTransition {

57BlockVerifier::State From;

58 std::bitset<number(BlockVerifier::State::StateMax)>ToStates;

59};

61}// namespace

63Error BlockVerifier::transition(State To) {

64usingToSet = std::bitset<number(State::StateMax)>;

65staticconstexpr std::array<const Transition, number(State::StateMax)>

66 TransitionTable{{{State::Unknown,

67 {mask(State::BufferExtents) |mask(State::NewBuffer)}},

69 {State::BufferExtents, {mask(State::NewBuffer)}},

71 {State::NewBuffer, {mask(State::WallClockTime)}},

73 {State::WallClockTime,

74 {mask(State::PIDEntry) |mask(State::NewCPUId)}},

76 {State::PIDEntry, {mask(State::NewCPUId)}},

78 {State::NewCPUId,

79 {mask(State::NewCPUId) |mask(State::TSCWrap) |

80mask(State::CustomEvent) |mask(State::Function) |

81mask(State::EndOfBuffer) |mask(State::TypedEvent)}},

83 {State::TSCWrap,

84 {mask(State::TSCWrap) |mask(State::NewCPUId) |

85mask(State::CustomEvent) |mask(State::Function) |

86mask(State::EndOfBuffer) |mask(State::TypedEvent)}},

88 {State::CustomEvent,

89 {mask(State::CustomEvent) |mask(State::TSCWrap) |

90mask(State::NewCPUId) |mask(State::Function) |

91mask(State::EndOfBuffer) |mask(State::TypedEvent)}},

93 {State::TypedEvent,

94 {mask(State::TypedEvent) |mask(State::TSCWrap) |

95mask(State::NewCPUId) |mask(State::Function) |

96mask(State::EndOfBuffer) |mask(State::CustomEvent)}},

98 {State::Function,

99 {mask(State::Function) |mask(State::TSCWrap) |

100mask(State::NewCPUId) |mask(State::CustomEvent) |

101mask(State::CallArg) |mask(State::EndOfBuffer) |

102mask(State::TypedEvent)}},

103

104 {State::CallArg,

105 {mask(State::CallArg) |mask(State::Function) |

106mask(State::TSCWrap) |mask(State::NewCPUId) |

107mask(State::CustomEvent) |mask(State::EndOfBuffer) |

108mask(State::TypedEvent)}},

109

110 {State::EndOfBuffer, {}}}};

111

112if (CurrentRecord >=State::StateMax)

113returncreateStringError(

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

115"BUG (BlockVerifier): Cannot find transition table entry for %s, "

116"transitioning to %s.",

117 recordToString(CurrentRecord).data(), recordToString(To).data());

118

119// If we're at an EndOfBuffer record, we ignore anything that follows that

120// isn't a NewBuffer record.

121if (CurrentRecord ==State::EndOfBuffer && To !=State::NewBuffer)

122returnError::success();

123

124auto &Mapping = TransitionTable[number(CurrentRecord)];

125auto &Destinations = Mapping.ToStates;

126assert(Mapping.From == CurrentRecord &&

127"BUG: Wrong index for record mapping.");

128if ((Destinations & ToSet(mask(To))) == 0)

129returncreateStringError(

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

131"BlockVerifier: Invalid transition from %s to %s.",

132 recordToString(CurrentRecord).data(), recordToString(To).data());

133

134 CurrentRecord = To;

135returnError::success();

136}// namespace xray

137

138Error BlockVerifier::visit(BufferExtents &) {

139return transition(State::BufferExtents);

140}

141

142Error BlockVerifier::visit(WallclockRecord &) {

143return transition(State::WallClockTime);

144}

145

146Error BlockVerifier::visit(NewCPUIDRecord &) {

147return transition(State::NewCPUId);

148}

149

150Error BlockVerifier::visit(TSCWrapRecord &) {

151return transition(State::TSCWrap);

152}

153

154Error BlockVerifier::visit(CustomEventRecord &) {

155return transition(State::CustomEvent);

156}

157

158Error BlockVerifier::visit(CustomEventRecordV5 &) {

159return transition(State::CustomEvent);

160}

161

162Error BlockVerifier::visit(TypedEventRecord &) {

163return transition(State::TypedEvent);

164}

165

166Error BlockVerifier::visit(CallArgRecord &) {

167return transition(State::CallArg);

168}

169

170Error BlockVerifier::visit(PIDRecord &) {return transition(State::PIDEntry); }

171

172Error BlockVerifier::visit(NewBufferRecord &) {

173return transition(State::NewBuffer);

174}

175

176Error BlockVerifier::visit(EndBufferRecord &) {

177return transition(State::EndOfBuffer);

178}

179

180Error BlockVerifier::visit(FunctionRecord &) {

181return transition(State::Function);

182}

183

184Error BlockVerifier::verify() {

185// The known terminal conditions are the following:

186switch (CurrentRecord) {

187caseState::EndOfBuffer:

188caseState::NewCPUId:

189caseState::CustomEvent:

190caseState::TypedEvent:

191caseState::Function:

192caseState::CallArg:

193caseState::TSCWrap:

194returnError::success();

195default:

196returncreateStringError(

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

198"BlockVerifier: Invalid terminal condition %s, malformed block.",

199 recordToString(CurrentRecord).data());

200 }

201}

202

203voidBlockVerifier::reset() { CurrentRecord =State::Unknown; }

204

205}// namespace xray

206}// namespace llvm

ToStates

std::bitset< number(BlockVerifier::State::StateMax)> ToStates

Definition:BlockVerifier.cpp:58

From

BlockVerifier::State From

Definition:BlockVerifier.cpp:57

BlockVerifier.h

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

data

static Split data

Definition:StaticDataSplitter.cpp:176

llvm::Error

Lightweight error class with error context and mandatory checking.

Definition:Error.h:160

llvm::Error::success

static ErrorSuccess success()

Create a success value.

Definition:Error.h:337

llvm::xray::BlockVerifier::visit

Error visit(BufferExtents &) override

Definition:BlockVerifier.cpp:138

llvm::xray::BlockVerifier::verify

Error verify()

Definition:BlockVerifier.cpp:184

llvm::xray::BlockVerifier::State

State

Definition:BlockVerifier.h:24

llvm::xray::BlockVerifier::State::WallClockTime

@ WallClockTime

llvm::xray::BlockVerifier::State::CallArg

@ CallArg

llvm::xray::BlockVerifier::State::NewCPUId

@ NewCPUId

llvm::xray::BlockVerifier::State::TypedEvent

@ TypedEvent

llvm::xray::BlockVerifier::State::TSCWrap

@ TSCWrap

llvm::xray::BlockVerifier::State::Function

@ Function

llvm::xray::BlockVerifier::State::Unknown

@ Unknown

llvm::xray::BlockVerifier::State::NewBuffer

@ NewBuffer

llvm::xray::BlockVerifier::State::StateMax

@ StateMax

llvm::xray::BlockVerifier::State::PIDEntry

@ PIDEntry

llvm::xray::BlockVerifier::State::CustomEvent

@ CustomEvent

llvm::xray::BlockVerifier::State::BufferExtents

@ BufferExtents

llvm::xray::BlockVerifier::State::EndOfBuffer

@ EndOfBuffer

llvm::xray::BlockVerifier::reset

void reset()

Definition:BlockVerifier.cpp:203

llvm::xray::BufferExtents

Definition:FDRRecords.h:110

llvm::xray::CallArgRecord

Definition:FDRRecords.h:291

llvm::xray::CustomEventRecordV5

Definition:FDRRecords.h:235

llvm::xray::CustomEventRecord

Definition:FDRRecords.h:206

llvm::xray::EndBufferRecord

Definition:FDRRecords.h:359

llvm::xray::FunctionRecord

Definition:FDRRecords.h:372

llvm::xray::NewBufferRecord

Definition:FDRRecords.h:336

llvm::xray::NewCPUIDRecord

Definition:FDRRecords.h:158

llvm::xray::PIDRecord

Definition:FDRRecords.h:313

llvm::xray::TSCWrapRecord

Definition:FDRRecords.h:184

llvm::xray::TypedEventRecord

Definition:FDRRecords.h:262

llvm::xray::WallclockRecord

Definition:FDRRecords.h:133

llvm_unreachable

#define llvm_unreachable(msg)

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

Definition:ErrorHandling.h:143

Error.h

llvm::lltok::Error

@ Error

Definition:LLToken.h:21

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::createStringError

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

Create formatted StringError object.

Definition:Error.h:1291

shuffles::mask

auto mask(ShuffFunc S, unsigned Length, OptArgs... args) -> MaskT

Definition:HexagonISelDAGToDAGHVX.cpp:899