llvm/lib/Remarks/YAMLRemarkParser.cpp

   1 //===- YAMLRemarkParser.cpp -----------------------------------------------===//
   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 //
   9 // This file provides utility methods used by clients that want to use the
  10 // parser for remark diagnostics in LLVM.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "YAMLRemarkParser.h"
  15 #include "llvm/ADT/SmallString.h"
  16 #include "llvm/ADT/StringSwitch.h"
  17 #include "llvm/Support/Endian.h"
  18 #include "llvm/Support/Path.h"
  19 #include <optional>
  20
  21 using namespace llvm;
  22 using namespace llvm::remarks;
  23
  24 char YAMLParseError::ID = 0;
  25
  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 }
  36
  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 }
  53
  54 static SourceMgr setupSM(std::string &LastErrorMessage) {
  55   SourceMgr SM;
  56   SM.setDiagHandler(handleDiagnostic, &LastErrorMessage);
  57   return SM;
  58 }
  59
  60 // Parse the magic number. This function returns true if this represents remark
  61 // metadata, false otherwise.
  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 }
  71
  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, support::little, support::unaligned>(
  79           Buf.data());
  80   if (Version != remarks::CurrentRemarkVersion)
  81     return createStringError(std::errc::illegal_byte_sequence,
  82                              "Mismatching remark version. Got %" PRId64
  83                              ", expected %" PRId64 ".",
  84                              Version, remarks::CurrentRemarkVersion);
  85   Buf = Buf.drop_front(sizeof(uint64_t));
  86   return Version;
  87 }
  88
  89 static Expected<uint64_t> parseStrTabSize(StringRef &Buf) {
  90   if (Buf.size() < sizeof(uint64_t))
  91     return createStringError(std::errc::illegal_byte_sequence,
  92                              "Expecting string table size.");
  93   uint64_t StrTabSize =
  94       support::endian::read<uint64_t, support::little, support::unaligned>(
  95           Buf.data());
  96   Buf = Buf.drop_front(sizeof(uint64_t));
  97   return StrTabSize;
  98 }
  99
 100 static Expected<ParsedStringTable> parseStrTab(StringRef &Buf,
 101                                                uint64_t StrTabSize) {
 102   if (Buf.size() < StrTabSize)
 103     return createStringError(std::errc::illegal_byte_sequence,
 104                              "Expecting string table.");
 105
 106   // Attach the string table to the parser.
 107   ParsedStringTable Result(StringRef(Buf.data(), StrTabSize));
 108   Buf = Buf.drop_front(StrTabSize);
 109   return Expected<ParsedStringTable>(std::move(Result));
 110 }
 111
 112 Expected<std::unique_ptr<YAMLRemarkParser>> remarks::createYAMLParserFromMeta(
 113     StringRef Buf, std::optional<ParsedStringTable> StrTab,
 114     std::optional<StringRef> ExternalFilePrependPath) {
 115   // We now have a magic number. The metadata has to be correct.
 116   Expected<bool> isMeta = parseMagic(Buf);
 117   if (!isMeta)
 118     return isMeta.takeError();
 119   // If it's not recognized as metadata, roll back.
 120   std::unique_ptr<MemoryBuffer> SeparateBuf;
 121   if (*isMeta) {
 122     Expected<uint64_t> Version = parseVersion(Buf);
 123     if (!Version)
 124       return Version.takeError();
 125
 126     Expected<uint64_t> StrTabSize = parseStrTabSize(Buf);
 127     if (!StrTabSize)
 128       return StrTabSize.takeError();
 129
 130     // If the size of string table is not 0, try to build one.
 131     if (*StrTabSize != 0) {
 132       if (StrTab)
 133         return createStringError(std::errc::illegal_byte_sequence,
 134                                  "String table already provided.");
 135       Expected<ParsedStringTable> MaybeStrTab = parseStrTab(Buf, *StrTabSize);
 136       if (!MaybeStrTab)
 137         return MaybeStrTab.takeError();
 138       StrTab = std::move(*MaybeStrTab);
 139     }
 140     // If it starts with "---", there is no external file.
 141     if (!Buf.startswith("---")) {
 142       // At this point, we expect Buf to contain the external file path.
 143       StringRef ExternalFilePath = Buf;
 144       SmallString<80> FullPath;
 145       if (ExternalFilePrependPath)
 146         FullPath = *ExternalFilePrependPath;
 147       sys::path::append(FullPath, ExternalFilePath);
 148
 149       // Try to open the file and start parsing from there.
 150       ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
 151           MemoryBuffer::getFile(FullPath);
 152       if (std::error_code EC = BufferOrErr.getError())
 153         return createFileError(FullPath, EC);
 154
 155       // Keep the buffer alive.
 156       SeparateBuf = std::move(*BufferOrErr);
 157       Buf = SeparateBuf->getBuffer();
 158     }
 159   }
 160
 161   std::unique_ptr<YAMLRemarkParser> Result =
 162       StrTab
 163           ? std::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(*StrTab))
 164           : std::make_unique<YAMLRemarkParser>(Buf);
 165   if (SeparateBuf)
 166     Result->SeparateBuf = std::move(SeparateBuf);
 167   return std::move(Result);
 168 }
 169
 170 YAMLRemarkParser::YAMLRemarkParser(StringRef Buf)
 171     : YAMLRemarkParser(Buf, std::nullopt) {}
 172
 173 YAMLRemarkParser::YAMLRemarkParser(StringRef Buf,
 174                                    std::optional<ParsedStringTable> StrTab)
 175     : RemarkParser{Format::YAML}, StrTab(std::move(StrTab)),
 176       SM(setupSM(LastErrorMessage)), Stream(Buf, SM), YAMLIt(Stream.begin()) {}
 177
 178 Error YAMLRemarkParser::error(StringRef Message, yaml::Node &Node) {
 179   return make_error<YAMLParseError>(Message, SM, Stream, Node);
 180 }
 181
 182 Error YAMLRemarkParser::error() {
 183   if (LastErrorMessage.empty())
 184     return Error::success();
 185   Error E = make_error<YAMLParseError>(LastErrorMessage);
 186   LastErrorMessage.clear();
 187   return E;
 188 }
 189
 190 Expected<std::unique_ptr<Remark>>
 191 YAMLRemarkParser::parseRemark(yaml::Document &RemarkEntry) {
 192   if (Error E = error())
 193     return std::move(E);
 194
 195   yaml::Node *YAMLRoot = RemarkEntry.getRoot();
 196   if (!YAMLRoot) {
 197     return createStringError(std::make_error_code(std::errc::invalid_argument),
 198                              "not a valid YAML file.");
 199   }
 200
 201   auto *Root = dyn_cast<yaml::MappingNode>(YAMLRoot);
 202   if (!Root)
 203     return error("document root is not of mapping type.", *YAMLRoot);
 204
 205   std::unique_ptr<Remark> Result = std::make_unique<Remark>();
 206   Remark &TheRemark = *Result;
 207
 208   // First, the type. It needs special handling since is not part of the
 209   // key-value stream.
 210   Expected<Type> T = parseType(*Root);
 211   if (!T)
 212     return T.takeError();
 213   else
 214     TheRemark.RemarkType = *T;
 215
 216   // Then, parse the fields, one by one.
 217   for (yaml::KeyValueNode &RemarkField : *Root) {
 218     Expected<StringRef> MaybeKey = parseKey(RemarkField);
 219     if (!MaybeKey)
 220       return MaybeKey.takeError();
 221     StringRef KeyName = *MaybeKey;
 222
 223     if (KeyName == "Pass") {
 224       if (Expected<StringRef> MaybeStr = parseStr(RemarkField))
 225         TheRemark.PassName = *MaybeStr;
 226       else
 227         return MaybeStr.takeError();
 228     } else if (KeyName == "Name") {
 229       if (Expected<StringRef> MaybeStr = parseStr(RemarkField))
 230         TheRemark.RemarkName = *MaybeStr;
 231       else
 232         return MaybeStr.takeError();
 233     } else if (KeyName == "Function") {
 234       if (Expected<StringRef> MaybeStr = parseStr(RemarkField))
 235         TheRemark.FunctionName = *MaybeStr;
 236       else
 237         return MaybeStr.takeError();
 238     } else if (KeyName == "Hotness") {
 239       if (Expected<unsigned> MaybeU = parseUnsigned(RemarkField))
 240         TheRemark.Hotness = *MaybeU;
 241       else
 242         return MaybeU.takeError();
 243     } else if (KeyName == "DebugLoc") {
 244       if (Expected<RemarkLocation> MaybeLoc = parseDebugLoc(RemarkField))
 245         TheRemark.Loc = *MaybeLoc;
 246       else
 247         return MaybeLoc.takeError();
 248     } else if (KeyName == "Args") {
 249       auto *Args = dyn_cast<yaml::SequenceNode>(RemarkField.getValue());
 250       if (!Args)
 251         return error("wrong value type for key.", RemarkField);
 252
 253       for (yaml::Node &Arg : *Args) {
 254         if (Expected<Argument> MaybeArg = parseArg(Arg))
 255           TheRemark.Args.push_back(*MaybeArg);
 256         else
 257           return MaybeArg.takeError();
 258       }
 259     } else {
 260       return error("unknown key.", RemarkField);
 261     }
 262   }
 263
 264   // Check if any of the mandatory fields are missing.
 265   if (TheRemark.RemarkType == Type::Unknown || TheRemark.PassName.empty() ||
 266       TheRemark.RemarkName.empty() || TheRemark.FunctionName.empty())
 267     return error("Type, Pass, Name or Function missing.",
 268                  *RemarkEntry.getRoot());
 269
 270   return std::move(Result);
 271 }
 272
 273 Expected<Type> YAMLRemarkParser::parseType(yaml::MappingNode &Node) {
 274   auto Type = StringSwitch<remarks::Type>(Node.getRawTag())
 275                   .Case("!Passed", remarks::Type::Passed)
 276                   .Case("!Missed", remarks::Type::Missed)
 277                   .Case("!Analysis", remarks::Type::Analysis)
 278                   .Case("!AnalysisFPCommute", remarks::Type::AnalysisFPCommute)
 279                   .Case("!AnalysisAliasing", remarks::Type::AnalysisAliasing)
 280                   .Case("!Failure", remarks::Type::Failure)
 281                   .Default(remarks::Type::Unknown);
 282   if (Type == remarks::Type::Unknown)
 283     return error("expected a remark tag.", Node);
 284   return Type;
 285 }
 286
 287 Expected<StringRef> YAMLRemarkParser::parseKey(yaml::KeyValueNode &Node) {
 288   if (auto *Key = dyn_cast<yaml::ScalarNode>(Node.getKey()))
 289     return Key->getRawValue();
 290
 291   return error("key is not a string.", Node);
 292 }
 293
 294 Expected<StringRef> YAMLRemarkParser::parseStr(yaml::KeyValueNode &Node) {
 295   auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
 296   yaml::BlockScalarNode *ValueBlock;
 297   StringRef Result;
 298   if (!Value) {
 299     // Try to parse the value as a block node.
 300     ValueBlock = dyn_cast<yaml::BlockScalarNode>(Node.getValue());
 301     if (!ValueBlock)
 302       return error("expected a value of scalar type.", Node);
 303     Result = ValueBlock->getValue();
 304   } else
 305     Result = Value->getRawValue();
 306
 307   if (Result.front() == '\'')
 308     Result = Result.drop_front();
 309
 310   if (Result.back() == '\'')
 311     Result = Result.drop_back();
 312
 313   return Result;
 314 }
 315
 316 Expected<unsigned> YAMLRemarkParser::parseUnsigned(yaml::KeyValueNode &Node) {
 317   SmallVector<char, 4> Tmp;
 318   auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
 319   if (!Value)
 320     return error("expected a value of scalar type.", Node);
 321   unsigned UnsignedValue = 0;
 322   if (Value->getValue(Tmp).getAsInteger(10, UnsignedValue))
 323     return error("expected a value of integer type.", *Value);
 324   return UnsignedValue;
 325 }
 326
 327 Expected<RemarkLocation>
 328 YAMLRemarkParser::parseDebugLoc(yaml::KeyValueNode &Node) {
 329   auto *DebugLoc = dyn_cast<yaml::MappingNode>(Node.getValue());
 330   if (!DebugLoc)
 331     return error("expected a value of mapping type.", Node);
 332
 333   std::optional<StringRef> File;
 334   std::optional<unsigned> Line;
 335   std::optional<unsigned> Column;
 336
 337   for (yaml::KeyValueNode &DLNode : *DebugLoc) {
 338     Expected<StringRef> MaybeKey = parseKey(DLNode);
 339     if (!MaybeKey)
 340       return MaybeKey.takeError();
 341     StringRef KeyName = *MaybeKey;
 342
 343     if (KeyName == "File") {
 344       if (Expected<StringRef> MaybeStr = parseStr(DLNode))
 345         File = *MaybeStr;
 346       else
 347         return MaybeStr.takeError();
 348     } else if (KeyName == "Column") {
 349       if (Expected<unsigned> MaybeU = parseUnsigned(DLNode))
 350         Column = *MaybeU;
 351       else
 352         return MaybeU.takeError();
 353     } else if (KeyName == "Line") {
 354       if (Expected<unsigned> MaybeU = parseUnsigned(DLNode))
 355         Line = *MaybeU;
 356       else
 357         return MaybeU.takeError();
 358     } else {
 359       return error("unknown entry in DebugLoc map.", DLNode);
 360     }
 361   }
 362
 363   // If any of the debug loc fields is missing, return an error.
 364   if (!File || !Line || !Column)
 365     return error("DebugLoc node incomplete.", Node);
 366
 367   return RemarkLocation{*File, *Line, *Column};
 368 }
 369
 370 Expected<Argument> YAMLRemarkParser::parseArg(yaml::Node &Node) {
 371   auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);
 372   if (!ArgMap)
 373     return error("expected a value of mapping type.", Node);
 374
 375   std::optional<StringRef> KeyStr;
 376   std::optional<StringRef> ValueStr;
 377   std::optional<RemarkLocation> Loc;
 378
 379   for (yaml::KeyValueNode &ArgEntry : *ArgMap) {
 380     Expected<StringRef> MaybeKey = parseKey(ArgEntry);
 381     if (!MaybeKey)
 382       return MaybeKey.takeError();
 383     StringRef KeyName = *MaybeKey;
 384
 385     // Try to parse debug locs.
 386     if (KeyName == "DebugLoc") {
 387       // Can't have multiple DebugLoc entries per argument.
 388       if (Loc)
 389         return error("only one DebugLoc entry is allowed per argument.",
 390                      ArgEntry);
 391
 392       if (Expected<RemarkLocation> MaybeLoc = parseDebugLoc(ArgEntry)) {
 393         Loc = *MaybeLoc;
 394         continue;
 395       } else
 396         return MaybeLoc.takeError();
 397     }
 398
 399     // If we already have a string, error out.
 400     if (ValueStr)
 401       return error("only one string entry is allowed per argument.", ArgEntry);
 402
 403     // Try to parse the value.
 404     if (Expected<StringRef> MaybeStr = parseStr(ArgEntry))
 405       ValueStr = *MaybeStr;
 406     else
 407       return MaybeStr.takeError();
 408
 409     // Keep the key from the string.
 410     KeyStr = KeyName;
 411   }
 412
 413   if (!KeyStr)
 414     return error("argument key is missing.", *ArgMap);
 415   if (!ValueStr)
 416     return error("argument value is missing.", *ArgMap);
 417
 418   return Argument{*KeyStr, *ValueStr, Loc};
 419 }
 420
 421 Expected<std::unique_ptr<Remark>> YAMLRemarkParser::next() {
 422   if (YAMLIt == Stream.end())
 423     return make_error<EndOfFileError>();
 424
 425   Expected<std::unique_ptr<Remark>> MaybeResult = parseRemark(*YAMLIt);
 426   if (!MaybeResult) {
 427     // Avoid garbage input, set the iterator to the end.
 428     YAMLIt = Stream.end();
 429     return MaybeResult.takeError();
 430   }
 431
 432   ++YAMLIt;
 433
 434   return std::move(*MaybeResult);
 435 }
 436
 437 Expected<StringRef> YAMLStrTabRemarkParser::parseStr(yaml::KeyValueNode &Node) {
 438   auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
 439   yaml::BlockScalarNode *ValueBlock;
 440   StringRef Result;
 441   if (!Value) {
 442     // Try to parse the value as a block node.
 443     ValueBlock = dyn_cast<yaml::BlockScalarNode>(Node.getValue());
 444     if (!ValueBlock)
 445       return error("expected a value of scalar type.", Node);
 446     Result = ValueBlock->getValue();
 447   } else
 448     Result = Value->getRawValue();
 449   // If we have a string table, parse it as an unsigned.
 450   unsigned StrID = 0;
 451   if (Expected<unsigned> MaybeStrID = parseUnsigned(Node))
 452     StrID = *MaybeStrID;
 453   else
 454     return MaybeStrID.takeError();
 455
 456   if (Expected<StringRef> Str = (*StrTab)[StrID])
 457     Result = *Str;
 458   else
 459     return Str.takeError();
 460
 461   if (Result.front() == '\'')
 462     Result = Result.drop_front();
 463
 464   if (Result.back() == '\'')
 465     Result = Result.drop_back();
 466
 467   return Result;
 468 }