unittests/Analysis/AliasAnalysisTest.cpp

   1 //===--- AliasAnalysisTest.cpp - Mixed TBAA unit tests --------------------===//
   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/Analysis/AliasAnalysis.h"
  11 #include "llvm/Analysis/BasicAliasAnalysis.h"
  12 #include "llvm/Analysis/Passes.h"
  13 #include "llvm/IR/Constants.h"
  14 #include "llvm/IR/Instructions.h"
  15 #include "llvm/IR/LLVMContext.h"
  16 #include "llvm/IR/Module.h"
  17 #include "llvm/IR/LegacyPassManager.h"
  18 #include "llvm/Support/CommandLine.h"
  19 #include "gtest/gtest.h"
  20
  21 namespace llvm {
  22 namespace {
  23
  24 class AliasAnalysisTest : public testing::Test {
  25 protected:
  26   AliasAnalysisTest() : M("AliasAnalysisTBAATest", C) {}
  27
  28   // This is going to check that calling getModRefInfo without a location, and
  29   // with a default location, first, doesn't crash, and second, gives the right
  30   // answer.
  31   void CheckModRef(Instruction *I, ModRefInfo Result) {
  32     static char ID;
  33     class CheckModRefTestPass : public FunctionPass {
  34     public:
  35       CheckModRefTestPass(Instruction *I, ModRefInfo Result)
  36           : FunctionPass(ID), ExpectResult(Result), I(I) {}
  37       static int initialize() {
  38         PassInfo *PI = new PassInfo("CheckModRef testing pass", "", &ID,
  39                                     nullptr, true, true);
  40         PassRegistry::getPassRegistry()->registerPass(*PI, false);
  41         initializeAliasAnalysisAnalysisGroup(*PassRegistry::getPassRegistry());
  42         initializeBasicAliasAnalysisPass(*PassRegistry::getPassRegistry());
  43         return 0;
  44       }
  45       void getAnalysisUsage(AnalysisUsage &AU) const override {
  46         AU.setPreservesAll();
  47         AU.addRequiredTransitive<AliasAnalysis>();
  48       }
  49       bool runOnFunction(Function &) override {
  50         AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
  51         EXPECT_EQ(AA.getModRefInfo(I, MemoryLocation()), ExpectResult);
  52         EXPECT_EQ(AA.getModRefInfo(I), ExpectResult);
  53         return false;
  54       }
  55       ModRefInfo ExpectResult;
  56       Instruction *I;
  57     };
  58     static int initialize = CheckModRefTestPass::initialize();
  59     (void)initialize;
  60     CheckModRefTestPass *P = new CheckModRefTestPass(I, Result);
  61     legacy::PassManager PM;
  62     PM.add(createBasicAliasAnalysisPass());
  63     PM.add(P);
  64     PM.run(M);
  65   }
  66
  67   LLVMContext C;
  68   Module M;
  69 };
  70
  71 TEST_F(AliasAnalysisTest, getModRefInfo) {
  72   // Setup function.
  73   FunctionType *FTy =
  74       FunctionType::get(Type::getVoidTy(C), std::vector<Type *>(), false);
  75   auto *F = cast<Function>(M.getOrInsertFunction("f", FTy));
  76   auto *BB = BasicBlock::Create(C, "entry", F);
  77   auto IntType = Type::getInt32Ty(C);
  78   auto PtrType = Type::getInt32PtrTy(C);
  79   auto *Value = ConstantInt::get(IntType, 42);
  80   auto *Addr = ConstantPointerNull::get(PtrType);
  81
  82   auto *Store1 = new StoreInst(Value, Addr, BB);
  83   auto *Load1 = new LoadInst(Addr, "load", BB);
  84   auto *Add1 = BinaryOperator::CreateAdd(Value, Value, "add", BB);
  85   auto *VAArg1 = new VAArgInst(Addr, PtrType, "vaarg", BB);
  86   auto *CmpXChg1 = new AtomicCmpXchgInst(Addr, ConstantInt::get(IntType, 0),
  87                                          ConstantInt::get(IntType, 1),
  88                                          Monotonic, Monotonic, CrossThread, BB);
  89   auto *AtomicRMW =
  90       new AtomicRMWInst(AtomicRMWInst::Xchg, Addr, ConstantInt::get(IntType, 1),
  91                         Monotonic, CrossThread, BB);
  92
  93   ReturnInst::Create(C, nullptr, BB);
  94
  95   // Check basic results
  96   CheckModRef(Store1, MRI_Mod);
  97   CheckModRef(Load1, MRI_Ref);
  98   CheckModRef(Add1, MRI_NoModRef);
  99   CheckModRef(VAArg1, MRI_ModRef);
 100   CheckModRef(CmpXChg1, MRI_ModRef);
 101   CheckModRef(AtomicRMW, MRI_ModRef);
 102 }
 103
 104 } // end anonymous namspace
 105 } // end llvm namespace