maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/lib/Remarks/YAMLRemarkParser.cpp

455 lines
15 KiB
C++
Raw Blame History

//===- 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"
#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;
}
Reference in New Issue View Git Blame Copy Permalink