454 lines
15 KiB
C++
454 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/Support/Endian.h"
|
||
|
|
#include "llvm/Support/Path.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::CurrentRemarkVersion)
|
||
|
|
return createStringError(std::errc::illegal_byte_sequence,
|
||
|
|
"Mismatching remark version. Got %" PRId64
|
||
|
|
", expected %" PRId64 ".",
|
||
|
|
Version, remarks::CurrentRemarkVersion);
|
||
|
|
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 Expected<ParsedStringTable>(std::move(Result));
|
||
|
|
}
|
||
|
|
|
||
|
|
Expected<std::unique_ptr<YAMLRemarkParser>>
|
||
|
|
remarks::createYAMLParserFromMeta(StringRef Buf,
|
||
|
|
Optional<ParsedStringTable> StrTab,
|
||
|
|
Optional<StringRef> ExternalFilePrependPath) {
|
||
|
|
// 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.
|
||
|
|
StringRef ExternalFilePath = Buf;
|
||
|
|
SmallString<80> FullPath;
|
||
|
|
if (ExternalFilePrependPath)
|
||
|
|
FullPath = *ExternalFilePrependPath;
|
||
|
|
sys::path::append(FullPath, ExternalFilePath);
|
||
|
|
|
||
|
|
// Try to open the file and start parsing from there.
|
||
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
|
||
|
|
MemoryBuffer::getFile(FullPath);
|
||
|
|
if (std::error_code EC = BufferOrErr.getError())
|
||
|
|
return createFileError(FullPath, EC);
|
||
|
|
|
||
|
|
// Keep the buffer alive.
|
||
|
|
SeparateBuf = std::move(*BufferOrErr);
|
||
|
|
Buf = SeparateBuf->getBuffer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::unique_ptr<YAMLRemarkParser> Result =
|
||
|
|
StrTab
|
||
|
|
? std::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(*StrTab))
|
||
|
|
: std::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 = std::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;
|
||
|
|
}
|