llvm/unittests/Remarks/BitstreamRemarksParsingTest.cpp

//===- unittests/Support/BitstreamRemarksParsingTest.cpp - Parsing tests --===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include "llvm-c/Remarks.h"
#include "llvm/Remarks/Remark.h"
#include "llvm/Remarks/RemarkParser.h"
#include "llvm/Remarks/RemarkSerializer.h"
#include "gtest/gtest.h"

using namespace llvm;

template <size_t N> void parseGood(const char (&Buf)[N]) {
  // 1. Parse the YAML remark -> FromYAMLRemark
  // 2. Serialize it to bitstream -> BSStream
  // 3. Parse it back -> FromBSRemark
  // 4. Compare the remark objects
  //
  // This testing methodology has the drawback of relying on both the YAML
  // remark parser and the bitstream remark serializer. It does simplify
  // testing a lot, since working directly with bitstream is not that easy.

  // 1.
  Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
      remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1});
  EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
  EXPECT_TRUE(*MaybeParser != nullptr);

  std::unique_ptr<remarks::Remark> FromYAMLRemark = nullptr;
  remarks::RemarkParser &Parser = **MaybeParser;
  Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
  EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
  EXPECT_TRUE(*Remark != nullptr);               // At least one remark.
  // Keep the previous remark around.
  FromYAMLRemark = std::move(*Remark);
  Remark = Parser.next();
  Error E = Remark.takeError();
  EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
  EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.

  // 2.
  remarks::StringTable BSStrTab;
  BSStrTab.internalize(*FromYAMLRemark);
  std::string BSBuf;
  raw_string_ostream BSStream(BSBuf);
  Expected<std::unique_ptr<remarks::RemarkSerializer>> BSSerializer =
      remarks::createRemarkSerializer(remarks::Format::Bitstream,
                                      remarks::SerializerMode::Standalone,
                                      BSStream, std::move(BSStrTab));
  EXPECT_FALSE(errorToBool(BSSerializer.takeError()));
  (*BSSerializer)->emit(*FromYAMLRemark);

  // 3.
  Expected<std::unique_ptr<remarks::RemarkParser>> MaybeBSParser =
      remarks::createRemarkParser(remarks::Format::Bitstream, BSStream.str());
  EXPECT_FALSE(errorToBool(MaybeBSParser.takeError()));
  EXPECT_TRUE(*MaybeBSParser != nullptr);

  std::unique_ptr<remarks::Remark> FromBSRemark = nullptr;
  remarks::RemarkParser &BSParser = **MaybeBSParser;
  Expected<std::unique_ptr<remarks::Remark>> BSRemark = BSParser.next();
  EXPECT_FALSE(errorToBool(BSRemark.takeError())); // Check for parsing errors.
  EXPECT_TRUE(*BSRemark != nullptr);               // At least one remark.
  // Keep the previous remark around.
  FromBSRemark = std::move(*BSRemark);
  BSRemark = BSParser.next();
  Error BSE = BSRemark.takeError();
  EXPECT_TRUE(BSE.isA<remarks::EndOfFileError>());
  EXPECT_TRUE(errorToBool(std::move(BSE))); // Check for parsing errors.

  EXPECT_EQ(*FromYAMLRemark, *FromBSRemark);
}

TEST(BitstreamRemarks, ParsingGood) {
  parseGood("\n"
            "--- !Missed\n"
            "Pass: inline\n"
            "Name: NoDefinition\n"
            "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
            "Function: foo\n"
            "Args:\n"
            "  - Callee: bar\n"
            "  - String: ' will not be inlined into '\n"
            "  - Caller: foo\n"
            "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
            "  - String: ' because its definition is unavailable'\n"
            "");

  // No debug loc should also pass.
  parseGood("\n"
            "--- !Missed\n"
            "Pass: inline\n"
            "Name: NoDefinition\n"
            "Function: foo\n"
            "Args:\n"
            "  - Callee: bar\n"
            "  - String: ' will not be inlined into '\n"
            "  - Caller: foo\n"
            "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
            "  - String: ' because its definition is unavailable'\n"
            "");

  // No args is also ok.
  parseGood("\n"
            "--- !Missed\n"
            "Pass: inline\n"
            "Name: NoDefinition\n"
            "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
            "Function: foo\n"
            "");
}

// Mandatory common part of a remark.
#define COMMON_REMARK "\nPass: inline\nName: NoDefinition\nFunction: foo\n\n"
// Test all the types.
TEST(BitstreamRemarks, ParsingTypes) {
  // Type: Passed
  parseGood("--- !Passed" COMMON_REMARK);
  // Type: Missed
  parseGood("--- !Missed" COMMON_REMARK);
  // Type: Analysis
  parseGood("--- !Analysis" COMMON_REMARK);
  // Type: AnalysisFPCommute
  parseGood("--- !AnalysisFPCommute" COMMON_REMARK);
  // Type: AnalysisAliasing
  parseGood("--- !AnalysisAliasing" COMMON_REMARK);
  // Type: Failure
  parseGood("--- !Failure" COMMON_REMARK);
}
#undef COMMON_REMARK

static inline StringRef checkStr(StringRef Str, unsigned ExpectedLen) {
  const char *StrData = Str.data();
  unsigned StrLen = Str.size();
  EXPECT_EQ(StrLen, ExpectedLen);
  return StringRef(StrData, StrLen);
}

TEST(BitstreamRemarks, Contents) {
  StringRef Buf = "\n"
                  "--- !Missed\n"
                  "Pass: inline\n"
                  "Name: NoDefinition\n"
                  "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
                  "Function: foo\n"
                  "Hotness: 4\n"
                  "Args:\n"
                  "  - Callee: bar\n"
                  "  - String: ' will not be inlined into '\n"
                  "  - Caller: foo\n"
                  "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
                  "  - String: ' because its definition is unavailable'\n"
                  "\n";

  Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
      remarks::createRemarkParser(remarks::Format::YAML, Buf);
  EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
  EXPECT_TRUE(*MaybeParser != nullptr);

  remarks::RemarkParser &Parser = **MaybeParser;
  Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
  EXPECT_FALSE(
      errorToBool(MaybeRemark.takeError())); // Check for parsing errors.
  EXPECT_TRUE(*MaybeRemark != nullptr);      // At least one remark.

  const remarks::Remark &Remark = **MaybeRemark;
  EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
  EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
  EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
  EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
  EXPECT_TRUE(Remark.Loc);
  const remarks::RemarkLocation &RL = *Remark.Loc;
  EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
  EXPECT_EQ(RL.SourceLine, 3U);
  EXPECT_EQ(RL.SourceColumn, 12U);
  EXPECT_TRUE(Remark.Hotness);
  EXPECT_EQ(*Remark.Hotness, 4U);
  EXPECT_EQ(Remark.Args.size(), 4U);

  unsigned ArgID = 0;
  for (const remarks::Argument &Arg : Remark.Args) {
    switch (ArgID) {
    case 0:
      EXPECT_EQ(checkStr(Arg.Key, 6), "Callee");
      EXPECT_EQ(checkStr(Arg.Val, 3), "bar");
      EXPECT_FALSE(Arg.Loc);
      break;
    case 1:
      EXPECT_EQ(checkStr(Arg.Key, 6), "String");
      EXPECT_EQ(checkStr(Arg.Val, 26), " will not be inlined into ");
      EXPECT_FALSE(Arg.Loc);
      break;
    case 2: {
      EXPECT_EQ(checkStr(Arg.Key, 6), "Caller");
      EXPECT_EQ(checkStr(Arg.Val, 3), "foo");
      EXPECT_TRUE(Arg.Loc);
      const remarks::RemarkLocation &RL = *Arg.Loc;
      EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
      EXPECT_EQ(RL.SourceLine, 2U);
      EXPECT_EQ(RL.SourceColumn, 0U);
      break;
    }
    case 3:
      EXPECT_EQ(checkStr(Arg.Key, 6), "String");
      EXPECT_EQ(checkStr(Arg.Val, 38),
                " because its definition is unavailable");
      EXPECT_FALSE(Arg.Loc);
      break;
    default:
      break;
    }
    ++ArgID;
  }

  MaybeRemark = Parser.next();
  Error E = MaybeRemark.takeError();
  EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
  EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
}

static inline StringRef checkStr(LLVMRemarkStringRef Str,
                                 unsigned ExpectedLen) {
  const char *StrData = LLVMRemarkStringGetData(Str);
  unsigned StrLen = LLVMRemarkStringGetLen(Str);
  EXPECT_EQ(StrLen, ExpectedLen);
  return StringRef(StrData, StrLen);
}

TEST(BitstreamRemarks, ContentsCAPI) {
  remarks::StringTable BSStrTab;
  remarks::Remark ToSerializeRemark;
  ToSerializeRemark.RemarkType = remarks::Type::Missed;
  ToSerializeRemark.PassName = "inline";
  ToSerializeRemark.RemarkName = "NoDefinition";
  ToSerializeRemark.FunctionName = "foo";
  ToSerializeRemark.Loc = remarks::RemarkLocation{"file.c", 3, 12};
  ToSerializeRemark.Hotness = 0;
  ToSerializeRemark.Args.emplace_back();
  ToSerializeRemark.Args.back().Key = "Callee";
  ToSerializeRemark.Args.back().Val = "bar";
  ToSerializeRemark.Args.emplace_back();
  ToSerializeRemark.Args.back().Key = "String";
  ToSerializeRemark.Args.back().Val = " will not be inlined into ";
  ToSerializeRemark.Args.emplace_back();
  ToSerializeRemark.Args.back().Key = "Caller";
  ToSerializeRemark.Args.back().Val = "foo";
  ToSerializeRemark.Args.back().Loc = remarks::RemarkLocation{"file.c", 2, 0};
  ToSerializeRemark.Args.emplace_back();
  ToSerializeRemark.Args.back().Key = "String";
  ToSerializeRemark.Args.back().Val = " because its definition is unavailable";
  BSStrTab.internalize(ToSerializeRemark);
  std::string BSBuf;
  raw_string_ostream BSStream(BSBuf);
  Expected<std::unique_ptr<remarks::RemarkSerializer>> BSSerializer =
      remarks::createRemarkSerializer(remarks::Format::Bitstream,
                                      remarks::SerializerMode::Standalone,
                                      BSStream, std::move(BSStrTab));
  EXPECT_FALSE(errorToBool(BSSerializer.takeError()));
  (*BSSerializer)->emit(ToSerializeRemark);

  StringRef Buf = BSStream.str();
  LLVMRemarkParserRef Parser =
      LLVMRemarkParserCreateBitstream(Buf.data(), Buf.size());
  LLVMRemarkEntryRef Remark = LLVMRemarkParserGetNext(Parser);
  EXPECT_FALSE(Remark == nullptr);
  EXPECT_EQ(LLVMRemarkEntryGetType(Remark), LLVMRemarkTypeMissed);
  EXPECT_EQ(checkStr(LLVMRemarkEntryGetPassName(Remark), 6), "inline");
  EXPECT_EQ(checkStr(LLVMRemarkEntryGetRemarkName(Remark), 12), "NoDefinition");
  EXPECT_EQ(checkStr(LLVMRemarkEntryGetFunctionName(Remark), 3), "foo");
  LLVMRemarkDebugLocRef DL = LLVMRemarkEntryGetDebugLoc(Remark);
  EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
  EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 3U);
  EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 12U);
  EXPECT_EQ(LLVMRemarkEntryGetHotness(Remark), 0U);
  EXPECT_EQ(LLVMRemarkEntryGetNumArgs(Remark), 4U);

  unsigned ArgID = 0;
  LLVMRemarkArgRef Arg = LLVMRemarkEntryGetFirstArg(Remark);
  do {
    switch (ArgID) {
    case 0:
      EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Callee");
      EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "bar");
      EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
      break;
    case 1:
      EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
      EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 26),
                " will not be inlined into ");
      EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
      break;
    case 2: {
      EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Caller");
      EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "foo");
      LLVMRemarkDebugLocRef DL = LLVMRemarkArgGetDebugLoc(Arg);
      EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
      EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 2U);
      EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 0U);
      break;
    }
    case 3:
      EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
      EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 38),
                " because its definition is unavailable");
      EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
      break;
    default:
      break;
    }
    ++ArgID;
  } while ((Arg = LLVMRemarkEntryGetNextArg(Arg, Remark)));

  LLVMRemarkEntryDispose(Remark);

  EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr);

  EXPECT_FALSE(LLVMRemarkParserHasError(Parser));
  LLVMRemarkParserDispose(Parser);
}

static void parseBad(StringRef Input, const char *ErrorMsg) {
  Expected<std::unique_ptr<remarks::RemarkParser>> MaybeBSParser =
      remarks::createRemarkParser(remarks::Format::Bitstream, Input);
  EXPECT_FALSE(errorToBool(MaybeBSParser.takeError()));
  EXPECT_TRUE(*MaybeBSParser != nullptr);

  remarks::RemarkParser &BSParser = **MaybeBSParser;
  Expected<std::unique_ptr<remarks::Remark>> BSRemark = BSParser.next();
  EXPECT_EQ(ErrorMsg, toString(BSRemark.takeError())); // Expect an error.
}

TEST(BitstreamRemarks, ParsingEmpty) {
  parseBad(StringRef(), "End of file reached.");
}

TEST(BitstreamRemarks, ParsingBadMagic) {
  parseBad("KRMR", "Unknown magic number: expecting RMRK, got KRMR.");
}

// Testing malformed bitstream is not easy. We would need to replace bytes in
// the stream to create malformed and unknown records and blocks. There is no
// textual format for bitstream that can be decoded, modified and encoded
// back.

// FIXME: Add tests for the following error messages:
// * Error while parsing META_BLOCK: malformed record entry
// (RECORD_META_CONTAINER_INFO).
// * Error while parsing META_BLOCK: malformed record entry
// (RECORD_META_REMARK_VERSION).
// * Error while parsing META_BLOCK: malformed record entry
// (RECORD_META_STRTAB).
// * Error while parsing META_BLOCK: malformed record entry
// (RECORD_META_EXTERNAL_FILE).
// * Error while parsing META_BLOCK: unknown record entry (NUM).
// * Error while parsing REMARK_BLOCK: malformed record entry
// (RECORD_REMARK_HEADER).
// * Error while parsing REMARK_BLOCK: malformed record entry
// (RECORD_REMARK_DEBUG_LOC).
// * Error while parsing REMARK_BLOCK: malformed record entry
// (RECORD_REMARK_HOTNESS).
// * Error while parsing REMARK_BLOCK: malformed record entry
// (RECORD_REMARK_ARG_WITH_DEBUGLOC).
// * Error while parsing REMARK_BLOCK: malformed record entry
// (RECORD_REMARK_ARG_WITHOUT_DEBUGLOC).
// * Error while parsing REMARK_BLOCK: unknown record entry (NUM).
// * Error while parsing META_BLOCK: expecting [ENTER_SUBBLOCO, META_BLOCK,
// ...].
// * Error while entering META_BLOCK.
// * Error while parsing META_BLOCK: expecting records.
// * Error while parsing META_BLOCK: unterminated block.
// * Error while parsing REMARK_BLOCK: expecting [ENTER_SUBBLOCO, REMARK_BLOCK,
// ...].
// * Error while entering REMARK_BLOCK.
// * Error while parsing REMARK_BLOCK: expecting records.
// * Error while parsing REMARK_BLOCK: unterminated block.
// * Error while parsing BLOCKINFO_BLOCK: expecting [ENTER_SUBBLOCK,
// BLOCKINFO_BLOCK, ...].
// * Error while parsing BLOCKINFO_BLOCK.
// * Unexpected error while parsing bitstream.
// * Expecting META_BLOCK after the BLOCKINFO_BLOCK.
// * Error while parsing BLOCK_META: missing container version.
// * Error while parsing BLOCK_META: invalid container type.
// * Error while parsing BLOCK_META: missing container type.
// * Error while parsing BLOCK_META: missing string table.
// * Error while parsing BLOCK_META: missing remark version.
// * Error while parsing BLOCK_META: missing external file path.
// * Error while parsing external file's BLOCK_META: wrong container type.
// * Error while parsing external file's BLOCK_META: mismatching versions:
// original meta: NUM, external file meta: NUM.
// * Error while parsing BLOCK_REMARK: missing string table.
// * Error while parsing BLOCK_REMARK: missing remark type.
// * Error while parsing BLOCK_REMARK: unknown remark type.
// * Error while parsing BLOCK_REMARK: missing remark name.
// * Error while parsing BLOCK_REMARK: missing remark pass.
// * Error while parsing BLOCK_REMARK: missing remark function name.
// * Error while parsing BLOCK_REMARK: missing key in remark argument.
// * Error while parsing BLOCK_REMARK: missing value in remark argument.