1 //===- BasicAliasAnalysisTest.cpp - Unit tests for BasicAA ----------------===// 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 // Targeted tests that are hard/convoluted to make happen with just `opt`. 10 // 11 12 #include "llvm/Analysis/BasicAliasAnalysis.h" 13 #include "llvm/Analysis/AliasAnalysis.h" 14 #include "llvm/AsmParser/Parser.h" 15 #include "llvm/IR/Dominators.h" 16 #include "llvm/IR/IRBuilder.h" 17 #include "llvm/IR/LLVMContext.h" 18 #include "llvm/IR/Module.h" 19 #include "llvm/Support/SourceMgr.h" 20 #include "gtest/gtest.h" 21 22 using namespace llvm; 23 24 // FIXME: This is duplicated between this file and MemorySSATest. Refactor. 25 const static char DLString[] = "e-i64:64-f80:128-n8:16:32:64-S128"; 26 27 /// There's a lot of common setup between these tests. This fixture helps reduce 28 /// that. Tests should mock up a function, store it in F, and then call 29 /// setupAnalyses(). 30 class BasicAATest : public testing::Test { 31 protected: 32 // N.B. Many of these members depend on each other (e.g. the Module depends on 33 // the Context, etc.). So, order matters here (and in TestAnalyses). 34 LLVMContext C; 35 Module M; 36 IRBuilder<> B; 37 DataLayout DL; 38 TargetLibraryInfoImpl TLII; 39 TargetLibraryInfo TLI; 40 Function *F; 41 42 // Things that we need to build after the function is created. 43 struct TestAnalyses { 44 DominatorTree DT; 45 AssumptionCache AC; 46 BasicAAResult BAA; 47 AAQueryInfo AAQI; 48 49 TestAnalyses(BasicAATest &Test) 50 : DT(*Test.F), AC(*Test.F), BAA(Test.DL, *Test.F, Test.TLI, AC, &DT), 51 AAQI() {} 52 }; 53 54 llvm::Optional<TestAnalyses> Analyses; 55 56 TestAnalyses &setupAnalyses() { 57 assert(F); 58 Analyses.emplace(*this); 59 return Analyses.getValue(); 60 } 61 62 public: 63 BasicAATest() 64 : M("BasicAATest", C), B(C), DL(DLString), TLI(TLII), F(nullptr) {} 65 }; 66 67 // Check that a function arg can't trivially alias a global when we're accessing 68 // >sizeof(global) bytes through that arg, unless the access size is just an 69 // upper-bound. 70 TEST_F(BasicAATest, AliasInstWithObjectOfImpreciseSize) { 71 F = Function::Create( 72 FunctionType::get(B.getVoidTy(), {B.getInt32Ty()->getPointerTo()}, false), 73 GlobalValue::ExternalLinkage, "F", &M); 74 75 BasicBlock *Entry(BasicBlock::Create(C, "", F)); 76 B.SetInsertPoint(Entry); 77 78 Value *IncomingI32Ptr = F->arg_begin(); 79 80 auto *GlobalPtr = 81 cast<GlobalVariable>(M.getOrInsertGlobal("some_global", B.getInt8Ty())); 82 83 // Without sufficiently restricted linkage/an init, some of the object size 84 // checking bits get more conservative. 85 GlobalPtr->setLinkage(GlobalValue::LinkageTypes::InternalLinkage); 86 GlobalPtr->setInitializer(B.getInt8(0)); 87 88 auto &AllAnalyses = setupAnalyses(); 89 BasicAAResult &BasicAA = AllAnalyses.BAA; 90 AAQueryInfo &AAQI = AllAnalyses.AAQI; 91 ASSERT_EQ( 92 BasicAA.alias(MemoryLocation(IncomingI32Ptr, LocationSize::precise(4)), 93 MemoryLocation(GlobalPtr, LocationSize::precise(1)), AAQI), 94 AliasResult::NoAlias); 95 96 ASSERT_EQ( 97 BasicAA.alias(MemoryLocation(IncomingI32Ptr, LocationSize::upperBound(4)), 98 MemoryLocation(GlobalPtr, LocationSize::precise(1)), AAQI), 99 AliasResult::MayAlias); 100 } 101 102 // Check that we fall back to MayAlias if we see an access of an entire object 103 // that's just an upper-bound. 104 TEST_F(BasicAATest, AliasInstWithFullObjectOfImpreciseSize) { 105 F = Function::Create( 106 FunctionType::get(B.getVoidTy(), {B.getInt64Ty()}, false), 107 GlobalValue::ExternalLinkage, "F", &M); 108 109 BasicBlock *Entry(BasicBlock::Create(C, "", F)); 110 B.SetInsertPoint(Entry); 111 112 Value *ArbitraryI32 = F->arg_begin(); 113 AllocaInst *I8 = B.CreateAlloca(B.getInt8Ty(), B.getInt32(2)); 114 auto *I8AtUncertainOffset = 115 cast<GetElementPtrInst>(B.CreateGEP(B.getInt8Ty(), I8, ArbitraryI32)); 116 117 auto &AllAnalyses = setupAnalyses(); 118 BasicAAResult &BasicAA = AllAnalyses.BAA; 119 AAQueryInfo &AAQI = AllAnalyses.AAQI; 120 ASSERT_EQ(BasicAA.alias( 121 MemoryLocation(I8, LocationSize::precise(2)), 122 MemoryLocation(I8AtUncertainOffset, LocationSize::precise(1)), 123 AAQI), 124 AliasResult::PartialAlias); 125 126 ASSERT_EQ(BasicAA.alias( 127 MemoryLocation(I8, LocationSize::upperBound(2)), 128 MemoryLocation(I8AtUncertainOffset, LocationSize::precise(1)), 129 AAQI), 130 AliasResult::MayAlias); 131 } 132