llvm/unittests/Remarks/RemarksLinkingTest.cpp

   1 //===- unittest/Support/RemarksLinkingTest.cpp - Linking 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/Bitcode/BitcodeAnalyzer.h"
  10 #include "llvm/Remarks/RemarkLinker.h"
  11 #include "llvm/Remarks/RemarkSerializer.h"
  12 #include "llvm/Support/raw_ostream.h"
  13 #include "gtest/gtest.h"
  14 #include <string>
  15
  16 using namespace llvm;
  17
  18 static void serializeAndCheck(remarks::RemarkLinker &RL,
  19                               remarks::Format OutputFormat,
  20                               StringRef ExpectedOutput) {
  21   // 1. Create a serializer.
  22   // 2. Serialize all the remarks from the linker.
  23   // 3. Check that it matches the output.
  24   std::string Buf;
  25   raw_string_ostream OS(Buf);
  26   Error E = RL.serialize(OS, OutputFormat);
  27   EXPECT_FALSE(static_cast<bool>(E));
  28
  29   // For bitstream, run it through the analyzer.
  30   if (OutputFormat == remarks::Format::Bitstream) {
  31     std::string AnalyzeBuf;
  32     raw_string_ostream AnalyzeOS(AnalyzeBuf);
  33     BCDumpOptions O(AnalyzeOS);
  34     O.ShowBinaryBlobs = true;
  35     BitcodeAnalyzer BA(OS.str());
  36     EXPECT_FALSE(BA.analyze(O)); // Expect no errors.
  37     EXPECT_EQ(AnalyzeOS.str(), ExpectedOutput);
  38   } else {
  39     EXPECT_EQ(OS.str(), ExpectedOutput);
  40   }
  41 }
  42
  43 static void check(remarks::Format InputFormat, StringRef Input,
  44                   remarks::Format OutputFormat, StringRef ExpectedOutput) {
  45   remarks::RemarkLinker RL;
  46   EXPECT_FALSE(RL.link(Input, InputFormat));
  47   serializeAndCheck(RL, OutputFormat, ExpectedOutput);
  48 }
  49
  50 static void check(remarks::Format InputFormat, StringRef Input,
  51                   remarks::Format InputFormat2, StringRef Input2,
  52                   remarks::Format OutputFormat, StringRef ExpectedOutput) {
  53   remarks::RemarkLinker RL;
  54   EXPECT_FALSE(RL.link(Input, InputFormat));
  55   EXPECT_FALSE(RL.link(Input2, InputFormat2));
  56   serializeAndCheck(RL, OutputFormat, ExpectedOutput);
  57 }
  58
  59 TEST(Remarks, LinkingGoodYAML) {
  60   // One YAML remark.
  61   check(remarks::Format::YAML,
  62         "--- !Missed\n"
  63         "Pass:            inline\n"
  64         "Name:            NoDefinition\n"
  65         "DebugLoc:        { File: file.c, Line: 3, Column: 12 }\n"
  66         "Function:        foo\n"
  67         "...\n",
  68         remarks::Format::YAML,
  69         "--- !Missed\n"
  70         "Pass:            inline\n"
  71         "Name:            NoDefinition\n"
  72         "DebugLoc:        { File: file.c, Line: 3, Column: 12 }\n"
  73         "Function:        foo\n"
  74         "...\n");
  75
  76   // Check that we don't keep remarks without debug locations.
  77   check(remarks::Format::YAML,
  78         "--- !Missed\n"
  79         "Pass:            inline\n"
  80         "Name:            NoDefinition\n"
  81         "Function:        foo\n"
  82         "...\n",
  83         remarks::Format::YAML, "");
  84
  85   // Check that we deduplicate remarks.
  86   check(remarks::Format::YAML,
  87         "--- !Missed\n"
  88         "Pass:            inline\n"
  89         "Name:            NoDefinition\n"
  90         "DebugLoc:        { File: file.c, Line: 3, Column: 12 }\n"
  91         "Function:        foo\n"
  92         "...\n"
  93         "--- !Missed\n"
  94         "Pass:            inline\n"
  95         "Name:            NoDefinition\n"
  96         "DebugLoc:        { File: file.c, Line: 3, Column: 12 }\n"
  97         "Function:        foo\n"
  98         "...\n",
  99         remarks::Format::YAML,
 100         "--- !Missed\n"
 101         "Pass:            inline\n"
 102         "Name:            NoDefinition\n"
 103         "DebugLoc:        { File: file.c, Line: 3, Column: 12 }\n"
 104         "Function:        foo\n"
 105         "...\n");
 106 }
 107
 108 TEST(Remarks, LinkingGoodBitstream) {
 109   // One YAML remark.
 110   check(remarks::Format::YAML,
 111         "--- !Missed\n"
 112         "Pass:            inline\n"
 113         "Name:            NoDefinition\n"
 114         "DebugLoc:        { File: file.c, Line: 3, Column: 12 }\n"
 115         "Function:        foo\n"
 116         "...\n",
 117         remarks::Format::Bitstream,
 118         "<BLOCKINFO_BLOCK/>\n"
 119         "<Meta BlockID=8 NumWords=12 BlockCodeSize=3>\n"
 120         "  <Container info codeid=1 abbrevid=4 op0=0 op1=2/>\n"
 121         "  <Remark version codeid=2 abbrevid=5 op0=0/>\n"
 122         "  <String table codeid=3 abbrevid=6/> blob data = "
 123         "'inline\\x00NoDefinition\\x00foo\\x00file.c\\x00'\n"
 124         "</Meta>\n"
 125         "<Remark BlockID=9 NumWords=4 BlockCodeSize=4>\n"
 126         "  <Remark header codeid=5 abbrevid=4 op0=2 op1=1 op2=0 op3=2/>\n"
 127         "  <Remark debug location codeid=6 abbrevid=5 op0=3 op1=3 op2=12/>\n"
 128         "</Remark>\n");
 129
 130   // Check that we deduplicate remarks.
 131   check(remarks::Format::YAML,
 132         "--- !Missed\n"
 133         "Pass:            inline\n"
 134         "Name:            NoDefinition\n"
 135         "DebugLoc:        { File: file.c, Line: 3, Column: 12 }\n"
 136         "Function:        foo\n"
 137         "...\n"
 138         "--- !Missed\n"
 139         "Pass:            inline\n"
 140         "Name:            NoDefinition\n"
 141         "DebugLoc:        { File: file.c, Line: 3, Column: 12 }\n"
 142         "Function:        foo\n"
 143         "...\n",
 144         remarks::Format::Bitstream,
 145         "<BLOCKINFO_BLOCK/>\n"
 146         "<Meta BlockID=8 NumWords=12 BlockCodeSize=3>\n"
 147         "  <Container info codeid=1 abbrevid=4 op0=0 op1=2/>\n"
 148         "  <Remark version codeid=2 abbrevid=5 op0=0/>\n"
 149         "  <String table codeid=3 abbrevid=6/> blob data = "
 150         "'inline\\x00NoDefinition\\x00foo\\x00file.c\\x00'\n"
 151         "</Meta>\n"
 152         "<Remark BlockID=9 NumWords=4 BlockCodeSize=4>\n"
 153         "  <Remark header codeid=5 abbrevid=4 op0=2 op1=1 op2=0 op3=2/>\n"
 154         "  <Remark debug location codeid=6 abbrevid=5 op0=3 op1=3 op2=12/>\n"
 155         "</Remark>\n");
 156 }
 157
 158 TEST(Remarks, LinkingGoodStrTab) {
 159   // Check that remarks from different entries use the same strtab.
 160   check(remarks::Format::YAML,
 161         "--- !Missed\n"
 162         "Pass:            inline\n"
 163         "Name:            NoDefinition\n"
 164         "DebugLoc:        { File: file.c, Line: 3, Column: 12 }\n"
 165         "Function:        foo\n"
 166         "...\n",
 167         remarks::Format::YAML,
 168         "--- !Passed\n"
 169         "Pass:            inline\n"
 170         "Name:            Ok\n"
 171         "DebugLoc:        { File: file.c, Line: 3, Column: 12 }\n"
 172         "Function:        foo\n"
 173         "...\n",
 174         remarks::Format::YAMLStrTab,
 175         StringRef("REMARKS\0\0\0\0\0\0\0\0\0\x22\0\0\0\0\0\0\0"
 176                   "inline\0NoDefinition\0foo\0file.c\0Ok\0"
 177                   "--- !Passed\n"
 178                   "Pass:            0\n"
 179                   "Name:            4\n"
 180                   "DebugLoc:        { File: 3, Line: 3, Column: 12 }\n"
 181                   "Function:        2\n"
 182                   "...\n"
 183                   "--- !Missed\n"
 184                   "Pass:            0\n"
 185                   "Name:            1\n"
 186                   "DebugLoc:        { File: 3, Line: 3, Column: 12 }\n"
 187                   "Function:        2\n"
 188                   "...\n",
 189                   304));
 190 }
 191
 192 // Check that we propagate parsing errors.
 193 TEST(Remarks, LinkingError) {
 194   remarks::RemarkLinker RL;
 195   {
 196     Error E = RL.link("badyaml", remarks::Format::YAML);
 197     EXPECT_TRUE(static_cast<bool>(E));
 198     EXPECT_EQ(toString(std::move(E)),
 199               "YAML:1:1: error: document root is not of mapping type.\n"
 200               "\n"
 201               "badyaml\n"
 202               "^~~~~~~\n"
 203               "\n");
 204   }
 205
 206   {
 207     // Check that the prepend path is propagated and fails with the full path.
 208     RL.setExternalFilePrependPath("/baddir/");
 209     Error E = RL.link(
 210         StringRef("REMARKS\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0badfile.opt.yaml",
 211                   40),
 212         remarks::Format::YAMLStrTab);
 213     EXPECT_TRUE(static_cast<bool>(E));
 214     std::string ErrorMessage = toString(std::move(E));
 215     EXPECT_EQ(StringRef(ErrorMessage).lower(),
 216               StringRef("'/baddir/badfile.opt.yaml': No such file or directory")
 217                   .lower());
 218   }
 219 }