| //===- 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]) { |
| remarks::Parser Parser({Buf, N - 1}); |
| Expected<const remarks::Remark *> Remark = Parser.getNext(); |
| EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors. |
| EXPECT_TRUE(*Remark != nullptr); // At least one remark. |
| Remark = Parser.getNext(); |
| EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors. |
| EXPECT_TRUE(*Remark == nullptr); // Check that there are no more remarks. |
| } |
| |
| template <size_t N> |
| bool parseExpectError(const char (&Buf)[N], const char *Error) { |
| remarks::Parser Parser({Buf, N - 1}); |
| Expected<const remarks::Remark *> Remark = Parser.getNext(); |
| EXPECT_FALSE(Remark); // Expect an error here. |
| |
| std::string ErrorStr; |
| raw_string_ostream Stream(ErrorStr); |
| handleAllErrors(Remark.takeError(), |
| [&](const ErrorInfoBase &EIB) { EIB.log(Stream); }); |
| return StringRef(Stream.str()).contains(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", "not a valid YAML file.")); |
| } |
| |
| 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" |
| " - Callee: ''\n" |
| " - DebugLoc: { File: a, Line: 1, Column: 2 }\n" |
| "", |
| "argument value is missing.")); |
| // 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"; |
| |
| remarks::Parser Parser(Buf); |
| Expected<const remarks::Remark *> RemarkOrErr = Parser.getNext(); |
| EXPECT_FALSE(errorToBool(RemarkOrErr.takeError())); |
| EXPECT_TRUE(*RemarkOrErr != nullptr); |
| |
| const remarks::Remark &Remark = **RemarkOrErr; |
| 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; |
| } |
| |
| RemarkOrErr = Parser.getNext(); |
| EXPECT_FALSE(errorToBool(RemarkOrErr.takeError())); |
| EXPECT_EQ(*RemarkOrErr, nullptr); |
| } |
| |
| 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))); |
| |
| EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr); |
| |
| EXPECT_FALSE(LLVMRemarkParserHasError(Parser)); |
| LLVMRemarkParserDispose(Parser); |
| } |
