unittests/Transforms/Utils/SpecialCaseList.cpp

   1 //===- SpecialCaseList.cpp - Unit tests for SpecialCaseList ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/IR/Function.h"
  11 #include "llvm/IR/LLVMContext.h"
  12 #include "llvm/IR/Module.h"
  13 #include "llvm/Support/MemoryBuffer.h"
  14 #include "llvm/Transforms/Utils/SpecialCaseList.h"
  15 #include "gtest/gtest.h"
  16
  17 using namespace llvm;
  18
  19 namespace {
  20
  21 class SpecialCaseListTest : public ::testing::Test {
  22 protected:
  23   Function *makeFunction(StringRef Name, Module &M) {
  24     return Function::Create(FunctionType::get(Type::getVoidTy(Ctx), false),
  25                             GlobalValue::ExternalLinkage,
  26                             Name,
  27                             &M);
  28   }
  29
  30   GlobalVariable *makeGlobal(StringRef Name, StringRef StructName, Module &M) {
  31     StructType *ST =
  32         StructType::create(StructName, Type::getInt32Ty(Ctx), (Type*)0);
  33     return new GlobalVariable(
  34         M, ST, false, GlobalValue::ExternalLinkage, 0, Name);
  35   }
  36
  37   GlobalAlias *makeAlias(StringRef Name, GlobalValue *Aliasee) {
  38     return new GlobalAlias(Aliasee->getType(), GlobalValue::ExternalLinkage,
  39                            Name, Aliasee, Aliasee->getParent());
  40   }
  41
  42   SpecialCaseList *makeSpecialCaseList(StringRef List, std::string &Error) {
  43     std::unique_ptr<MemoryBuffer> MB(MemoryBuffer::getMemBuffer(List));
  44     return SpecialCaseList::create(MB.get(), Error);
  45   }
  46
  47   SpecialCaseList *makeSpecialCaseList(StringRef List) {
  48     std::string Error;
  49     SpecialCaseList *SCL = makeSpecialCaseList(List, Error);
  50     assert(SCL);
  51     assert(Error == "");
  52     return SCL;
  53   }
  54
  55   LLVMContext Ctx;
  56 };
  57
  58 TEST_F(SpecialCaseListTest, ModuleIsIn) {
  59   Module M("hello", Ctx);
  60   Function *F = makeFunction("foo", M);
  61   GlobalVariable *GV = makeGlobal("bar", "t", M);
  62
  63   std::unique_ptr<SpecialCaseList> SCL(
  64       makeSpecialCaseList("# This is a comment.\n"
  65                           "\n"
  66                           "src:hello\n"));
  67   EXPECT_TRUE(SCL->isIn(M));
  68   EXPECT_TRUE(SCL->isIn(*F));
  69   EXPECT_TRUE(SCL->isIn(*GV));
  70
  71   SCL.reset(makeSpecialCaseList("src:he*o\n"));
  72   EXPECT_TRUE(SCL->isIn(M));
  73   EXPECT_TRUE(SCL->isIn(*F));
  74   EXPECT_TRUE(SCL->isIn(*GV));
  75
  76   SCL.reset(makeSpecialCaseList("src:hi\n"));
  77   EXPECT_FALSE(SCL->isIn(M));
  78   EXPECT_FALSE(SCL->isIn(*F));
  79   EXPECT_FALSE(SCL->isIn(*GV));
  80 }
  81
  82 TEST_F(SpecialCaseListTest, FunctionIsIn) {
  83   Module M("hello", Ctx);
  84   Function *Foo = makeFunction("foo", M);
  85   Function *Bar = makeFunction("bar", M);
  86
  87   std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList("fun:foo\n"));
  88   EXPECT_TRUE(SCL->isIn(*Foo));
  89   EXPECT_FALSE(SCL->isIn(*Bar));
  90
  91   SCL.reset(makeSpecialCaseList("fun:b*\n"));
  92   EXPECT_FALSE(SCL->isIn(*Foo));
  93   EXPECT_TRUE(SCL->isIn(*Bar));
  94
  95   SCL.reset(makeSpecialCaseList("fun:f*\n"
  96                                 "fun:bar\n"));
  97   EXPECT_TRUE(SCL->isIn(*Foo));
  98   EXPECT_TRUE(SCL->isIn(*Bar));
  99
 100   SCL.reset(makeSpecialCaseList("fun:foo=functional\n"));
 101   EXPECT_TRUE(SCL->isIn(*Foo, "functional"));
 102   StringRef Category;
 103   EXPECT_FALSE(SCL->isIn(*Bar, "functional"));
 104 }
 105
 106 TEST_F(SpecialCaseListTest, GlobalIsIn) {
 107   Module M("hello", Ctx);
 108   GlobalVariable *Foo = makeGlobal("foo", "t1", M);
 109   GlobalVariable *Bar = makeGlobal("bar", "t2", M);
 110
 111   std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList("global:foo\n"));
 112   EXPECT_TRUE(SCL->isIn(*Foo));
 113   EXPECT_FALSE(SCL->isIn(*Bar));
 114   EXPECT_FALSE(SCL->isIn(*Foo, "init"));
 115   EXPECT_FALSE(SCL->isIn(*Bar, "init"));
 116
 117   SCL.reset(makeSpecialCaseList("global:foo=init\n"));
 118   EXPECT_FALSE(SCL->isIn(*Foo));
 119   EXPECT_FALSE(SCL->isIn(*Bar));
 120   EXPECT_TRUE(SCL->isIn(*Foo, "init"));
 121   EXPECT_FALSE(SCL->isIn(*Bar, "init"));
 122
 123   SCL.reset(makeSpecialCaseList("global-init:foo\n"));
 124   EXPECT_FALSE(SCL->isIn(*Foo));
 125   EXPECT_FALSE(SCL->isIn(*Bar));
 126   EXPECT_TRUE(SCL->isIn(*Foo, "init"));
 127   EXPECT_FALSE(SCL->isIn(*Bar, "init"));
 128
 129   SCL.reset(makeSpecialCaseList("type:t2=init\n"));
 130   EXPECT_FALSE(SCL->isIn(*Foo));
 131   EXPECT_FALSE(SCL->isIn(*Bar));
 132   EXPECT_FALSE(SCL->isIn(*Foo, "init"));
 133   EXPECT_TRUE(SCL->isIn(*Bar, "init"));
 134
 135   SCL.reset(makeSpecialCaseList("global-init-type:t2\n"));
 136   EXPECT_FALSE(SCL->isIn(*Foo));
 137   EXPECT_FALSE(SCL->isIn(*Bar));
 138   EXPECT_FALSE(SCL->isIn(*Foo, "init"));
 139   EXPECT_TRUE(SCL->isIn(*Bar, "init"));
 140
 141   SCL.reset(makeSpecialCaseList("src:hello=init\n"));
 142   EXPECT_FALSE(SCL->isIn(*Foo));
 143   EXPECT_FALSE(SCL->isIn(*Bar));
 144   EXPECT_TRUE(SCL->isIn(*Foo, "init"));
 145   EXPECT_TRUE(SCL->isIn(*Bar, "init"));
 146
 147   SCL.reset(makeSpecialCaseList("global-init-src:hello\n"));
 148   EXPECT_FALSE(SCL->isIn(*Foo));
 149   EXPECT_FALSE(SCL->isIn(*Bar));
 150   EXPECT_TRUE(SCL->isIn(*Foo, "init"));
 151   EXPECT_TRUE(SCL->isIn(*Bar, "init"));
 152 }
 153
 154 TEST_F(SpecialCaseListTest, AliasIsIn) {
 155   Module M("hello", Ctx);
 156   Function *Foo = makeFunction("foo", M);
 157   GlobalVariable *Bar = makeGlobal("bar", "t", M);
 158   GlobalAlias *FooAlias = makeAlias("fooalias", Foo);
 159   GlobalAlias *BarAlias = makeAlias("baralias", Bar);
 160
 161   std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList("fun:foo\n"));
 162   EXPECT_FALSE(SCL->isIn(*FooAlias));
 163   EXPECT_FALSE(SCL->isIn(*BarAlias));
 164
 165   SCL.reset(makeSpecialCaseList("global:bar\n"));
 166   EXPECT_FALSE(SCL->isIn(*FooAlias));
 167   EXPECT_FALSE(SCL->isIn(*BarAlias));
 168
 169   SCL.reset(makeSpecialCaseList("global:fooalias\n"));
 170   EXPECT_FALSE(SCL->isIn(*FooAlias));
 171   EXPECT_FALSE(SCL->isIn(*BarAlias));
 172
 173   SCL.reset(makeSpecialCaseList("fun:fooalias\n"));
 174   EXPECT_TRUE(SCL->isIn(*FooAlias));
 175   EXPECT_FALSE(SCL->isIn(*BarAlias));
 176
 177   SCL.reset(makeSpecialCaseList("global:baralias=init\n"));
 178   EXPECT_FALSE(SCL->isIn(*FooAlias, "init"));
 179   EXPECT_TRUE(SCL->isIn(*BarAlias, "init"));
 180
 181   SCL.reset(makeSpecialCaseList("type:t=init\n"));
 182   EXPECT_FALSE(SCL->isIn(*FooAlias, "init"));
 183   EXPECT_TRUE(SCL->isIn(*BarAlias, "init"));
 184
 185   SCL.reset(makeSpecialCaseList("fun:baralias=init\n"));
 186   EXPECT_FALSE(SCL->isIn(*FooAlias, "init"));
 187   EXPECT_FALSE(SCL->isIn(*BarAlias, "init"));
 188 }
 189
 190 TEST_F(SpecialCaseListTest, Substring) {
 191   Module M("othello", Ctx);
 192   Function *F = makeFunction("tomfoolery", M);
 193   GlobalVariable *GV = makeGlobal("bartender", "t", M);
 194   GlobalAlias *GA1 = makeAlias("buffoonery", F);
 195   GlobalAlias *GA2 = makeAlias("foobar", GV);
 196
 197   std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList("src:hello\n"
 198                                                            "fun:foo\n"
 199                                                            "global:bar\n"));
 200   EXPECT_FALSE(SCL->isIn(M));
 201   EXPECT_FALSE(SCL->isIn(*F));
 202   EXPECT_FALSE(SCL->isIn(*GV));
 203   EXPECT_FALSE(SCL->isIn(*GA1));
 204   EXPECT_FALSE(SCL->isIn(*GA2));
 205
 206   SCL.reset(makeSpecialCaseList("fun:*foo*\n"));
 207   EXPECT_TRUE(SCL->isIn(*F));
 208   EXPECT_TRUE(SCL->isIn(*GA1));
 209 }
 210
 211 TEST_F(SpecialCaseListTest, InvalidSpecialCaseList) {
 212   std::string Error;
 213   EXPECT_EQ(0, makeSpecialCaseList("badline", Error));
 214   EXPECT_EQ("Malformed line 1: 'badline'", Error);
 215   EXPECT_EQ(0, makeSpecialCaseList("src:bad[a-", Error));
 216   EXPECT_EQ("Malformed regex in line 1: 'bad[a-': invalid character range",
 217             Error);
 218   EXPECT_EQ(0, makeSpecialCaseList("src:a.c\n"
 219                                    "fun:fun(a\n",
 220                                    Error));
 221   EXPECT_EQ("Malformed regex in line 2: 'fun(a': parentheses not balanced",
 222             Error);
 223   EXPECT_EQ(0, SpecialCaseList::create("unexisting", Error));
 224   EXPECT_EQ(0U, Error.find("Can't open file 'unexisting':"));
 225 }
 226
 227 TEST_F(SpecialCaseListTest, EmptySpecialCaseList) {
 228   std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList(""));
 229   Module M("foo", Ctx);
 230   EXPECT_FALSE(SCL->isIn(M));
 231 }
 232
 233 }