mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-18 18:42:46 +02:00
b07bf19865
This adds support to the yaml remark parser to be able to parse remarks directly from the metadata. This supports parsing separate metadata and following the external file with the associated metadata, and also a standalone file containing metadata + remarks all together. llvm-svn: 367148
447 lines
15 KiB
C++
447 lines
15 KiB
C++
//===- YAMLRemarkParser.cpp -----------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file provides utility methods used by clients that want to use the
|
|
// parser for remark diagnostics in LLVM.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "YAMLRemarkParser.h"
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
#include "llvm/Remarks/RemarkParser.h"
|
|
#include "llvm/Support/Endian.h"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::remarks;
|
|
|
|
char YAMLParseError::ID = 0;
|
|
|
|
static void handleDiagnostic(const SMDiagnostic &Diag, void *Ctx) {
|
|
assert(Ctx && "Expected non-null Ctx in diagnostic handler.");
|
|
std::string &Message = *static_cast<std::string *>(Ctx);
|
|
assert(Message.empty() && "Expected an empty string.");
|
|
raw_string_ostream OS(Message);
|
|
Diag.print(/*ProgName=*/nullptr, OS, /*ShowColors*/ false,
|
|
/*ShowKindLabels*/ true);
|
|
OS << '\n';
|
|
OS.flush();
|
|
}
|
|
|
|
YAMLParseError::YAMLParseError(StringRef Msg, SourceMgr &SM,
|
|
yaml::Stream &Stream, yaml::Node &Node) {
|
|
// 1) Set up a diagnostic handler to avoid errors being printed out to
|
|
// stderr.
|
|
// 2) Use the stream to print the error with the associated node.
|
|
// 3) The stream will use the source manager to print the error, which will
|
|
// call the diagnostic handler.
|
|
// 4) The diagnostic handler will stream the error directly into this object's
|
|
// Message member, which is used when logging is asked for.
|
|
auto OldDiagHandler = SM.getDiagHandler();
|
|
auto OldDiagCtx = SM.getDiagContext();
|
|
SM.setDiagHandler(handleDiagnostic, &Message);
|
|
Stream.printError(&Node, Twine(Msg) + Twine('\n'));
|
|
// Restore the old handlers.
|
|
SM.setDiagHandler(OldDiagHandler, OldDiagCtx);
|
|
}
|
|
|
|
static SourceMgr setupSM(std::string &LastErrorMessage) {
|
|
SourceMgr SM;
|
|
SM.setDiagHandler(handleDiagnostic, &LastErrorMessage);
|
|
return SM;
|
|
}
|
|
|
|
// Parse the magic number. This function returns true if this represents remark
|
|
// metadata, false otherwise.
|
|
static Expected<bool> parseMagic(StringRef &Buf) {
|
|
if (!Buf.consume_front(remarks::Magic))
|
|
return false;
|
|
|
|
if (Buf.size() < 1 || !Buf.consume_front(StringRef("\0", 1)))
|
|
return createStringError(std::errc::illegal_byte_sequence,
|
|
"Expecting \\0 after magic number.");
|
|
return true;
|
|
}
|
|
|
|
static Expected<uint64_t> parseVersion(StringRef &Buf) {
|
|
if (Buf.size() < sizeof(uint64_t))
|
|
return createStringError(std::errc::illegal_byte_sequence,
|
|
"Expecting version number.");
|
|
|
|
uint64_t Version =
|
|
support::endian::read<uint64_t, support::little, support::unaligned>(
|
|
Buf.data());
|
|
if (Version != remarks::Version)
|
|
return createStringError(
|
|
std::errc::illegal_byte_sequence,
|
|
"Mismatching remark version. Got %u, expected %u.", Version,
|
|
remarks::Version);
|
|
Buf = Buf.drop_front(sizeof(uint64_t));
|
|
return Version;
|
|
}
|
|
|
|
static Expected<uint64_t> parseStrTabSize(StringRef &Buf) {
|
|
if (Buf.size() < sizeof(uint64_t))
|
|
return createStringError(std::errc::illegal_byte_sequence,
|
|
"Expecting string table size.");
|
|
uint64_t StrTabSize =
|
|
support::endian::read<uint64_t, support::little, support::unaligned>(
|
|
Buf.data());
|
|
Buf = Buf.drop_front(sizeof(uint64_t));
|
|
return StrTabSize;
|
|
}
|
|
|
|
static Expected<ParsedStringTable> parseStrTab(StringRef &Buf,
|
|
uint64_t StrTabSize) {
|
|
if (Buf.size() < StrTabSize)
|
|
return createStringError(std::errc::illegal_byte_sequence,
|
|
"Expecting string table.");
|
|
|
|
// Attach the string table to the parser.
|
|
ParsedStringTable Result(StringRef(Buf.data(), StrTabSize));
|
|
Buf = Buf.drop_front(StrTabSize);
|
|
return Result;
|
|
}
|
|
|
|
Expected<std::unique_ptr<YAMLRemarkParser>>
|
|
remarks::createYAMLParserFromMeta(StringRef Buf,
|
|
Optional<ParsedStringTable> StrTab) {
|
|
// We now have a magic number. The metadata has to be correct.
|
|
Expected<bool> isMeta = parseMagic(Buf);
|
|
if (!isMeta)
|
|
return isMeta.takeError();
|
|
// If it's not recognized as metadata, roll back.
|
|
std::unique_ptr<MemoryBuffer> SeparateBuf;
|
|
if (*isMeta) {
|
|
Expected<uint64_t> Version = parseVersion(Buf);
|
|
if (!Version)
|
|
return Version.takeError();
|
|
|
|
Expected<uint64_t> StrTabSize = parseStrTabSize(Buf);
|
|
if (!StrTabSize)
|
|
return StrTabSize.takeError();
|
|
|
|
// If the size of string table is not 0, try to build one.
|
|
if (*StrTabSize != 0) {
|
|
if (StrTab)
|
|
return createStringError(std::errc::illegal_byte_sequence,
|
|
"String table already provided.");
|
|
Expected<ParsedStringTable> MaybeStrTab = parseStrTab(Buf, *StrTabSize);
|
|
if (!MaybeStrTab)
|
|
return MaybeStrTab.takeError();
|
|
StrTab = std::move(*MaybeStrTab);
|
|
}
|
|
// If it starts with "---", there is no external file.
|
|
if (!Buf.startswith("---")) {
|
|
// At this point, we expect Buf to contain the external file path.
|
|
// Try to open the file and start parsing from there.
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
|
|
MemoryBuffer::getFile(Buf);
|
|
if (std::error_code EC = BufferOrErr.getError())
|
|
return errorCodeToError(EC);
|
|
|
|
// Keep the buffer alive.
|
|
SeparateBuf = std::move(*BufferOrErr);
|
|
Buf = SeparateBuf->getBuffer();
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<YAMLRemarkParser> Result =
|
|
StrTab
|
|
? llvm::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(*StrTab))
|
|
: llvm::make_unique<YAMLRemarkParser>(Buf);
|
|
if (SeparateBuf)
|
|
Result->SeparateBuf = std::move(SeparateBuf);
|
|
return std::move(Result);
|
|
}
|
|
|
|
YAMLRemarkParser::YAMLRemarkParser(StringRef Buf)
|
|
: YAMLRemarkParser(Buf, None) {}
|
|
|
|
YAMLRemarkParser::YAMLRemarkParser(StringRef Buf,
|
|
Optional<ParsedStringTable> StrTab)
|
|
: RemarkParser{Format::YAML}, StrTab(std::move(StrTab)), LastErrorMessage(),
|
|
SM(setupSM(LastErrorMessage)), Stream(Buf, SM), YAMLIt(Stream.begin()) {}
|
|
|
|
Error YAMLRemarkParser::error(StringRef Message, yaml::Node &Node) {
|
|
return make_error<YAMLParseError>(Message, SM, Stream, Node);
|
|
}
|
|
|
|
Error YAMLRemarkParser::error() {
|
|
if (LastErrorMessage.empty())
|
|
return Error::success();
|
|
Error E = make_error<YAMLParseError>(LastErrorMessage);
|
|
LastErrorMessage.clear();
|
|
return E;
|
|
}
|
|
|
|
Expected<std::unique_ptr<Remark>>
|
|
YAMLRemarkParser::parseRemark(yaml::Document &RemarkEntry) {
|
|
if (Error E = error())
|
|
return std::move(E);
|
|
|
|
yaml::Node *YAMLRoot = RemarkEntry.getRoot();
|
|
if (!YAMLRoot) {
|
|
return createStringError(std::make_error_code(std::errc::invalid_argument),
|
|
"not a valid YAML file.");
|
|
}
|
|
|
|
auto *Root = dyn_cast<yaml::MappingNode>(YAMLRoot);
|
|
if (!Root)
|
|
return error("document root is not of mapping type.", *YAMLRoot);
|
|
|
|
std::unique_ptr<Remark> Result = llvm::make_unique<Remark>();
|
|
Remark &TheRemark = *Result;
|
|
|
|
// First, the type. It needs special handling since is not part of the
|
|
// key-value stream.
|
|
Expected<Type> T = parseType(*Root);
|
|
if (!T)
|
|
return T.takeError();
|
|
else
|
|
TheRemark.RemarkType = *T;
|
|
|
|
// Then, parse the fields, one by one.
|
|
for (yaml::KeyValueNode &RemarkField : *Root) {
|
|
Expected<StringRef> MaybeKey = parseKey(RemarkField);
|
|
if (!MaybeKey)
|
|
return MaybeKey.takeError();
|
|
StringRef KeyName = *MaybeKey;
|
|
|
|
if (KeyName == "Pass") {
|
|
if (Expected<StringRef> MaybeStr = parseStr(RemarkField))
|
|
TheRemark.PassName = *MaybeStr;
|
|
else
|
|
return MaybeStr.takeError();
|
|
} else if (KeyName == "Name") {
|
|
if (Expected<StringRef> MaybeStr = parseStr(RemarkField))
|
|
TheRemark.RemarkName = *MaybeStr;
|
|
else
|
|
return MaybeStr.takeError();
|
|
} else if (KeyName == "Function") {
|
|
if (Expected<StringRef> MaybeStr = parseStr(RemarkField))
|
|
TheRemark.FunctionName = *MaybeStr;
|
|
else
|
|
return MaybeStr.takeError();
|
|
} else if (KeyName == "Hotness") {
|
|
if (Expected<unsigned> MaybeU = parseUnsigned(RemarkField))
|
|
TheRemark.Hotness = *MaybeU;
|
|
else
|
|
return MaybeU.takeError();
|
|
} else if (KeyName == "DebugLoc") {
|
|
if (Expected<RemarkLocation> MaybeLoc = parseDebugLoc(RemarkField))
|
|
TheRemark.Loc = *MaybeLoc;
|
|
else
|
|
return MaybeLoc.takeError();
|
|
} else if (KeyName == "Args") {
|
|
auto *Args = dyn_cast<yaml::SequenceNode>(RemarkField.getValue());
|
|
if (!Args)
|
|
return error("wrong value type for key.", RemarkField);
|
|
|
|
for (yaml::Node &Arg : *Args) {
|
|
if (Expected<Argument> MaybeArg = parseArg(Arg))
|
|
TheRemark.Args.push_back(*MaybeArg);
|
|
else
|
|
return MaybeArg.takeError();
|
|
}
|
|
} else {
|
|
return error("unknown key.", RemarkField);
|
|
}
|
|
}
|
|
|
|
// Check if any of the mandatory fields are missing.
|
|
if (TheRemark.RemarkType == Type::Unknown || TheRemark.PassName.empty() ||
|
|
TheRemark.RemarkName.empty() || TheRemark.FunctionName.empty())
|
|
return error("Type, Pass, Name or Function missing.",
|
|
*RemarkEntry.getRoot());
|
|
|
|
return std::move(Result);
|
|
}
|
|
|
|
Expected<Type> YAMLRemarkParser::parseType(yaml::MappingNode &Node) {
|
|
auto Type = StringSwitch<remarks::Type>(Node.getRawTag())
|
|
.Case("!Passed", remarks::Type::Passed)
|
|
.Case("!Missed", remarks::Type::Missed)
|
|
.Case("!Analysis", remarks::Type::Analysis)
|
|
.Case("!AnalysisFPCommute", remarks::Type::AnalysisFPCommute)
|
|
.Case("!AnalysisAliasing", remarks::Type::AnalysisAliasing)
|
|
.Case("!Failure", remarks::Type::Failure)
|
|
.Default(remarks::Type::Unknown);
|
|
if (Type == remarks::Type::Unknown)
|
|
return error("expected a remark tag.", Node);
|
|
return Type;
|
|
}
|
|
|
|
Expected<StringRef> YAMLRemarkParser::parseKey(yaml::KeyValueNode &Node) {
|
|
if (auto *Key = dyn_cast<yaml::ScalarNode>(Node.getKey()))
|
|
return Key->getRawValue();
|
|
|
|
return error("key is not a string.", Node);
|
|
}
|
|
|
|
Expected<StringRef> YAMLRemarkParser::parseStr(yaml::KeyValueNode &Node) {
|
|
auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
|
|
if (!Value)
|
|
return error("expected a value of scalar type.", Node);
|
|
StringRef Result = Value->getRawValue();
|
|
|
|
if (Result.front() == '\'')
|
|
Result = Result.drop_front();
|
|
|
|
if (Result.back() == '\'')
|
|
Result = Result.drop_back();
|
|
|
|
return Result;
|
|
}
|
|
|
|
Expected<unsigned> YAMLRemarkParser::parseUnsigned(yaml::KeyValueNode &Node) {
|
|
SmallVector<char, 4> Tmp;
|
|
auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
|
|
if (!Value)
|
|
return error("expected a value of scalar type.", Node);
|
|
unsigned UnsignedValue = 0;
|
|
if (Value->getValue(Tmp).getAsInteger(10, UnsignedValue))
|
|
return error("expected a value of integer type.", *Value);
|
|
return UnsignedValue;
|
|
}
|
|
|
|
Expected<RemarkLocation>
|
|
YAMLRemarkParser::parseDebugLoc(yaml::KeyValueNode &Node) {
|
|
auto *DebugLoc = dyn_cast<yaml::MappingNode>(Node.getValue());
|
|
if (!DebugLoc)
|
|
return error("expected a value of mapping type.", Node);
|
|
|
|
Optional<StringRef> File;
|
|
Optional<unsigned> Line;
|
|
Optional<unsigned> Column;
|
|
|
|
for (yaml::KeyValueNode &DLNode : *DebugLoc) {
|
|
Expected<StringRef> MaybeKey = parseKey(DLNode);
|
|
if (!MaybeKey)
|
|
return MaybeKey.takeError();
|
|
StringRef KeyName = *MaybeKey;
|
|
|
|
if (KeyName == "File") {
|
|
if (Expected<StringRef> MaybeStr = parseStr(DLNode))
|
|
File = *MaybeStr;
|
|
else
|
|
return MaybeStr.takeError();
|
|
} else if (KeyName == "Column") {
|
|
if (Expected<unsigned> MaybeU = parseUnsigned(DLNode))
|
|
Column = *MaybeU;
|
|
else
|
|
return MaybeU.takeError();
|
|
} else if (KeyName == "Line") {
|
|
if (Expected<unsigned> MaybeU = parseUnsigned(DLNode))
|
|
Line = *MaybeU;
|
|
else
|
|
return MaybeU.takeError();
|
|
} else {
|
|
return error("unknown entry in DebugLoc map.", DLNode);
|
|
}
|
|
}
|
|
|
|
// If any of the debug loc fields is missing, return an error.
|
|
if (!File || !Line || !Column)
|
|
return error("DebugLoc node incomplete.", Node);
|
|
|
|
return RemarkLocation{*File, *Line, *Column};
|
|
}
|
|
|
|
Expected<Argument> YAMLRemarkParser::parseArg(yaml::Node &Node) {
|
|
auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);
|
|
if (!ArgMap)
|
|
return error("expected a value of mapping type.", Node);
|
|
|
|
Optional<StringRef> KeyStr;
|
|
Optional<StringRef> ValueStr;
|
|
Optional<RemarkLocation> Loc;
|
|
|
|
for (yaml::KeyValueNode &ArgEntry : *ArgMap) {
|
|
Expected<StringRef> MaybeKey = parseKey(ArgEntry);
|
|
if (!MaybeKey)
|
|
return MaybeKey.takeError();
|
|
StringRef KeyName = *MaybeKey;
|
|
|
|
// Try to parse debug locs.
|
|
if (KeyName == "DebugLoc") {
|
|
// Can't have multiple DebugLoc entries per argument.
|
|
if (Loc)
|
|
return error("only one DebugLoc entry is allowed per argument.",
|
|
ArgEntry);
|
|
|
|
if (Expected<RemarkLocation> MaybeLoc = parseDebugLoc(ArgEntry)) {
|
|
Loc = *MaybeLoc;
|
|
continue;
|
|
} else
|
|
return MaybeLoc.takeError();
|
|
}
|
|
|
|
// If we already have a string, error out.
|
|
if (ValueStr)
|
|
return error("only one string entry is allowed per argument.", ArgEntry);
|
|
|
|
// Try to parse the value.
|
|
if (Expected<StringRef> MaybeStr = parseStr(ArgEntry))
|
|
ValueStr = *MaybeStr;
|
|
else
|
|
return MaybeStr.takeError();
|
|
|
|
// Keep the key from the string.
|
|
KeyStr = KeyName;
|
|
}
|
|
|
|
if (!KeyStr)
|
|
return error("argument key is missing.", *ArgMap);
|
|
if (!ValueStr)
|
|
return error("argument value is missing.", *ArgMap);
|
|
|
|
return Argument{*KeyStr, *ValueStr, Loc};
|
|
}
|
|
|
|
Expected<std::unique_ptr<Remark>> YAMLRemarkParser::next() {
|
|
if (YAMLIt == Stream.end())
|
|
return make_error<EndOfFileError>();
|
|
|
|
Expected<std::unique_ptr<Remark>> MaybeResult = parseRemark(*YAMLIt);
|
|
if (!MaybeResult) {
|
|
// Avoid garbage input, set the iterator to the end.
|
|
YAMLIt = Stream.end();
|
|
return MaybeResult.takeError();
|
|
}
|
|
|
|
++YAMLIt;
|
|
|
|
return std::move(*MaybeResult);
|
|
}
|
|
|
|
Expected<StringRef> YAMLStrTabRemarkParser::parseStr(yaml::KeyValueNode &Node) {
|
|
auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
|
|
if (!Value)
|
|
return error("expected a value of scalar type.", Node);
|
|
StringRef Result;
|
|
// If we have a string table, parse it as an unsigned.
|
|
unsigned StrID = 0;
|
|
if (Expected<unsigned> MaybeStrID = parseUnsigned(Node))
|
|
StrID = *MaybeStrID;
|
|
else
|
|
return MaybeStrID.takeError();
|
|
|
|
if (Expected<StringRef> Str = (*StrTab)[StrID])
|
|
Result = *Str;
|
|
else
|
|
return Str.takeError();
|
|
|
|
if (Result.front() == '\'')
|
|
Result = Result.drop_front();
|
|
|
|
if (Result.back() == '\'')
|
|
Result = Result.drop_back();
|
|
|
|
return Result;
|
|
}
|