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/StringSwitch.h"
  16 #include "llvm/Remarks/RemarkParser.h"
  17 #include "llvm/Support/Endian.h"
  18 #include "llvm/Support/Path.h"
  19
  20 using namespace llvm;
  21 using namespace llvm::remarks;
  22
  23 char YAMLParseError::ID = 0;
  24
  25 static void handleDiagnostic(const SMDiagnostic &Diag, void *Ctx) {
  26   assert(Ctx && "Expected non-null Ctx in diagnostic handler.");
  27   std::string &Message = *static_cast<std::string *>(Ctx);
  28   assert(Message.empty() && "Expected an empty string.");
  29   raw_string_ostream OS(Message);
  30   Diag.print(/*ProgName=*/nullptr, OS, /*ShowColors*/ false,
  31              /*ShowKindLabels*/ true);
  32   OS << '\n';
  33   OS.flush();
  34 }
  35
  36 YAMLParseError::YAMLParseError(StringRef Msg, SourceMgr &SM,
  37                                yaml::Stream &Stream, yaml::Node &Node) {
  38   // 1) Set up a diagnostic handler to avoid errors being printed out to
  39   // stderr.
  40   // 2) Use the stream to print the error with the associated node.
  41   // 3) The stream will use the source manager to print the error, which will
  42   // call the diagnostic handler.
  43   // 4) The diagnostic handler will stream the error directly into this object's
  44   // Message member, which is used when logging is asked for.
  45   auto OldDiagHandler = SM.getDiagHandler();
  46   auto OldDiagCtx = SM.getDiagContext();
  47   SM.setDiagHandler(handleDiagnostic, &Message);
  48   Stream.printError(&Node, Twine(Msg) + Twine('\n'));
  49   // Restore the old handlers.
  50   SM.setDiagHandler(OldDiagHandler, OldDiagCtx);
  51 }
  52
  53 static SourceMgr setupSM(std::string &LastErrorMessage) {
  54   SourceMgr SM;
  55   SM.setDiagHandler(handleDiagnostic, &LastErrorMessage);
  56   return SM;
  57 }
  58
  59 // Parse the magic number. This function returns true if this represents remark
  60 // metadata, false otherwise.
  61 static Expected<bool> parseMagic(StringRef &Buf) {
  62   if (!Buf.consume_front(remarks::Magic))
  63     return false;
  64
  65   if (Buf.size() < 1 || !Buf.consume_front(StringRef("\0", 1)))
  66     return createStringError(std::errc::illegal_byte_sequence,
  67                              "Expecting \\0 after magic number.");
  68   return true;
  69 }
  70
  71 static Expected<uint64_t> parseVersion(StringRef &Buf) {
  72   if (Buf.size() < sizeof(uint64_t))
  73     return createStringError(std::errc::illegal_byte_sequence,
  74                              "Expecting version number.");
  75
  76   uint64_t Version =
  77       support::endian::read<uint64_t, support::little, support::unaligned>(
  78           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 }
  87
  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, support::little, support::unaligned>(
  94           Buf.data());
  95   Buf = Buf.drop_front(sizeof(uint64_t));
  96   return StrTabSize;
  97 }
  98
  99 static Expected<ParsedStringTable> parseStrTab(StringRef &Buf,
 100                                                uint64_t StrTabSize) {
 101   if (Buf.size() < StrTabSize)
 102     return createStringError(std::errc::illegal_byte_sequence,
 103                              "Expecting string table.");
 104
 105   // Attach the string table to the parser.
 106   ParsedStringTable Result(StringRef(Buf.data(), StrTabSize));
 107   Buf = Buf.drop_front(StrTabSize);
 108   return Expected<ParsedStringTable>(std::move(Result));
 109 }
 110
 111 Expected<std::unique_ptr<YAMLRemarkParser>>
 112 remarks::createYAMLParserFromMeta(StringRef Buf,
 113                                   Optional<ParsedStringTable> StrTab,
 114                                   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, None) {}
 172
 173 YAMLRemarkParser::YAMLRemarkParser(StringRef Buf,
 174                                    Optional<ParsedStringTable> StrTab)
 175     : RemarkParser{Format::YAML}, StrTab(std::move(StrTab)), LastErrorMessage(),
 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   if (!Value)
 297     return error("expected a value of scalar type.", Node);
 298   StringRef Result = Value->getRawValue();
 299
 300   if (Result.front() == '\'')
 301     Result = Result.drop_front();
 302
 303   if (Result.back() == '\'')
 304     Result = Result.drop_back();
 305
 306   return Result;
 307 }
 308
 309 Expected<unsigned> YAMLRemarkParser::parseUnsigned(yaml::KeyValueNode &Node) {
 310   SmallVector<char, 4> Tmp;
 311   auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
 312   if (!Value)
 313     return error("expected a value of scalar type.", Node);
 314   unsigned UnsignedValue = 0;
 315   if (Value->getValue(Tmp).getAsInteger(10, UnsignedValue))
 316     return error("expected a value of integer type.", *Value);
 317   return UnsignedValue;
 318 }
 319
 320 Expected<RemarkLocation>
 321 YAMLRemarkParser::parseDebugLoc(yaml::KeyValueNode &Node) {
 322   auto *DebugLoc = dyn_cast<yaml::MappingNode>(Node.getValue());
 323   if (!DebugLoc)
 324     return error("expected a value of mapping type.", Node);
 325
 326   Optional<StringRef> File;
 327   Optional<unsigned> Line;
 328   Optional<unsigned> Column;
 329
 330   for (yaml::KeyValueNode &DLNode : *DebugLoc) {
 331     Expected<StringRef> MaybeKey = parseKey(DLNode);
 332     if (!MaybeKey)
 333       return MaybeKey.takeError();
 334     StringRef KeyName = *MaybeKey;
 335
 336     if (KeyName == "File") {
 337       if (Expected<StringRef> MaybeStr = parseStr(DLNode))
 338         File = *MaybeStr;
 339       else
 340         return MaybeStr.takeError();
 341     } else if (KeyName == "Column") {
 342       if (Expected<unsigned> MaybeU = parseUnsigned(DLNode))
 343         Column = *MaybeU;
 344       else
 345         return MaybeU.takeError();
 346     } else if (KeyName == "Line") {
 347       if (Expected<unsigned> MaybeU = parseUnsigned(DLNode))
 348         Line = *MaybeU;
 349       else
 350         return MaybeU.takeError();
 351     } else {
 352       return error("unknown entry in DebugLoc map.", DLNode);
 353     }
 354   }
 355
 356   // If any of the debug loc fields is missing, return an error.
 357   if (!File || !Line || !Column)
 358     return error("DebugLoc node incomplete.", Node);
 359
 360   return RemarkLocation{*File, *Line, *Column};
 361 }
 362
 363 Expected<Argument> YAMLRemarkParser::parseArg(yaml::Node &Node) {
 364   auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);
 365   if (!ArgMap)
 366     return error("expected a value of mapping type.", Node);
 367
 368   Optional<StringRef> KeyStr;
 369   Optional<StringRef> ValueStr;
 370   Optional<RemarkLocation> Loc;
 371
 372   for (yaml::KeyValueNode &ArgEntry : *ArgMap) {
 373     Expected<StringRef> MaybeKey = parseKey(ArgEntry);
 374     if (!MaybeKey)
 375       return MaybeKey.takeError();
 376     StringRef KeyName = *MaybeKey;
 377
 378     // Try to parse debug locs.
 379     if (KeyName == "DebugLoc") {
 380       // Can't have multiple DebugLoc entries per argument.
 381       if (Loc)
 382         return error("only one DebugLoc entry is allowed per argument.",
 383                      ArgEntry);
 384
 385       if (Expected<RemarkLocation> MaybeLoc = parseDebugLoc(ArgEntry)) {
 386         Loc = *MaybeLoc;
 387         continue;
 388       } else
 389         return MaybeLoc.takeError();
 390     }
 391
 392     // If we already have a string, error out.
 393     if (ValueStr)
 394       return error("only one string entry is allowed per argument.", ArgEntry);
 395
 396     // Try to parse the value.
 397     if (Expected<StringRef> MaybeStr = parseStr(ArgEntry))
 398       ValueStr = *MaybeStr;
 399     else
 400       return MaybeStr.takeError();
 401
 402     // Keep the key from the string.
 403     KeyStr = KeyName;
 404   }
 405
 406   if (!KeyStr)
 407     return error("argument key is missing.", *ArgMap);
 408   if (!ValueStr)
 409     return error("argument value is missing.", *ArgMap);
 410
 411   return Argument{*KeyStr, *ValueStr, Loc};
 412 }
 413
 414 Expected<std::unique_ptr<Remark>> YAMLRemarkParser::next() {
 415   if (YAMLIt == Stream.end())
 416     return make_error<EndOfFileError>();
 417
 418   Expected<std::unique_ptr<Remark>> MaybeResult = parseRemark(*YAMLIt);
 419   if (!MaybeResult) {
 420     // Avoid garbage input, set the iterator to the end.
 421     YAMLIt = Stream.end();
 422     return MaybeResult.takeError();
 423   }
 424
 425   ++YAMLIt;
 426
 427   return std::move(*MaybeResult);
 428 }
 429
 430 Expected<StringRef> YAMLStrTabRemarkParser::parseStr(yaml::KeyValueNode &Node) {
 431   auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
 432   if (!Value)
 433     return error("expected a value of scalar type.", Node);
 434   StringRef Result;
 435   // If we have a string table, parse it as an unsigned.
 436   unsigned StrID = 0;
 437   if (Expected<unsigned> MaybeStrID = parseUnsigned(Node))
 438     StrID = *MaybeStrID;
 439   else
 440     return MaybeStrID.takeError();
 441
 442   if (Expected<StringRef> Str = (*StrTab)[StrID])
 443     Result = *Str;
 444   else
 445     return Str.takeError();
 446
 447   if (Result.front() == '\'')
 448     Result = Result.drop_front();
 449
 450   if (Result.back() == '\'')
 451     Result = Result.drop_back();
 452
 453   return Result;
 454 }