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