unittests/Analysis/AliasAnalysisTest.cpp

   1 //===--- AliasAnalysisTest.cpp - Mixed TBAA unit 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/Analysis/AliasAnalysis.h"
  10 #include "llvm/ADT/SetVector.h"
  11 #include "llvm/Analysis/AssumptionCache.h"
  12 #include "llvm/Analysis/BasicAliasAnalysis.h"
  13 #include "llvm/Analysis/TargetLibraryInfo.h"
  14 #include "llvm/AsmParser/Parser.h"
  15 #include "llvm/IR/Constants.h"
  16 #include "llvm/IR/InstIterator.h"
  17 #include "llvm/IR/Instructions.h"
  18 #include "llvm/IR/LLVMContext.h"
  19 #include "llvm/IR/LegacyPassManager.h"
  20 #include "llvm/IR/Module.h"
  21 #include "llvm/Support/SourceMgr.h"
  22 #include "gtest/gtest.h"
  23
  24 using namespace llvm;
  25
  26 // Set up some test passes.
  27 namespace llvm {
  28 void initializeAATestPassPass(PassRegistry&);
  29 void initializeTestCustomAAWrapperPassPass(PassRegistry&);
  30 }
  31
  32 namespace {
  33 struct AATestPass : FunctionPass {
  34   static char ID;
  35   AATestPass() : FunctionPass(ID) {
  36     initializeAATestPassPass(*PassRegistry::getPassRegistry());
  37   }
  38
  39   void getAnalysisUsage(AnalysisUsage &AU) const override {
  40     AU.addRequired<AAResultsWrapperPass>();
  41     AU.setPreservesAll();
  42   }
  43
  44   bool runOnFunction(Function &F) override {
  45     AliasAnalysis &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
  46
  47     SetVector<Value *> Pointers;
  48     for (Argument &A : F.args())
  49       if (A.getType()->isPointerTy())
  50         Pointers.insert(&A);
  51     for (Instruction &I : instructions(F))
  52       if (I.getType()->isPointerTy())
  53         Pointers.insert(&I);
  54
  55     for (Value *P1 : Pointers)
  56       for (Value *P2 : Pointers)
  57         (void)AA.alias(P1, LocationSize::unknown(), P2,
  58                        LocationSize::unknown());
  59
  60     return false;
  61   }
  62 };
  63 }
  64
  65 char AATestPass::ID = 0;
  66 INITIALIZE_PASS_BEGIN(AATestPass, "aa-test-pas", "Alias Analysis Test Pass",
  67                       false, true)
  68 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
  69 INITIALIZE_PASS_END(AATestPass, "aa-test-pass", "Alias Analysis Test Pass",
  70                     false, true)
  71
  72 namespace {
  73 /// A test customizable AA result. It merely accepts a callback to run whenever
  74 /// it receives an alias query. Useful for testing that a particular AA result
  75 /// is reached.
  76 struct TestCustomAAResult : AAResultBase<TestCustomAAResult> {
  77   friend AAResultBase<TestCustomAAResult>;
  78
  79   std::function<void()> CB;
  80
  81   explicit TestCustomAAResult(std::function<void()> CB)
  82       : AAResultBase(), CB(std::move(CB)) {}
  83   TestCustomAAResult(TestCustomAAResult &&Arg)
  84       : AAResultBase(std::move(Arg)), CB(std::move(Arg.CB)) {}
  85
  86   bool invalidate(Function &, const PreservedAnalyses &) { return false; }
  87
  88   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
  89                     AAQueryInfo &AAQI) {
  90     CB();
  91     return MayAlias;
  92   }
  93 };
  94 }
  95
  96 namespace {
  97 /// A wrapper pass for the legacy pass manager to use with the above custom AA
  98 /// result.
  99 class TestCustomAAWrapperPass : public ImmutablePass {
 100   std::function<void()> CB;
 101   std::unique_ptr<TestCustomAAResult> Result;
 102
 103 public:
 104   static char ID;
 105
 106   explicit TestCustomAAWrapperPass(
 107       std::function<void()> CB = std::function<void()>())
 108       : ImmutablePass(ID), CB(std::move(CB)) {
 109     initializeTestCustomAAWrapperPassPass(*PassRegistry::getPassRegistry());
 110   }
 111
 112   void getAnalysisUsage(AnalysisUsage &AU) const override {
 113     AU.setPreservesAll();
 114     AU.addRequired<TargetLibraryInfoWrapperPass>();
 115   }
 116
 117   bool doInitialization(Module &M) override {
 118     Result.reset(new TestCustomAAResult(std::move(CB)));
 119     return true;
 120   }
 121
 122   bool doFinalization(Module &M) override {
 123     Result.reset();
 124     return true;
 125   }
 126
 127   TestCustomAAResult &getResult() { return *Result; }
 128   const TestCustomAAResult &getResult() const { return *Result; }
 129 };
 130 }
 131
 132 char TestCustomAAWrapperPass::ID = 0;
 133 INITIALIZE_PASS_BEGIN(TestCustomAAWrapperPass, "test-custom-aa",
 134                 "Test Custom AA Wrapper Pass", false, true)
 135 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 136 INITIALIZE_PASS_END(TestCustomAAWrapperPass, "test-custom-aa",
 137                 "Test Custom AA Wrapper Pass", false, true)
 138
 139 namespace {
 140
 141 class AliasAnalysisTest : public testing::Test {
 142 protected:
 143   LLVMContext C;
 144   Module M;
 145   TargetLibraryInfoImpl TLII;
 146   TargetLibraryInfo TLI;
 147   std::unique_ptr<AssumptionCache> AC;
 148   std::unique_ptr<BasicAAResult> BAR;
 149   std::unique_ptr<AAResults> AAR;
 150
 151   AliasAnalysisTest() : M("AliasAnalysisTest", C), TLI(TLII) {}
 152
 153   AAResults &getAAResults(Function &F) {
 154     // Reset the Function AA results first to clear out any references.
 155     AAR.reset(new AAResults(TLI));
 156
 157     // Build the various AA results and register them.
 158     AC.reset(new AssumptionCache(F));
 159     BAR.reset(new BasicAAResult(M.getDataLayout(), F, TLI, *AC));
 160     AAR->addAAResult(*BAR);
 161
 162     return *AAR;
 163   }
 164 };
 165
 166 TEST_F(AliasAnalysisTest, getModRefInfo) {
 167   // Setup function.
 168   FunctionType *FTy =
 169       FunctionType::get(Type::getVoidTy(C), std::vector<Type *>(), false);
 170   auto *F = Function::Create(FTy, Function::ExternalLinkage, "f", M);
 171   auto *BB = BasicBlock::Create(C, "entry", F);
 172   auto IntType = Type::getInt32Ty(C);
 173   auto PtrType = Type::getInt32PtrTy(C);
 174   auto *Value = ConstantInt::get(IntType, 42);
 175   auto *Addr = ConstantPointerNull::get(PtrType);
 176
 177   auto *Store1 = new StoreInst(Value, Addr, BB);
 178   auto *Load1 = new LoadInst(IntType, Addr, "load", BB);
 179   auto *Add1 = BinaryOperator::CreateAdd(Value, Value, "add", BB);
 180   auto *VAArg1 = new VAArgInst(Addr, PtrType, "vaarg", BB);
 181   auto *CmpXChg1 = new AtomicCmpXchgInst(
 182       Addr, ConstantInt::get(IntType, 0), ConstantInt::get(IntType, 1),
 183       AtomicOrdering::Monotonic, AtomicOrdering::Monotonic,
 184       SyncScope::System, BB);
 185   auto *AtomicRMW =
 186       new AtomicRMWInst(AtomicRMWInst::Xchg, Addr, ConstantInt::get(IntType, 1),
 187                         AtomicOrdering::Monotonic, SyncScope::System, BB);
 188
 189   ReturnInst::Create(C, nullptr, BB);
 190
 191   auto &AA = getAAResults(*F);
 192
 193   // Check basic results
 194   EXPECT_EQ(AA.getModRefInfo(Store1, MemoryLocation()), ModRefInfo::Mod);
 195   EXPECT_EQ(AA.getModRefInfo(Store1, None), ModRefInfo::Mod);
 196   EXPECT_EQ(AA.getModRefInfo(Load1, MemoryLocation()), ModRefInfo::Ref);
 197   EXPECT_EQ(AA.getModRefInfo(Load1, None), ModRefInfo::Ref);
 198   EXPECT_EQ(AA.getModRefInfo(Add1, MemoryLocation()), ModRefInfo::NoModRef);
 199   EXPECT_EQ(AA.getModRefInfo(Add1, None), ModRefInfo::NoModRef);
 200   EXPECT_EQ(AA.getModRefInfo(VAArg1, MemoryLocation()), ModRefInfo::ModRef);
 201   EXPECT_EQ(AA.getModRefInfo(VAArg1, None), ModRefInfo::ModRef);
 202   EXPECT_EQ(AA.getModRefInfo(CmpXChg1, MemoryLocation()), ModRefInfo::ModRef);
 203   EXPECT_EQ(AA.getModRefInfo(CmpXChg1, None), ModRefInfo::ModRef);
 204   EXPECT_EQ(AA.getModRefInfo(AtomicRMW, MemoryLocation()), ModRefInfo::ModRef);
 205   EXPECT_EQ(AA.getModRefInfo(AtomicRMW, None), ModRefInfo::ModRef);
 206 }
 207
 208 class AAPassInfraTest : public testing::Test {
 209 protected:
 210   LLVMContext C;
 211   SMDiagnostic Err;
 212   std::unique_ptr<Module> M;
 213
 214 public:
 215   AAPassInfraTest()
 216       : M(parseAssemblyString("define i32 @f(i32* %x, i32* %y) {\n"
 217                               "entry:\n"
 218                               "  %lx = load i32, i32* %x\n"
 219                               "  %ly = load i32, i32* %y\n"
 220                               "  %sum = add i32 %lx, %ly\n"
 221                               "  ret i32 %sum\n"
 222                               "}\n",
 223                               Err, C)) {
 224     assert(M && "Failed to build the module!");
 225   }
 226 };
 227
 228 TEST_F(AAPassInfraTest, injectExternalAA) {
 229   legacy::PassManager PM;
 230
 231   // Register our custom AA's wrapper pass manually.
 232   bool IsCustomAAQueried = false;
 233   PM.add(new TestCustomAAWrapperPass([&] { IsCustomAAQueried = true; }));
 234
 235   // Now add the external AA wrapper with a lambda which queries for the
 236   // wrapper around our custom AA and adds it to the results.
 237   PM.add(createExternalAAWrapperPass([](Pass &P, Function &, AAResults &AAR) {
 238     if (auto *WrapperPass = P.getAnalysisIfAvailable<TestCustomAAWrapperPass>())
 239       AAR.addAAResult(WrapperPass->getResult());
 240   }));
 241
 242   // And run a pass that will make some alias queries. This will automatically
 243   // trigger the rest of the alias analysis stack to be run. It is analagous to
 244   // building a full pass pipeline with any of the existing pass manager
 245   // builders.
 246   PM.add(new AATestPass());
 247   PM.run(*M);
 248
 249   // Finally, ensure that our custom AA was indeed queried.
 250   EXPECT_TRUE(IsCustomAAQueried);
 251 }
 252
 253 } // end anonymous namspace