LLVM: lib/Remarks/YAMLRemarkParser.cpp Source File

26 static void handleDiagnostic(const SMDiagnostic &Diag, void *Ctx) {

27 assert(Ctx && "Expected non-null Ctx in diagnostic handler.");

28 std::string &Message = *static_cast<std::string *>(Ctx);

29 assert(Message.empty() && "Expected an empty string.");

30 raw_string_ostream OS(Message);

31 Diag.print(/*ProgName=*/nullptr, OS, /*ShowColors*/ false,

32 /*ShowKindLabels*/ true);

33 OS << '\n';

34 OS.flush();

35}

37 YAMLParseError::YAMLParseError(StringRef Msg, SourceMgr &SM,

38 yaml::Stream &Stream, yaml::Node &Node) {

39 // 1) Set up a diagnostic handler to avoid errors being printed out to

40 // stderr.

41 // 2) Use the stream to print the error with the associated node.

42 // 3) The stream will use the source manager to print the error, which will

43 // call the diagnostic handler.

44 // 4) The diagnostic handler will stream the error directly into this object's

45 // Message member, which is used when logging is asked for.

46 auto OldDiagHandler = SM.getDiagHandler();

47 auto OldDiagCtx = SM.getDiagContext();

48 SM.setDiagHandler(handleDiagnostic, &Message);

49 Stream.printError(&Node, Twine(Msg) + Twine('\n'));

50 // Restore the old handlers.

51 SM.setDiagHandler(OldDiagHandler, OldDiagCtx);

52}

54 static SourceMgr setupSM(std::string &LastErrorMessage) {

55 SourceMgr SM;

56 SM.setDiagHandler(handleDiagnostic, &LastErrorMessage);

57 return SM;

58}

62 static Expected<bool> parseMagic(StringRef &Buf) {

63 if (!Buf.consume_front(remarks::Magic))

64 return false;

65

66 if (Buf.size() < 1 || !Buf.consume_front(StringRef("0円", 1)))

67 return createStringError(std::errc::illegal_byte_sequence,

68 "Expecting \0円 after magic number.");

69 return true;

70}

72 static Expected<uint64_t> parseVersion(StringRef &Buf) {

73 if (Buf.size() < sizeof(uint64_t))

74 return createStringError(std::errc::illegal_byte_sequence,

75 "Expecting version number.");

76

77 uint64_t Version =

78 support::endian::read<uint64_t, llvm::endianness::little>(Buf.data());

79 if (Version != remarks::CurrentRemarkVersion)

80 return createStringError(std::errc::illegal_byte_sequence,

81 "Mismatching remark version. Got %" PRId64

82 ", expected %" PRId64 ".",

83 Version, remarks::CurrentRemarkVersion);

84 Buf = Buf.drop_front(sizeof(uint64_t));

85 return Version;

86}

88 static Expected<uint64_t> parseStrTabSize(StringRef &Buf) {

89 if (Buf.size() < sizeof(uint64_t))

90 return createStringError(std::errc::illegal_byte_sequence,

91 "Expecting string table size.");

92 uint64_t StrTabSize =

93 support::endian::read<uint64_t, llvm::endianness::little>(Buf.data());

94 Buf = Buf.drop_front(sizeof(uint64_t));

95 return StrTabSize;

96}

98 Expected<std::unique_ptr<YAMLRemarkParser>> remarks::createYAMLParserFromMeta(

99 StringRef Buf, std::optional<StringRef> ExternalFilePrependPath) {

100 // We now have a magic number. The metadata has to be correct.

101 Expected<bool> isMeta = parseMagic(Buf);

102 if (!isMeta)

103 return isMeta.takeError();

104 // If it's not recognized as metadata, roll back.

105 std::unique_ptr<MemoryBuffer> SeparateBuf;

106 if (*isMeta) {

107 Expected<uint64_t> Version = parseVersion(Buf);

108 if (!Version)

109 return Version.takeError();

110

111 Expected<uint64_t> StrTabSize = parseStrTabSize(Buf);

112 if (!StrTabSize)

113 return StrTabSize.takeError();

114

115 if (*StrTabSize != 0) {

116 return createStringError(std::errc::illegal_byte_sequence,

117 "String table unsupported for YAML format.");

118 }

119 // If it starts with "---", there is no external file.

120 if (!Buf.starts_with("---")) {

121 // At this point, we expect Buf to contain the external file path.

122 StringRef ExternalFilePath = Buf;

123 SmallString<80> FullPath;

124 if (ExternalFilePrependPath)

125 FullPath = *ExternalFilePrependPath;

126 sys::path::append(FullPath, ExternalFilePath);

127

128 // Try to open the file and start parsing from there.

129 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =

130 MemoryBuffer::getFile(FullPath);

131 if (std::error_code EC = BufferOrErr.getError())

132 return createFileError(FullPath, EC);

133

134 // Keep the buffer alive.

135 SeparateBuf = std::move(*BufferOrErr);

136 Buf = SeparateBuf->getBuffer();

137 }

138 }

139

140 std::unique_ptr<YAMLRemarkParser> Result =

141 std::make_unique<YAMLRemarkParser>(Buf);

142 if (SeparateBuf)

143 Result->SeparateBuf = std::move(SeparateBuf);

144 return std::move(Result);

145}

147 YAMLRemarkParser::YAMLRemarkParser(StringRef Buf)

148 : RemarkParser{Format::YAML}, SM(setupSM(LastErrorMessage)),

149 Stream(Buf, SM), YAMLIt(Stream.begin()) {}

151 Error YAMLRemarkParser::error(StringRef Message, yaml::Node &Node) {

152 return make_error<YAMLParseError>(Message, SM, Stream, Node);

153}

155 Error YAMLRemarkParser::error() {

156 if (LastErrorMessage.empty())

157 return Error::success();

158 Error E = make_error<YAMLParseError>(LastErrorMessage);

159 LastErrorMessage.clear();

160 return E;

161}

164 YAMLRemarkParser::parseRemark(yaml::Document &RemarkEntry) {

165 if (Error E = error())

166 return std::move(E);

167

168 yaml::Node *YAMLRoot = RemarkEntry.getRoot();

169 if (!YAMLRoot) {

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

171 "not a valid YAML file.");

172 }

173

174 auto *Root = dyn_cast<yaml::MappingNode>(YAMLRoot);

175 if (!Root)

176 return error("document root is not of mapping type.", *YAMLRoot);

177

178 std::unique_ptr<Remark> Result = std::make_unique<Remark>();

179 Remark &TheRemark = *Result;

180

181 // First, the type. It needs special handling since is not part of the

182 // key-value stream.

183 Expected<Type> T = parseType(*Root);

184 if (!T)

185 return T.takeError();

186

187 TheRemark.RemarkType = *T;

188

189 // Then, parse the fields, one by one.

190 for (yaml::KeyValueNode &RemarkField : *Root) {

191 Expected<StringRef> MaybeKey = parseKey(RemarkField);

192 if (!MaybeKey)

193 return MaybeKey.takeError();

194 StringRef KeyName = *MaybeKey;

195

196 if (KeyName == "Pass") {

197 if (Expected<StringRef> MaybeStr = parseStr(RemarkField))

198 TheRemark.PassName = *MaybeStr;

199 else

200 return MaybeStr.takeError();

201 } else if (KeyName == "Name") {

202 if (Expected<StringRef> MaybeStr = parseStr(RemarkField))

203 TheRemark.RemarkName = *MaybeStr;

204 else

205 return MaybeStr.takeError();

206 } else if (KeyName == "Function") {

207 if (Expected<StringRef> MaybeStr = parseStr(RemarkField))

208 TheRemark.FunctionName = *MaybeStr;

209 else

210 return MaybeStr.takeError();

211 } else if (KeyName == "Hotness") {

212 if (Expected<unsigned> MaybeU = parseUnsigned(RemarkField))

213 TheRemark.Hotness = *MaybeU;

214 else

215 return MaybeU.takeError();

216 } else if (KeyName == "DebugLoc") {

217 if (Expected<RemarkLocation> MaybeLoc = parseDebugLoc(RemarkField))

218 TheRemark.Loc = *MaybeLoc;

219 else

220 return MaybeLoc.takeError();

221 } else if (KeyName == "Args") {

222 auto *Args = dyn_cast<yaml::SequenceNode>(RemarkField.getValue());

223 if (!Args)

224 return error("wrong value type for key.", RemarkField);

225

226 for (yaml::Node &Arg : *Args) {

227 if (Expected<Argument> MaybeArg = parseArg(Arg))

228 TheRemark.Args.push_back(*MaybeArg);

229 else

230 return MaybeArg.takeError();

231 }

232 } else {

233 return error("unknown key.", RemarkField);

234 }

235 }

236

237 // Check if any of the mandatory fields are missing.

238 if (TheRemark.RemarkType == Type::Unknown || TheRemark.PassName.empty() ||

239 TheRemark.RemarkName.empty() || TheRemark.FunctionName.empty())

240 return error("Type, Pass, Name or Function missing.",

241 *RemarkEntry.getRoot());

242

243 return std::move(Result);

244}

246 Expected<Type> YAMLRemarkParser::parseType(yaml::MappingNode &Node) {

247 auto Type = StringSwitch<remarks::Type>(Node.getRawTag())

248 .Case("!Passed", remarks::Type::Passed)

249 .Case("!Missed", remarks::Type::Missed)

250 .Case("!Analysis", remarks::Type::Analysis)

251 .Case("!AnalysisFPCommute", remarks::Type::AnalysisFPCommute)

252 .Case("!AnalysisAliasing", remarks::Type::AnalysisAliasing)

253 .Case("!Failure", remarks::Type::Failure)

254 .Default(remarks::Type::Unknown);

255 if (Type == remarks::Type::Unknown)

256 return error("expected a remark tag.", Node);

257 return Type;

258}

260 Expected<StringRef> YAMLRemarkParser::parseKey(yaml::KeyValueNode &Node) {

261 if (auto *Key = dyn_cast<yaml::ScalarNode>(Node.getKey()))

262 return Key->getRawValue();

263

264 return error("key is not a string.", Node);

265}

267 Expected<StringRef> YAMLRemarkParser::parseStr(yaml::KeyValueNode &Node) {

268 auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());

269 yaml::BlockScalarNode *ValueBlock;

270 StringRef Result;

271 if (!Value) {

272 // Try to parse the value as a block node.

273 ValueBlock = dyn_cast<yaml::BlockScalarNode>(Node.getValue());

274 if (!ValueBlock)

275 return error("expected a value of scalar type.", Node);

276 Result = ValueBlock->getValue();

277 } else

278 Result = Value->getRawValue();

279

280 Result.consume_front("\'");

281 Result.consume_back("\'");

282

283 return Result;

284}

286 Expected<unsigned> YAMLRemarkParser::parseUnsigned(yaml::KeyValueNode &Node) {

287 SmallVector<char, 4> Tmp;

288 auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());

289 if (!Value)

290 return error("expected a value of scalar type.", Node);

291 unsigned UnsignedValue = 0;

292 if (Value->getValue(Tmp).getAsInteger(10, UnsignedValue))

293 return error("expected a value of integer type.", *Value);

294 return UnsignedValue;

295}

298 YAMLRemarkParser::parseDebugLoc(yaml::KeyValueNode &Node) {

299 auto *DebugLoc = dyn_cast<yaml::MappingNode>(Node.getValue());

300 if (!DebugLoc)

301 return error("expected a value of mapping type.", Node);

302

303 std::optional<StringRef> File;

304 std::optional<unsigned> Line;

305 std::optional<unsigned> Column;

306

307 for (yaml::KeyValueNode &DLNode : *DebugLoc) {

308 Expected<StringRef> MaybeKey = parseKey(DLNode);

309 if (!MaybeKey)

310 return MaybeKey.takeError();

311 StringRef KeyName = *MaybeKey;

312

313 if (KeyName == "File") {

314 if (Expected<StringRef> MaybeStr = parseStr(DLNode))

315 File = *MaybeStr;

316 else

317 return MaybeStr.takeError();

318 } else if (KeyName == "Column") {

319 if (Expected<unsigned> MaybeU = parseUnsigned(DLNode))

320 Column = *MaybeU;

321 else

322 return MaybeU.takeError();

323 } else if (KeyName == "Line") {

324 if (Expected<unsigned> MaybeU = parseUnsigned(DLNode))

325 Line = *MaybeU;

326 else

327 return MaybeU.takeError();

328 } else {

329 return error("unknown entry in DebugLoc map.", DLNode);

330 }

331 }

332

333 // If any of the debug loc fields is missing, return an error.

334 if (!File || !Line || !Column)

335 return error("DebugLoc node incomplete.", Node);

336

337 return RemarkLocation{*File, *Line, *Column};

338}

340 Expected<Argument> YAMLRemarkParser::parseArg(yaml::Node &Node) {

341 auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);

342 if (!ArgMap)

343 return error("expected a value of mapping type.", Node);

344

345 std::optional<StringRef> KeyStr;

346 std::optional<StringRef> ValueStr;

347 std::optional<RemarkLocation> Loc;

348

349 for (yaml::KeyValueNode &ArgEntry : *ArgMap) {

350 Expected<StringRef> MaybeKey = parseKey(ArgEntry);

351 if (!MaybeKey)

352 return MaybeKey.takeError();

353 StringRef KeyName = *MaybeKey;

354

355 // Try to parse debug locs.

356 if (KeyName == "DebugLoc") {

357 // Can't have multiple DebugLoc entries per argument.

358 if (Loc)

359 return error("only one DebugLoc entry is allowed per argument.",

360 ArgEntry);

361

362 if (Expected<RemarkLocation> MaybeLoc = parseDebugLoc(ArgEntry)) {

363 Loc = *MaybeLoc;

364 continue;

365 } else

366 return MaybeLoc.takeError();

367 }

368

369 // If we already have a string, error out.

370 if (ValueStr)

371 return error("only one string entry is allowed per argument.", ArgEntry);

372

373 // Try to parse the value.

374 if (Expected<StringRef> MaybeStr = parseStr(ArgEntry))

375 ValueStr = *MaybeStr;

376 else

377 return MaybeStr.takeError();

378

379 // Keep the key from the string.

380 KeyStr = KeyName;

381 }

382

383 if (!KeyStr)

384 return error("argument key is missing.", *ArgMap);

385 if (!ValueStr)

386 return error("argument value is missing.", *ArgMap);

387

388 Argument Arg;

389 Arg.Key = *KeyStr;

390 Arg.Val = *ValueStr;

391 Arg.Loc = Loc;

392 return Arg;

393}

395 Expected<std::unique_ptr<Remark>> YAMLRemarkParser::next() {

396 if (YAMLIt == Stream.end())

397 return make_error<EndOfFileError>();

398

399 Expected<std::unique_ptr<Remark>> MaybeResult = parseRemark(*YAMLIt);

400 if (!MaybeResult) {

401 // Avoid garbage input, set the iterator to the end.

402 YAMLIt = Stream.end();

403 return MaybeResult.takeError();

404 }

405

406 ++YAMLIt;

407

408 return std::move(*MaybeResult);

409}

assert

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

parseVersion

static Version parseVersion(StringRef Name)

Definition CodeViewDebug.cpp:861

Endian.h

T

#define T

Definition Mips16ISelLowering.cpp:353

Path.h

SmallString.h

This file defines the SmallString class.

StringSwitch.h

This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...

setupSM

static SourceMgr setupSM(std::string &LastErrorMessage)

Definition YAMLRemarkParser.cpp:54

parseStrTabSize

static Expected< uint64_t > parseStrTabSize(StringRef &Buf)

Definition YAMLRemarkParser.cpp:88

handleDiagnostic

static void handleDiagnostic(const SMDiagnostic &Diag, void *Ctx)

Definition YAMLRemarkParser.cpp:26

parseMagic

static Expected< bool > parseMagic(StringRef &Buf)

Definition YAMLRemarkParser.cpp:62

YAMLRemarkParser.h

Node

Definition ItaniumDemangle.h:166

llvm::DebugLoc

A debug info location.

Definition DebugLoc.h:124

llvm::ErrorOr

Represents either an error or a value T.

Definition ErrorOr.h:56

llvm::ErrorOr::getError

std::error_code getError() const

Definition ErrorOr.h:152

llvm::Error

Lightweight error class with error context and mandatory checking.

Definition Error.h:159

llvm::Error::success

static ErrorSuccess success()

Create a success value.

Definition Error.h:336

llvm::Expected

Tagged union holding either a T or a Error.

Definition Error.h:485

llvm::Expected::takeError

Error takeError()

Take ownership of the stored error.

Definition Error.h:612

llvm::MemoryBuffer::getFile

static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)

Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...

Definition MemoryBuffer.cpp:258

llvm::SMDiagnostic

Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...

Definition SourceMgr.h:297

llvm::SMDiagnostic::print

LLVM_ABI void print(const char *ProgName, raw_ostream &S, bool ShowColors=true, bool ShowKindLabel=true, bool ShowLocation=true) const

Definition SourceMgr.cpp:504

llvm::SmallString

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

Definition SmallString.h:26

llvm::SmallVector

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Definition SmallVector.h:1203

llvm::SourceMgr

This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling.

Definition SourceMgr.h:37

llvm::SourceMgr::getDiagContext

void * getDiagContext() const

Definition SourceMgr.h:134

llvm::SourceMgr::getDiagHandler

DiagHandlerTy getDiagHandler() const

Definition SourceMgr.h:133

llvm::SourceMgr::setDiagHandler

void setDiagHandler(DiagHandlerTy DH, void *Ctx=nullptr)

Specify a diagnostic handler to be invoked every time PrintMessage is called.

Definition SourceMgr.h:128

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition StringRef.h:55

llvm::StringRef::starts_with

bool starts_with(StringRef Prefix) const

Check if this string starts with the given Prefix.

Definition StringRef.h:261

llvm::StringRef::empty

constexpr bool empty() const

empty - Check if the string is empty.

Definition StringRef.h:143

llvm::StringRef::drop_front

StringRef drop_front(size_t N=1) const

Return a StringRef equal to 'this' but with the first N elements dropped.

Definition StringRef.h:611

llvm::StringRef::size

constexpr size_t size() const

size - Get the string size.

Definition StringRef.h:146

llvm::StringRef::data

constexpr const char * data() const

data - Get a pointer to the start of the string (which may not be null terminated).

Definition StringRef.h:140

llvm::StringRef::consume_front

bool consume_front(StringRef Prefix)

Returns true if this StringRef has the given prefix and removes that prefix.

Definition StringRef.h:637

llvm::StringSwitch

A switch()-like statement whose cases are string literals.

Definition StringSwitch.h:47

llvm::StringSwitch::Case

StringSwitch & Case(StringLiteral S, T Value)

Definition StringSwitch.h:69

llvm::StringSwitch::Default

R Default(T Value)

Definition StringSwitch.h:201

llvm::Twine

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

Definition Twine.h:82

llvm::Value

LLVM Value Representation.

Definition Value.h:75

llvm::raw_ostream::flush

void flush()

Definition raw_ostream.h:199

llvm::raw_string_ostream

A raw_ostream that writes to an std::string.

Definition raw_ostream.h:662

llvm::remarks::YAMLParseError::ID

static char ID

Definition YAMLRemarkParser.h:31

llvm::remarks::YAMLParseError::YAMLParseError

YAMLParseError(StringRef Message, SourceMgr &SM, yaml::Stream &Stream, yaml::Node &Node)

Definition YAMLRemarkParser.cpp:37

llvm::yaml::BlockScalarNode

A block scalar node is an opaque datum that can be presented as a series of zero or more Unicode scal...

Definition YAMLParser.h:262

llvm::yaml::BlockScalarNode::getValue

StringRef getValue() const

Gets the value of this node as a StringRef.

Definition YAMLParser.h:275

llvm::yaml::Document

A YAML Stream is a sequence of Documents.

Definition YAMLParser.h:538

llvm::yaml::Document::getRoot

Node * getRoot()

Parse and return the root level node.

Definition YAMLParser.h:550

llvm::yaml::KeyValueNode

A key and value pair.

Definition YAMLParser.h:292

llvm::yaml::MappingNode

Represents a YAML map created from either a block map for a flow map.

Definition YAMLParser.h:421

llvm::yaml::Node

Abstract base class for all Nodes.

Definition YAMLParser.h:121

llvm::yaml::Stream

This class represents a YAML stream potentially containing multiple documents.

Definition YAMLParser.h:88

llvm::yaml::Stream::printError

LLVM_ABI void printError(Node *N, const Twine &Msg, SourceMgr::DiagKind Kind=SourceMgr::DK_Error)

Definition YAMLParser.cpp:1927

uint64_t

llvm::Loc

Definition DwarfDebug.h:129

llvm::remarks

Definition AsmPrinter.h:87

llvm::remarks::Magic

constexpr StringLiteral Magic("REMARKS")

llvm::remarks::Format

Format

The format used for serializing/deserializing remarks.

Definition RemarkFormat.h:26

llvm::remarks::Format::YAML

@ YAML

Definition RemarkFormat.h:26

llvm::remarks::CurrentRemarkVersion

constexpr uint64_t CurrentRemarkVersion

The current version of the remark entry.

Definition Remark.h:29

llvm::remarks::createYAMLParserFromMeta

Expected< std::unique_ptr< YAMLRemarkParser > > createYAMLParserFromMeta(StringRef Buf, std::optional< StringRef > ExternalFilePrependPath=std::nullopt)

Definition YAMLRemarkParser.cpp:98

llvm::remarks::Type

Type

The type of the remark.

Definition Remark.h:75

llvm::remarks::Type::AnalysisAliasing

@ AnalysisAliasing

Definition Remark.h:81

llvm::remarks::Type::AnalysisFPCommute

@ AnalysisFPCommute

Definition Remark.h:80

llvm::remarks::Type::Analysis

@ Analysis

Definition Remark.h:79

llvm::remarks::Type::Unknown

@ Unknown

Definition Remark.h:76

llvm::remarks::Type::Passed

@ Passed

Definition Remark.h:77

llvm::remarks::Type::Missed

@ Missed

Definition Remark.h:78

llvm::remarks::Type::Failure

@ Failure

Definition Remark.h:82

llvm::support::endian::read

value_type read(const void *memory, endianness endian)

Read a value of a particular endianness from memory.

Definition Endian.h:60

llvm::sys::path::append

LLVM_ABI void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")

Append to path.

Definition Path.cpp:456

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition AddressRanges.h:18

llvm::createFileError

Error createFileError(const Twine &F, Error E)

Concatenate a source file path and/or name with an Error.

Definition Error.h:1399

llvm::dyn_cast

decltype(auto) dyn_cast(const From &Val)

dyn_cast<X> - Return the argument parameter cast to the specified type.

Definition Casting.h:643

llvm::createStringError

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

Create formatted StringError object.

Definition Error.h:1305

llvm::Version

FunctionAddr VTableAddr uintptr_t uintptr_t Version

Definition InstrProf.h:302

llvm::Key

LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key

Definition PassManager.h:668

llvm::make_error

Error make_error(ArgTs &&... Args)

Make a Error instance representing failure using the given error info type.

Definition Error.h:340

llvm::remarks::Argument

A key-value pair with a debug location that is used to display the remarks at the right place in the ...

Definition Remark.h:47

llvm::remarks::Argument::Key

StringRef Key

Definition Remark.h:48

llvm::remarks::Argument::Val

StringRef Val

Definition Remark.h:50

llvm::remarks::Argument::Loc

std::optional< RemarkLocation > Loc

Definition Remark.h:52

llvm::remarks::RemarkLocation

The debug location used to track a remark back to the source file.

Definition Remark.h:32

llvm::remarks::RemarkParser::RemarkParser

RemarkParser(Format ParserFormat)

Definition RemarkParser.h:47

llvm::remarks::Remark

A remark type used for both emission and parsing.

Definition Remark.h:107

llvm::remarks::Remark::RemarkType

Type RemarkType

The type of the remark.

Definition Remark.h:109

llvm::remarks::Remark::PassName

StringRef PassName

Name of the pass that triggers the emission of this remark.

Definition Remark.h:112

llvm::remarks::Remark::Loc

std::optional< RemarkLocation > Loc

The location in the source file of the remark.

Definition Remark.h:123

llvm::remarks::Remark::Hotness

std::optional< uint64_t > Hotness

If profile information is available, this is the number of times the corresponding code was executed ...

Definition Remark.h:127

llvm::remarks::Remark::RemarkName

StringRef RemarkName

Textual identifier for the remark (single-word, camel-case).

Definition Remark.h:117

llvm::remarks::Remark::FunctionName

StringRef FunctionName

Mangled name of the function that triggers the emssion of this remark.

Definition Remark.h:120

llvm::remarks::Remark::Args

SmallVector< Argument, 5 > Args

Arguments collected via the streaming interface.

Definition Remark.h:130

llvm::remarks::YAMLRemarkParser::YAMLIt

yaml::document_iterator YAMLIt

Iterator in the YAML stream.

Definition YAMLRemarkParser.h:57

llvm::remarks::YAMLRemarkParser::error

Error error()

Create a YAMLParseError error from an existing error generated by the YAML parser.

Definition YAMLRemarkParser.cpp:155

llvm::remarks::YAMLRemarkParser::parseUnsigned

Expected< unsigned > parseUnsigned(yaml::KeyValueNode &Node)

Parse one value to an unsigned.

Definition YAMLRemarkParser.cpp:286

llvm::remarks::YAMLRemarkParser::Stream

yaml::Stream Stream

Stream for yaml parsing.

Definition YAMLRemarkParser.h:55

llvm::remarks::YAMLRemarkParser::YAMLRemarkParser

YAMLRemarkParser(StringRef Buf)

Definition YAMLRemarkParser.cpp:147

llvm::remarks::YAMLRemarkParser::parseDebugLoc

Expected< RemarkLocation > parseDebugLoc(yaml::KeyValueNode &Node)

Parse a debug location.

Definition YAMLRemarkParser.cpp:298

llvm::remarks::YAMLRemarkParser::parseStr

virtual Expected< StringRef > parseStr(yaml::KeyValueNode &Node)

Parse one value to a string.

Definition YAMLRemarkParser.cpp:267

llvm::remarks::YAMLRemarkParser::parseKey

Expected< StringRef > parseKey(yaml::KeyValueNode &Node)

Parse one key to a string.

Definition YAMLRemarkParser.cpp:260

llvm::remarks::YAMLRemarkParser::parseArg

Expected< Argument > parseArg(yaml::Node &Node)

Parse an argument.

Definition YAMLRemarkParser.cpp:340

llvm::remarks::YAMLRemarkParser::parseRemark

Expected< std::unique_ptr< Remark > > parseRemark(yaml::Document &Remark)

Parse a YAML remark to a remarks::Remark object.

Definition YAMLRemarkParser.cpp:164

llvm::remarks::YAMLRemarkParser::next

Expected< std::unique_ptr< Remark > > next() override

If no error occurs, this returns a valid Remark object.

Definition YAMLRemarkParser.cpp:395

llvm::remarks::YAMLRemarkParser::SM

SourceMgr SM

Source manager for better error messages.

Definition YAMLRemarkParser.h:53

llvm::remarks::YAMLRemarkParser::LastErrorMessage

std::string LastErrorMessage

Last error message that can come from the YAML parser diagnostics.

Definition YAMLRemarkParser.h:51

llvm::remarks::YAMLRemarkParser::parseType

Expected< Type > parseType(yaml::MappingNode &Node)

Parse the type of a remark to an enum type.

Definition YAMLRemarkParser.cpp:246