unittests/Remarks/BitstreamRemarksParsingTest.cpp

   1 //===- unittests/Support/BitstreamRemarksParsingTest.cpp - Parsing tests --===//
   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 #include "llvm-c/Remarks.h"
  10 #include "llvm/Remarks/Remark.h"
  11 #include "llvm/Remarks/RemarkParser.h"
  12 #include "llvm/Remarks/RemarkSerializer.h"
  13 #include "gtest/gtest.h"
  14
  15 using namespace llvm;
  16
  17 template <size_t N> void parseGood(const char (&Buf)[N]) {
  18   // 1. Parse the YAML remark -> FromYAMLRemark
  19   // 2. Serialize it to bitstream -> BSStream
  20   // 3. Parse it back -> FromBSRemark
  21   // 4. Compare the remark objects
  22   //
  23   // This testing methodology has the drawback of relying on both the YAML
  24   // remark parser and the bitstream remark serializer. It does simplify
  25   // testing a lot, since working directly with bitstream is not that easy.
  26
  27   // 1.
  28   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
  29       remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1});
  30   EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
  31   EXPECT_TRUE(*MaybeParser != nullptr);
  32
  33   std::unique_ptr<remarks::Remark> FromYAMLRemark = nullptr;
  34   remarks::RemarkParser &Parser = **MaybeParser;
  35   Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
  36   EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
  37   EXPECT_TRUE(*Remark != nullptr);               // At least one remark.
  38   // Keep the previous remark around.
  39   FromYAMLRemark = std::move(*Remark);
  40   Remark = Parser.next();
  41   Error E = Remark.takeError();
  42   EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
  43   EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
  44
  45   // 2.
  46   remarks::StringTable BSStrTab;
  47   BSStrTab.internalize(*FromYAMLRemark);
  48   std::string BSBuf;
  49   raw_string_ostream BSStream(BSBuf);
  50   Expected<std::unique_ptr<remarks::RemarkSerializer>> BSSerializer =
  51       remarks::createRemarkSerializer(remarks::Format::Bitstream,
  52                                       remarks::SerializerMode::Standalone,
  53                                       BSStream, std::move(BSStrTab));
  54   EXPECT_FALSE(errorToBool(BSSerializer.takeError()));
  55   (*BSSerializer)->emit(*FromYAMLRemark);
  56
  57   // 3.
  58   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeBSParser =
  59       remarks::createRemarkParser(remarks::Format::Bitstream, BSStream.str());
  60   EXPECT_FALSE(errorToBool(MaybeBSParser.takeError()));
  61   EXPECT_TRUE(*MaybeBSParser != nullptr);
  62
  63   std::unique_ptr<remarks::Remark> FromBSRemark = nullptr;
  64   remarks::RemarkParser &BSParser = **MaybeBSParser;
  65   Expected<std::unique_ptr<remarks::Remark>> BSRemark = BSParser.next();
  66   EXPECT_FALSE(errorToBool(BSRemark.takeError())); // Check for parsing errors.
  67   EXPECT_TRUE(*BSRemark != nullptr);               // At least one remark.
  68   // Keep the previous remark around.
  69   FromBSRemark = std::move(*BSRemark);
  70   BSRemark = BSParser.next();
  71   Error BSE = BSRemark.takeError();
  72   EXPECT_TRUE(BSE.isA<remarks::EndOfFileError>());
  73   EXPECT_TRUE(errorToBool(std::move(BSE))); // Check for parsing errors.
  74
  75   EXPECT_EQ(*FromYAMLRemark, *FromBSRemark);
  76 }
  77
  78 TEST(BitstreamRemarks, ParsingGood) {
  79   parseGood("\n"
  80             "--- !Missed\n"
  81             "Pass: inline\n"
  82             "Name: NoDefinition\n"
  83             "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
  84             "Function: foo\n"
  85             "Args:\n"
  86             "  - Callee: bar\n"
  87             "  - String: ' will not be inlined into '\n"
  88             "  - Caller: foo\n"
  89             "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
  90             "  - String: ' because its definition is unavailable'\n"
  91             "");
  92
  93   // No debug loc should also pass.
  94   parseGood("\n"
  95             "--- !Missed\n"
  96             "Pass: inline\n"
  97             "Name: NoDefinition\n"
  98             "Function: foo\n"
  99             "Args:\n"
 100             "  - Callee: bar\n"
 101             "  - String: ' will not be inlined into '\n"
 102             "  - Caller: foo\n"
 103             "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
 104             "  - String: ' because its definition is unavailable'\n"
 105             "");
 106
 107   // No args is also ok.
 108   parseGood("\n"
 109             "--- !Missed\n"
 110             "Pass: inline\n"
 111             "Name: NoDefinition\n"
 112             "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
 113             "Function: foo\n"
 114             "");
 115 }
 116
 117 // Mandatory common part of a remark.
 118 #define COMMON_REMARK "\nPass: inline\nName: NoDefinition\nFunction: foo\n\n"
 119 // Test all the types.
 120 TEST(BitstreamRemarks, ParsingTypes) {
 121   // Type: Passed
 122   parseGood("--- !Passed" COMMON_REMARK);
 123   // Type: Missed
 124   parseGood("--- !Missed" COMMON_REMARK);
 125   // Type: Analysis
 126   parseGood("--- !Analysis" COMMON_REMARK);
 127   // Type: AnalysisFPCommute
 128   parseGood("--- !AnalysisFPCommute" COMMON_REMARK);
 129   // Type: AnalysisAliasing
 130   parseGood("--- !AnalysisAliasing" COMMON_REMARK);
 131   // Type: Failure
 132   parseGood("--- !Failure" COMMON_REMARK);
 133 }
 134 #undef COMMON_REMARK
 135
 136 static inline StringRef checkStr(StringRef Str, unsigned ExpectedLen) {
 137   const char *StrData = Str.data();
 138   unsigned StrLen = Str.size();
 139   EXPECT_EQ(StrLen, ExpectedLen);
 140   return StringRef(StrData, StrLen);
 141 }
 142
 143 TEST(BitstreamRemarks, Contents) {
 144   StringRef Buf = "\n"
 145                   "--- !Missed\n"
 146                   "Pass: inline\n"
 147                   "Name: NoDefinition\n"
 148                   "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
 149                   "Function: foo\n"
 150                   "Hotness: 4\n"
 151                   "Args:\n"
 152                   "  - Callee: bar\n"
 153                   "  - String: ' will not be inlined into '\n"
 154                   "  - Caller: foo\n"
 155                   "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
 156                   "  - String: ' because its definition is unavailable'\n"
 157                   "\n";
 158
 159   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
 160       remarks::createRemarkParser(remarks::Format::YAML, Buf);
 161   EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
 162   EXPECT_TRUE(*MaybeParser != nullptr);
 163
 164   remarks::RemarkParser &Parser = **MaybeParser;
 165   Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
 166   EXPECT_FALSE(
 167       errorToBool(MaybeRemark.takeError())); // Check for parsing errors.
 168   EXPECT_TRUE(*MaybeRemark != nullptr);      // At least one remark.
 169
 170   const remarks::Remark &Remark = **MaybeRemark;
 171   EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
 172   EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
 173   EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
 174   EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
 175   EXPECT_TRUE(Remark.Loc);
 176   const remarks::RemarkLocation &RL = *Remark.Loc;
 177   EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
 178   EXPECT_EQ(RL.SourceLine, 3U);
 179   EXPECT_EQ(RL.SourceColumn, 12U);
 180   EXPECT_TRUE(Remark.Hotness);
 181   EXPECT_EQ(*Remark.Hotness, 4U);
 182   EXPECT_EQ(Remark.Args.size(), 4U);
 183
 184   unsigned ArgID = 0;
 185   for (const remarks::Argument &Arg : Remark.Args) {
 186     switch (ArgID) {
 187     case 0:
 188       EXPECT_EQ(checkStr(Arg.Key, 6), "Callee");
 189       EXPECT_EQ(checkStr(Arg.Val, 3), "bar");
 190       EXPECT_FALSE(Arg.Loc);
 191       break;
 192     case 1:
 193       EXPECT_EQ(checkStr(Arg.Key, 6), "String");
 194       EXPECT_EQ(checkStr(Arg.Val, 26), " will not be inlined into ");
 195       EXPECT_FALSE(Arg.Loc);
 196       break;
 197     case 2: {
 198       EXPECT_EQ(checkStr(Arg.Key, 6), "Caller");
 199       EXPECT_EQ(checkStr(Arg.Val, 3), "foo");
 200       EXPECT_TRUE(Arg.Loc);
 201       const remarks::RemarkLocation &RL = *Arg.Loc;
 202       EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
 203       EXPECT_EQ(RL.SourceLine, 2U);
 204       EXPECT_EQ(RL.SourceColumn, 0U);
 205       break;
 206     }
 207     case 3:
 208       EXPECT_EQ(checkStr(Arg.Key, 6), "String");
 209       EXPECT_EQ(checkStr(Arg.Val, 38),
 210                 " because its definition is unavailable");
 211       EXPECT_FALSE(Arg.Loc);
 212       break;
 213     default:
 214       break;
 215     }
 216     ++ArgID;
 217   }
 218
 219   MaybeRemark = Parser.next();
 220   Error E = MaybeRemark.takeError();
 221   EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
 222   EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
 223 }
 224
 225 static inline StringRef checkStr(LLVMRemarkStringRef Str,
 226                                  unsigned ExpectedLen) {
 227   const char *StrData = LLVMRemarkStringGetData(Str);
 228   unsigned StrLen = LLVMRemarkStringGetLen(Str);
 229   EXPECT_EQ(StrLen, ExpectedLen);
 230   return StringRef(StrData, StrLen);
 231 }
 232
 233 TEST(BitstreamRemarks, ContentsCAPI) {
 234   remarks::StringTable BSStrTab;
 235   remarks::Remark ToSerializeRemark;
 236   ToSerializeRemark.RemarkType = remarks::Type::Missed;
 237   ToSerializeRemark.PassName = "inline";
 238   ToSerializeRemark.RemarkName = "NoDefinition";
 239   ToSerializeRemark.FunctionName = "foo";
 240   ToSerializeRemark.Loc = remarks::RemarkLocation{"file.c", 3, 12};
 241   ToSerializeRemark.Hotness = 0;
 242   ToSerializeRemark.Args.emplace_back();
 243   ToSerializeRemark.Args.back().Key = "Callee";
 244   ToSerializeRemark.Args.back().Val = "bar";
 245   ToSerializeRemark.Args.emplace_back();
 246   ToSerializeRemark.Args.back().Key = "String";
 247   ToSerializeRemark.Args.back().Val = " will not be inlined into ";
 248   ToSerializeRemark.Args.emplace_back();
 249   ToSerializeRemark.Args.back().Key = "Caller";
 250   ToSerializeRemark.Args.back().Val = "foo";
 251   ToSerializeRemark.Args.back().Loc = remarks::RemarkLocation{"file.c", 2, 0};
 252   ToSerializeRemark.Args.emplace_back();
 253   ToSerializeRemark.Args.back().Key = "String";
 254   ToSerializeRemark.Args.back().Val = " because its definition is unavailable";
 255   BSStrTab.internalize(ToSerializeRemark);
 256   std::string BSBuf;
 257   raw_string_ostream BSStream(BSBuf);
 258   Expected<std::unique_ptr<remarks::RemarkSerializer>> BSSerializer =
 259       remarks::createRemarkSerializer(remarks::Format::Bitstream,
 260                                       remarks::SerializerMode::Standalone,
 261                                       BSStream, std::move(BSStrTab));
 262   EXPECT_FALSE(errorToBool(BSSerializer.takeError()));
 263   (*BSSerializer)->emit(ToSerializeRemark);
 264
 265   StringRef Buf = BSStream.str();
 266   LLVMRemarkParserRef Parser =
 267       LLVMRemarkParserCreateBitstream(Buf.data(), Buf.size());
 268   LLVMRemarkEntryRef Remark = LLVMRemarkParserGetNext(Parser);
 269   EXPECT_FALSE(Remark == nullptr);
 270   EXPECT_EQ(LLVMRemarkEntryGetType(Remark), LLVMRemarkTypeMissed);
 271   EXPECT_EQ(checkStr(LLVMRemarkEntryGetPassName(Remark), 6), "inline");
 272   EXPECT_EQ(checkStr(LLVMRemarkEntryGetRemarkName(Remark), 12), "NoDefinition");
 273   EXPECT_EQ(checkStr(LLVMRemarkEntryGetFunctionName(Remark), 3), "foo");
 274   LLVMRemarkDebugLocRef DL = LLVMRemarkEntryGetDebugLoc(Remark);
 275   EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
 276   EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 3U);
 277   EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 12U);
 278   EXPECT_EQ(LLVMRemarkEntryGetHotness(Remark), 0U);
 279   EXPECT_EQ(LLVMRemarkEntryGetNumArgs(Remark), 4U);
 280
 281   unsigned ArgID = 0;
 282   LLVMRemarkArgRef Arg = LLVMRemarkEntryGetFirstArg(Remark);
 283   do {
 284     switch (ArgID) {
 285     case 0:
 286       EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Callee");
 287       EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "bar");
 288       EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
 289       break;
 290     case 1:
 291       EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
 292       EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 26),
 293                 " will not be inlined into ");
 294       EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
 295       break;
 296     case 2: {
 297       EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Caller");
 298       EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "foo");
 299       LLVMRemarkDebugLocRef DL = LLVMRemarkArgGetDebugLoc(Arg);
 300       EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
 301       EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 2U);
 302       EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 0U);
 303       break;
 304     }
 305     case 3:
 306       EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
 307       EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 38),
 308                 " because its definition is unavailable");
 309       EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
 310       break;
 311     default:
 312       break;
 313     }
 314     ++ArgID;
 315   } while ((Arg = LLVMRemarkEntryGetNextArg(Arg, Remark)));
 316
 317   LLVMRemarkEntryDispose(Remark);
 318
 319   EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr);
 320
 321   EXPECT_FALSE(LLVMRemarkParserHasError(Parser));
 322   LLVMRemarkParserDispose(Parser);
 323 }
 324
 325 static void parseBad(StringRef Input, const char *ErrorMsg) {
 326   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeBSParser =
 327       remarks::createRemarkParser(remarks::Format::Bitstream, Input);
 328   EXPECT_FALSE(errorToBool(MaybeBSParser.takeError()));
 329   EXPECT_TRUE(*MaybeBSParser != nullptr);
 330
 331   remarks::RemarkParser &BSParser = **MaybeBSParser;
 332   Expected<std::unique_ptr<remarks::Remark>> BSRemark = BSParser.next();
 333   EXPECT_EQ(ErrorMsg, toString(BSRemark.takeError())); // Expect an error.
 334 }
 335
 336 TEST(BitstreamRemarks, ParsingEmpty) {
 337   parseBad(StringRef(), "End of file reached.");
 338 }
 339
 340 TEST(BitstreamRemarks, ParsingBadMagic) {
 341   parseBad("KRMR", "Unknown magic number: expecting RMRK, got KRMR.");
 342 }
 343
 344 // Testing malformed bitstream is not easy. We would need to replace bytes in
 345 // the stream to create malformed and unknown records and blocks. There is no
 346 // textual format for bitstream that can be decoded, modified and encoded
 347 // back.
 348
 349 // FIXME: Add tests for the following error messages:
 350 // * Error while parsing META_BLOCK: malformed record entry
 351 // (RECORD_META_CONTAINER_INFO).
 352 // * Error while parsing META_BLOCK: malformed record entry
 353 // (RECORD_META_REMARK_VERSION).
 354 // * Error while parsing META_BLOCK: malformed record entry
 355 // (RECORD_META_STRTAB).
 356 // * Error while parsing META_BLOCK: malformed record entry
 357 // (RECORD_META_EXTERNAL_FILE).
 358 // * Error while parsing META_BLOCK: unknown record entry (NUM).
 359 // * Error while parsing REMARK_BLOCK: malformed record entry
 360 // (RECORD_REMARK_HEADER).
 361 // * Error while parsing REMARK_BLOCK: malformed record entry
 362 // (RECORD_REMARK_DEBUG_LOC).
 363 // * Error while parsing REMARK_BLOCK: malformed record entry
 364 // (RECORD_REMARK_HOTNESS).
 365 // * Error while parsing REMARK_BLOCK: malformed record entry
 366 // (RECORD_REMARK_ARG_WITH_DEBUGLOC).
 367 // * Error while parsing REMARK_BLOCK: malformed record entry
 368 // (RECORD_REMARK_ARG_WITHOUT_DEBUGLOC).
 369 // * Error while parsing REMARK_BLOCK: unknown record entry (NUM).
 370 // * Error while parsing META_BLOCK: expecting [ENTER_SUBBLOCO, META_BLOCK,
 371 // ...].
 372 // * Error while entering META_BLOCK.
 373 // * Error while parsing META_BLOCK: expecting records.
 374 // * Error while parsing META_BLOCK: unterminated block.
 375 // * Error while parsing REMARK_BLOCK: expecting [ENTER_SUBBLOCO, REMARK_BLOCK,
 376 // ...].
 377 // * Error while entering REMARK_BLOCK.
 378 // * Error while parsing REMARK_BLOCK: expecting records.
 379 // * Error while parsing REMARK_BLOCK: unterminated block.
 380 // * Error while parsing BLOCKINFO_BLOCK: expecting [ENTER_SUBBLOCK,
 381 // BLOCKINFO_BLOCK, ...].
 382 // * Error while parsing BLOCKINFO_BLOCK.
 383 // * Unexpected error while parsing bitstream.
 384 // * Expecting META_BLOCK after the BLOCKINFO_BLOCK.
 385 // * Error while parsing BLOCK_META: missing container version.
 386 // * Error while parsing BLOCK_META: invalid container type.
 387 // * Error while parsing BLOCK_META: missing container type.
 388 // * Error while parsing BLOCK_META: missing string table.
 389 // * Error while parsing BLOCK_META: missing remark version.
 390 // * Error while parsing BLOCK_META: missing external file path.
 391 // * Error while parsing external file's BLOCK_META: wrong container type.
 392 // * Error while parsing external file's BLOCK_META: mismatching versions:
 393 // original meta: NUM, external file meta: NUM.
 394 // * Error while parsing BLOCK_REMARK: missing string table.
 395 // * Error while parsing BLOCK_REMARK: missing remark type.
 396 // * Error while parsing BLOCK_REMARK: unknown remark type.
 397 // * Error while parsing BLOCK_REMARK: missing remark name.
 398 // * Error while parsing BLOCK_REMARK: missing remark pass.
 399 // * Error while parsing BLOCK_REMARK: missing remark function name.
 400 // * Error while parsing BLOCK_REMARK: missing key in remark argument.
 401 // * Error while parsing BLOCK_REMARK: missing value in remark argument.