[OptRemarks] Make OptRemarks more generic: rename OptRemarks to Remarks

Getting rid of the name "optimization remarks" for anything that
involves handling remarks on the client side.

It's safer to do this now, before we get stuck with that name in all the
APIs and public interfaces we decide to export to users in the future.

This renames llvm/tools/opt-remarks to llvm/tools/remarks-shlib, and now
generates `libRemarks.dylib` instead of `libOptRemarks.dylib`.

Differential Revision: https://reviews.llvm.org/D58535

llvm-svn: 355439

1 files changed, 436 insertions, 0 deletions

diff --git a/llvm/unittests/Remarks/RemarksParsingTest.cpp b/llvm/unittests/Remarks/RemarksParsingTest.cpp
new file mode 100644
index 00000000000..a167b8318a4
--- /dev/null
+++ b/llvm/unittests/Remarks/RemarksParsingTest.cpp
@@ -0,0 +1,436 @@
+//===- unittest/Support/RemarksParsingTest.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 "gtest/gtest.h"
+
+using namespace llvm;
+
+template <size_t N> bool tryParse(const char (&Buf)[N]) {
+  LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf, N - 1);
+  LLVMRemarkEntry *Remark = nullptr;
+  while (LLVMRemarkEntry *NewRemark = LLVMRemarkParserGetNext(Parser)) {
+    EXPECT_TRUE(Remark == nullptr); // Only one remark per test.
+    Remark = NewRemark;
+  }
+  EXPECT_TRUE(Remark != nullptr); // We need *exactly* one remark per test.
+  bool HasError = LLVMRemarkParserHasError(Parser);
+  LLVMRemarkParserDispose(Parser);
+  return !HasError;
+}
+
+template <size_t N>
+bool parseExpectError(const char (&Buf)[N], const char *Error) {
+  LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf, N - 1);
+  LLVMRemarkEntry *Remark = nullptr;
+  while (LLVMRemarkEntry *NewRemark = LLVMRemarkParserGetNext(Parser)) {
+    EXPECT_FALSE(NewRemark);
+  }
+  EXPECT_TRUE(Remark == nullptr); // We are parsing only one malformed remark.
+  EXPECT_TRUE(LLVMRemarkParserHasError(Parser));
+  bool MatchesError =
+      StringRef(LLVMRemarkParserGetErrorMessage(Parser)).contains(Error);
+  LLVMRemarkParserDispose(Parser);
+
+  return MatchesError;
+}
+
+TEST(Remarks, RemarksParsingEmpty) {
+  StringRef Buf = "\n"
+                  "\n";
+  LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf.data(), Buf.size());
+  LLVMRemarkEntry *NewRemark = LLVMRemarkParserGetNext(Parser);
+  EXPECT_TRUE(NewRemark == nullptr); // No remark expected.
+  EXPECT_TRUE(LLVMRemarkParserHasError(Parser));
+  EXPECT_TRUE(StringRef(LLVMRemarkParserGetErrorMessage(Parser))
+                  .contains("document root is not of mapping type."));
+  LLVMRemarkParserDispose(Parser);
+}
+
+TEST(Remarks, RemarksParsingGood) {
+  EXPECT_TRUE(tryParse("\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.
+  EXPECT_TRUE(tryParse("\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.
+  EXPECT_TRUE(tryParse("\n"
+                       "--- !Missed\n"
+                       "Pass: inline\n"
+                       "Name: NoDefinition\n"
+                       "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
+                       "Function: foo\n"
+                       ""));
+
+  // Different order.
+  EXPECT_TRUE(tryParse("\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(Remarks, RemarksParsingTypes) {
+  // Type: Passed
+  EXPECT_TRUE(tryParse("--- !Passed" COMMON_REMARK));
+  // Type: Missed
+  EXPECT_TRUE(tryParse("--- !Missed" COMMON_REMARK));
+  // Type: Analysis
+  EXPECT_TRUE(tryParse("--- !Analysis" COMMON_REMARK));
+  // Type: AnalysisFPCompute
+  EXPECT_TRUE(tryParse("--- !AnalysisFPCompute" COMMON_REMARK));
+  // Type: AnalysisAliasing
+  EXPECT_TRUE(tryParse("--- !AnalysisAliasing" COMMON_REMARK));
+  // Type: Failure
+  EXPECT_TRUE(tryParse("--- !Failure" COMMON_REMARK));
+}
+#undef COMMON_REMARK
+
+TEST(Remarks, RemarksParsingMissingFields) {
+  // No type.
+  EXPECT_TRUE(parseExpectError("\n"
+                               "---\n"
+                               "Pass: inline\n"
+                               "Name: NoDefinition\n"
+                               "Function: foo\n"
+                               "",
+                               "error: Type, Pass, Name or Function missing."));
+  // No pass.
+  EXPECT_TRUE(parseExpectError("\n"
+                               "--- !Missed\n"
+                               "Name: NoDefinition\n"
+                               "Function: foo\n"
+                               "",
+                               "error: Type, Pass, Name or Function missing."));
+  // No name.
+  EXPECT_TRUE(parseExpectError("\n"
+                               "--- !Missed\n"
+                               "Pass: inline\n"
+                               "Function: foo\n"
+                               "",
+                               "error: Type, Pass, Name or Function missing."));
+  // No function.
+  EXPECT_TRUE(parseExpectError("\n"
+                               "--- !Missed\n"
+                               "Pass: inline\n"
+                               "Name: NoDefinition\n"
+                               "",
+                               "error: 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(Remarks, RemarksParsingWrongTypes) {
+  // 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(Remarks, RemarksParsingWrongArgs) {
+  // 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."));
+}
+
+TEST(Remarks, RemarksGoodStruct) {
+  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 = LLVMRemarkParserCreate(Buf.data(), Buf.size());
+  LLVMRemarkEntry *Remark = LLVMRemarkParserGetNext(Parser);
+  EXPECT_FALSE(Remark == nullptr);
+  EXPECT_EQ(StringRef(Remark->RemarkType.Str, 7), "!Missed");
+  EXPECT_EQ(Remark->RemarkType.Len, 7U);
+  EXPECT_EQ(StringRef(Remark->PassName.Str, 6), "inline");
+  EXPECT_EQ(Remark->PassName.Len, 6U);
+  EXPECT_EQ(StringRef(Remark->RemarkName.Str, 12), "NoDefinition");
+  EXPECT_EQ(Remark->RemarkName.Len, 12U);
+  EXPECT_EQ(StringRef(Remark->FunctionName.Str, 3), "foo");
+  EXPECT_EQ(Remark->FunctionName.Len, 3U);
+  EXPECT_EQ(StringRef(Remark->DebugLoc.SourceFile.Str, 6), "file.c");
+  EXPECT_EQ(Remark->DebugLoc.SourceFile.Len, 6U);
+  EXPECT_EQ(Remark->DebugLoc.SourceLineNumber, 3U);
+  EXPECT_EQ(Remark->DebugLoc.SourceColumnNumber, 12U);
+  EXPECT_EQ(Remark->Hotness, 0U);
+  EXPECT_EQ(Remark->NumArgs, 4U);
+  // Arg 0
+  {
+    LLVMRemarkArg &Arg = Remark->Args[0];
+    EXPECT_EQ(StringRef(Arg.Key.Str, 6), "Callee");
+    EXPECT_EQ(Arg.Key.Len, 6U);
+    EXPECT_EQ(StringRef(Arg.Value.Str, 3), "bar");
+    EXPECT_EQ(Arg.Value.Len, 3U);
+    EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 0), "");
+    EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 0U);
+    EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 0U);
+    EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
+  }
+  // Arg 1
+  {
+    LLVMRemarkArg &Arg = Remark->Args[1];
+    EXPECT_EQ(StringRef(Arg.Key.Str, 6), "String");
+    EXPECT_EQ(Arg.Key.Len, 6U);
+    EXPECT_EQ(StringRef(Arg.Value.Str, 26), " will not be inlined into ");
+    EXPECT_EQ(Arg.Value.Len, 26U);
+    EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 0), "");
+    EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 0U);
+    EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 0U);
+    EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
+  }
+  // Arg 2
+  {
+    LLVMRemarkArg &Arg = Remark->Args[2];
+    EXPECT_EQ(StringRef(Arg.Key.Str, 6), "Caller");
+    EXPECT_EQ(Arg.Key.Len, 6U);
+    EXPECT_EQ(StringRef(Arg.Value.Str, 3), "foo");
+    EXPECT_EQ(Arg.Value.Len, 3U);
+    EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 6), "file.c");
+    EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 6U);
+    EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 2U);
+    EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
+  }
+  // Arg 3
+  {
+    LLVMRemarkArg &Arg = Remark->Args[3];
+    EXPECT_EQ(StringRef(Arg.Key.Str, 6), "String");
+    EXPECT_EQ(Arg.Key.Len, 6U);
+    EXPECT_EQ(StringRef(Arg.Value.Str, 38),
+              " because its definition is unavailable");
+    EXPECT_EQ(Arg.Value.Len, 38U);
+    EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 0), "");
+    EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 0U);
+    EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 0U);
+    EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
+  }
+
+  EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr);
+
+  EXPECT_FALSE(LLVMRemarkParserHasError(Parser));
+  LLVMRemarkParserDispose(Parser);
+}