| //===- unittest/Support/YAMLRemarksParsingTest.cpp - OptTable 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 "gtest/gtest.h" |
| |
| using namespace llvm; |
| |
| template <size_t N> void parseGood(const char (&Buf)[N]) { |
| Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser = |
| remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1}); |
| EXPECT_FALSE(errorToBool(MaybeParser.takeError())); |
| EXPECT_TRUE(*MaybeParser != 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. |
| Remark = Parser.next(); |
| Error E = Remark.takeError(); |
| EXPECT_TRUE(E.isA<remarks::EndOfFileError>()); |
| EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors. |
| } |
| |
| void parseGoodMeta(StringRef Buf) { |
| Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser = |
| remarks::createRemarkParserFromMeta(remarks::Format::YAML, Buf); |
| EXPECT_FALSE(errorToBool(MaybeParser.takeError())); |
| EXPECT_TRUE(*MaybeParser != 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. |
| Remark = Parser.next(); |
| Error E = Remark.takeError(); |
| EXPECT_TRUE(E.isA<remarks::EndOfFileError>()); |
| EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors. |
| } |
| |
| template <size_t N> |
| bool parseExpectError(const char (&Buf)[N], const char *Error) { |
| Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser = |
| remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1}); |
| EXPECT_FALSE(errorToBool(MaybeParser.takeError())); |
| EXPECT_TRUE(*MaybeParser != nullptr); |
| |
| remarks::RemarkParser &Parser = **MaybeParser; |
| Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next(); |
| EXPECT_FALSE(Remark); // Check for parsing errors. |
| |
| std::string ErrorStr; |
| raw_string_ostream Stream(ErrorStr); |
| handleAllErrors(Remark.takeError(), |
| [&](const ErrorInfoBase &EIB) { EIB.log(Stream); }); |
| return StringRef(Stream.str()).contains(Error); |
| } |
| |
| enum class CmpType { |
| Equal, |
| Contains |
| }; |
| |
| void parseExpectErrorMeta(StringRef Buf, const char *Error, CmpType Cmp, |
| Optional<StringRef> ExternalFilePrependPath = None) { |
| std::string ErrorStr; |
| raw_string_ostream Stream(ErrorStr); |
| |
| Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser = |
| remarks::createRemarkParserFromMeta(remarks::Format::YAML, Buf, |
| /*StrTab=*/None, |
| std::move(ExternalFilePrependPath)); |
| handleAllErrors(MaybeParser.takeError(), |
| [&](const ErrorInfoBase &EIB) { EIB.log(Stream); }); |
| |
| // Use a case insensitive comparision due to case differences in error strings |
| // for different OSs. |
| if (Cmp == CmpType::Equal) { |
| EXPECT_EQ(StringRef(Stream.str()).lower(), StringRef(Error).lower()); |
| } |
| |
| if (Cmp == CmpType::Contains) { |
| EXPECT_TRUE(StringRef(Stream.str()).contains(StringRef(Error))); |
| } |
| } |
| |
| TEST(YAMLRemarks, ParsingEmpty) { |
| EXPECT_TRUE(parseExpectError("\n\n", "document root is not of mapping type.")); |
| } |
| |
| TEST(YAMLRemarks, ParsingNotYAML) { |
| EXPECT_TRUE( |
| parseExpectError("\x01\x02\x03\x04\x05\x06", "Got empty plain scalar")); |
| } |
| |
| TEST(YAMLRemarks, 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" |
| ""); |
| |
| // Different order. |
| parseGood("\n" |
| "--- !Missed\n" |
| "DebugLoc: { Line: 3, Column: 12, File: file.c }\n" |
| "Function: foo\n" |
| "Name: NoDefinition\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" |
| "Pass: inline\n" |
| ""); |
| } |
| |
| // Mandatory common part of a remark. |
| #define COMMON_REMARK "\nPass: inline\nName: NoDefinition\nFunction: foo\n\n" |
| // Test all the types. |
| TEST(YAMLRemarks, 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 |
| |
| TEST(YAMLRemarks, ParsingMissingFields) { |
| // No type. |
| EXPECT_TRUE(parseExpectError("\n" |
| "---\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "", |
| "expected a remark tag.")); |
| // No pass. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "", |
| "Type, Pass, Name or Function missing.")); |
| // No name. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Function: foo\n" |
| "", |
| "Type, Pass, Name or Function missing.")); |
| // No function. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "", |
| "Type, Pass, Name or Function missing.")); |
| // Debug loc but no file. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: { Line: 3, Column: 12 }\n" |
| "", |
| "DebugLoc node incomplete.")); |
| // Debug loc but no line. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: { File: file.c, Column: 12 }\n" |
| "", |
| "DebugLoc node incomplete.")); |
| // Debug loc but no column. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: { File: file.c, Line: 3 }\n" |
| "", |
| "DebugLoc node incomplete.")); |
| } |
| |
| TEST(YAMLRemarks, ParsingWrongTypes) { |
| // Wrong debug loc type. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: foo\n" |
| "", |
| "expected a value of mapping type.")); |
| // Wrong line type. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: { File: file.c, Line: b, Column: 12 }\n" |
| "", |
| "expected a value of integer type.")); |
| // Wrong column type. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: { File: file.c, Line: 3, Column: c }\n" |
| "", |
| "expected a value of integer type.")); |
| // Wrong args type. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "Args: foo\n" |
| "", |
| "wrong value type for key.")); |
| // Wrong key type. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "{ A: a }: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "", |
| "key is not a string.")); |
| // Debug loc with unknown entry. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: { File: file.c, Column: 12, Unknown: 12 }\n" |
| "", |
| "unknown entry in DebugLoc map.")); |
| // Unknown entry. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Unknown: inline\n" |
| "", |
| "unknown key.")); |
| // Not a scalar. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: { File: a, Line: 1, Column: 2 }\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "", |
| "expected a value of scalar type.")); |
| // Not a string file in debug loc. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: { File: { a: b }, Column: 12, Line: 12 }\n" |
| "", |
| "expected a value of scalar type.")); |
| // Not a integer column in debug loc. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: { File: file.c, Column: { a: b }, Line: 12 }\n" |
| "", |
| "expected a value of scalar type.")); |
| // Not a integer line in debug loc. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: { File: file.c, Column: 12, Line: { a: b } }\n" |
| "", |
| "expected a value of scalar type.")); |
| // Not a mapping type value for args. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "DebugLoc: { File: file.c, Column: 12, Line: { a: b } }\n" |
| "", |
| "expected a value of scalar type.")); |
| } |
| |
| TEST(YAMLRemarks, ParsingWrongArgs) { |
| // Multiple debug locs per arg. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "Args:\n" |
| " - Str: string\n" |
| " DebugLoc: { File: a, Line: 1, Column: 2 }\n" |
| " DebugLoc: { File: a, Line: 1, Column: 2 }\n" |
| "", |
| "only one DebugLoc entry is allowed per argument.")); |
| // Multiple strings per arg. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "Args:\n" |
| " - Str: string\n" |
| " Str2: string\n" |
| " DebugLoc: { File: a, Line: 1, Column: 2 }\n" |
| "", |
| "only one string entry is allowed per argument.")); |
| // No arg value. |
| EXPECT_TRUE(parseExpectError("\n" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n" |
| "Args:\n" |
| " - DebugLoc: { File: a, Line: 1, Column: 2 }\n" |
| "", |
| "argument key is missing.")); |
| } |
| |
| 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(YAMLRemarks, 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(YAMLRemarks, ContentsCAPI) { |
| StringRef Buf = "\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" |
| "\n"; |
| |
| LLVMRemarkParserRef Parser = |
| LLVMRemarkParserCreateYAML(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); |
| } |
| |
| TEST(YAMLRemarks, ContentsStrTab) { |
| StringRef Buf = "\n" |
| "--- !Missed\n" |
| "Pass: 0\n" |
| "Name: 1\n" |
| "DebugLoc: { File: 2, Line: 3, Column: 12 }\n" |
| "Function: 3\n" |
| "Hotness: 4\n" |
| "Args:\n" |
| " - Callee: 5\n" |
| " - String: 7\n" |
| " - Caller: 3\n" |
| " DebugLoc: { File: 2, Line: 2, Column: 0 }\n" |
| " - String: 8\n" |
| "\n"; |
| |
| StringRef StrTabBuf = |
| StringRef("inline\0NoDefinition\0file.c\0foo\0Callee\0bar\0String\0 " |
| "will not be inlined into \0 because its definition is " |
| "unavailable", |
| 115); |
| |
| remarks::ParsedStringTable StrTab(StrTabBuf); |
| Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser = |
| remarks::createRemarkParser(remarks::Format::YAMLStrTab, Buf, |
| std::move(StrTab)); |
| 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. |
| } |
| |
| TEST(YAMLRemarks, ParsingBadStringTableIndex) { |
| StringRef Buf = "\n" |
| "--- !Missed\n" |
| "Pass: 50\n" |
| "\n"; |
| |
| StringRef StrTabBuf = StringRef("inline"); |
| |
| remarks::ParsedStringTable StrTab(StrTabBuf); |
| Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser = |
| remarks::createRemarkParser(remarks::Format::YAMLStrTab, Buf, |
| std::move(StrTab)); |
| EXPECT_FALSE(errorToBool(MaybeParser.takeError())); |
| EXPECT_TRUE(*MaybeParser != nullptr); |
| |
| remarks::RemarkParser &Parser = **MaybeParser; |
| Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next(); |
| EXPECT_FALSE(MaybeRemark); // Expect an error here. |
| |
| std::string ErrorStr; |
| raw_string_ostream Stream(ErrorStr); |
| handleAllErrors(MaybeRemark.takeError(), |
| [&](const ErrorInfoBase &EIB) { EIB.log(Stream); }); |
| EXPECT_TRUE( |
| StringRef(Stream.str()) |
| .contains("String with index 50 is out of bounds (size = 1).")); |
| } |
| |
| TEST(YAMLRemarks, ParsingGoodMeta) { |
| // No metadata should also work. |
| parseGoodMeta("--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n"); |
| |
| // No string table. |
| parseGoodMeta(StringRef("REMARKS\0" |
| "\0\0\0\0\0\0\0\0" |
| "\0\0\0\0\0\0\0\0" |
| "--- !Missed\n" |
| "Pass: inline\n" |
| "Name: NoDefinition\n" |
| "Function: foo\n", |
| 82)); |
| |
| // Use the string table from the metadata. |
| parseGoodMeta(StringRef("REMARKS\0" |
| "\0\0\0\0\0\0\0\0" |
| "\x02\0\0\0\0\0\0\0" |
| "a\0" |
| "--- !Missed\n" |
| "Pass: 0\n" |
| "Name: 0\n" |
| "Function: 0\n", |
| 66)); |
| } |
| |
| TEST(YAMLRemarks, ParsingBadMeta) { |
| parseExpectErrorMeta(StringRef("REMARKSS", 9), |
| "Expecting \\0 after magic number.", CmpType::Equal); |
| |
| parseExpectErrorMeta(StringRef("REMARKS\0", 8), "Expecting version number.", |
| CmpType::Equal); |
| |
| parseExpectErrorMeta(StringRef("REMARKS\0" |
| "\x09\0\0\0\0\0\0\0", |
| 16), |
| "Mismatching remark version. Got 9, expected 0.", |
| CmpType::Equal); |
| |
| parseExpectErrorMeta(StringRef("REMARKS\0" |
| "\0\0\0\0\0\0\0\0", |
| 16), |
| "Expecting string table size.", CmpType::Equal); |
| |
| parseExpectErrorMeta(StringRef("REMARKS\0" |
| "\0\0\0\0\0\0\0\0" |
| "\x01\0\0\0\0\0\0\0", |
| 24), |
| "Expecting string table.", CmpType::Equal); |
| |
| parseExpectErrorMeta(StringRef("REMARKS\0" |
| "\0\0\0\0\0\0\0\0" |
| "\0\0\0\0\0\0\0\0" |
| "/path/", |
| 30), |
| "'/path/'", CmpType::Contains); |
| |
| parseExpectErrorMeta(StringRef("REMARKS\0" |
| "\0\0\0\0\0\0\0\0" |
| "\0\0\0\0\0\0\0\0" |
| "/path/", |
| 30), |
| "'/baddir/path/'", CmpType::Contains, |
| StringRef("/baddir/")); |
| } |
