diff options
Diffstat (limited to 'llvm/lib/Analysis')
-rw-r--r-- | llvm/lib/Analysis/AliasAnalysis.cpp | 43 | ||||
-rw-r--r-- | llvm/lib/Analysis/AliasAnalysisCounter.cpp | 13 | ||||
-rw-r--r-- | llvm/lib/Analysis/AliasDebugger.cpp | 8 | ||||
-rw-r--r-- | llvm/lib/Analysis/AliasSetTracker.cpp | 38 | ||||
-rw-r--r-- | llvm/lib/Analysis/BasicAliasAnalysis.cpp | 30 | ||||
-rw-r--r-- | llvm/lib/Analysis/CFLAliasAnalysis.cpp | 10 | ||||
-rw-r--r-- | llvm/lib/Analysis/IPA/GlobalsModRef.cpp | 13 | ||||
-rw-r--r-- | llvm/lib/Analysis/LibCallAliasAnalysis.cpp | 4 | ||||
-rw-r--r-- | llvm/lib/Analysis/LoopAccessAnalysis.cpp | 8 | ||||
-rw-r--r-- | llvm/lib/Analysis/MemoryDependenceAnalysis.cpp | 72 | ||||
-rw-r--r-- | llvm/lib/Analysis/NoAliasAnalysis.cpp | 8 | ||||
-rw-r--r-- | llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp | 17 | ||||
-rw-r--r-- | llvm/lib/Analysis/ScopedNoAliasAA.cpp | 16 | ||||
-rw-r--r-- | llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp | 16 |
14 files changed, 145 insertions, 151 deletions
diff --git a/llvm/lib/Analysis/AliasAnalysis.cpp b/llvm/lib/Analysis/AliasAnalysis.cpp index 641b617fac9..1cb5cc8727e 100644 --- a/llvm/lib/Analysis/AliasAnalysis.cpp +++ b/llvm/lib/Analysis/AliasAnalysis.cpp @@ -48,13 +48,13 @@ char AliasAnalysis::ID = 0; // Default chaining methods //===----------------------------------------------------------------------===// -AliasAnalysis::AliasResult -AliasAnalysis::alias(const Location &LocA, const Location &LocB) { +AliasAnalysis::AliasResult AliasAnalysis::alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) { assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); return AA->alias(LocA, LocB); } -bool AliasAnalysis::pointsToConstantMemory(const Location &Loc, +bool AliasAnalysis::pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) { assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); return AA->pointsToConstantMemory(Loc, OrLocal); @@ -92,7 +92,7 @@ AliasAnalysis::getModRefInfo(Instruction *I, ImmutableCallSite Call) { // location this memory access defines. The best we can say // is that if the call references what this instruction // defines, it must be clobbered by this location. - const AliasAnalysis::Location DefLoc = MemoryLocation::get(I); + const MemoryLocation DefLoc = MemoryLocation::get(I); if (getModRefInfo(Call, DefLoc) != AliasAnalysis::NoModRef) return AliasAnalysis::ModRef; } @@ -100,8 +100,7 @@ AliasAnalysis::getModRefInfo(Instruction *I, ImmutableCallSite Call) { } AliasAnalysis::ModRefResult -AliasAnalysis::getModRefInfo(ImmutableCallSite CS, - const Location &Loc) { +AliasAnalysis::getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc) { assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); ModRefBehavior MRB = getModRefBehavior(CS); @@ -122,7 +121,8 @@ AliasAnalysis::getModRefInfo(ImmutableCallSite CS, if (!Arg->getType()->isPointerTy()) continue; unsigned ArgIdx = std::distance(CS.arg_begin(), AI); - Location ArgLoc = MemoryLocation::getForArgument(CS, ArgIdx, *TLI); + MemoryLocation ArgLoc = + MemoryLocation::getForArgument(CS, ArgIdx, *TLI); if (!isNoAlias(ArgLoc, Loc)) { ModRefResult ArgMask = getArgModRefInfo(CS, ArgIdx); doesAlias = true; @@ -182,7 +182,7 @@ AliasAnalysis::getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) { if (!Arg->getType()->isPointerTy()) continue; unsigned CS2ArgIdx = std::distance(CS2.arg_begin(), I); - Location CS2ArgLoc = MemoryLocation::getForArgument(CS2, CS2ArgIdx, *TLI); + auto CS2ArgLoc = MemoryLocation::getForArgument(CS2, CS2ArgIdx, *TLI); // ArgMask indicates what CS2 might do to CS2ArgLoc, and the dependence of // CS1 on that location is the inverse. @@ -211,7 +211,7 @@ AliasAnalysis::getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) { if (!Arg->getType()->isPointerTy()) continue; unsigned CS1ArgIdx = std::distance(CS1.arg_begin(), I); - Location CS1ArgLoc = MemoryLocation::getForArgument(CS1, CS1ArgIdx, *TLI); + auto CS1ArgLoc = MemoryLocation::getForArgument(CS1, CS1ArgIdx, *TLI); // ArgMask indicates what CS1 might do to CS1ArgLoc; if CS1 might Mod // CS1ArgLoc, then we care about either a Mod or a Ref by CS2. If CS1 @@ -267,7 +267,7 @@ AliasAnalysis::getModRefBehavior(const Function *F) { //===----------------------------------------------------------------------===// AliasAnalysis::ModRefResult -AliasAnalysis::getModRefInfo(const LoadInst *L, const Location &Loc) { +AliasAnalysis::getModRefInfo(const LoadInst *L, const MemoryLocation &Loc) { // Be conservative in the face of volatile/atomic. if (!L->isUnordered()) return ModRef; @@ -282,7 +282,7 @@ AliasAnalysis::getModRefInfo(const LoadInst *L, const Location &Loc) { } AliasAnalysis::ModRefResult -AliasAnalysis::getModRefInfo(const StoreInst *S, const Location &Loc) { +AliasAnalysis::getModRefInfo(const StoreInst *S, const MemoryLocation &Loc) { // Be conservative in the face of volatile/atomic. if (!S->isUnordered()) return ModRef; @@ -305,7 +305,7 @@ AliasAnalysis::getModRefInfo(const StoreInst *S, const Location &Loc) { } AliasAnalysis::ModRefResult -AliasAnalysis::getModRefInfo(const VAArgInst *V, const Location &Loc) { +AliasAnalysis::getModRefInfo(const VAArgInst *V, const MemoryLocation &Loc) { if (Loc.Ptr) { // If the va_arg address cannot alias the pointer in question, then the @@ -324,7 +324,8 @@ AliasAnalysis::getModRefInfo(const VAArgInst *V, const Location &Loc) { } AliasAnalysis::ModRefResult -AliasAnalysis::getModRefInfo(const AtomicCmpXchgInst *CX, const Location &Loc) { +AliasAnalysis::getModRefInfo(const AtomicCmpXchgInst *CX, + const MemoryLocation &Loc) { // Acquire/Release cmpxchg has properties that matter for arbitrary addresses. if (CX->getSuccessOrdering() > Monotonic) return ModRef; @@ -337,7 +338,8 @@ AliasAnalysis::getModRefInfo(const AtomicCmpXchgInst *CX, const Location &Loc) { } AliasAnalysis::ModRefResult -AliasAnalysis::getModRefInfo(const AtomicRMWInst *RMW, const Location &Loc) { +AliasAnalysis::getModRefInfo(const AtomicRMWInst *RMW, + const MemoryLocation &Loc) { // Acquire/Release atomicrmw has properties that matter for arbitrary addresses. if (RMW->getOrdering() > Monotonic) return ModRef; @@ -353,10 +355,8 @@ AliasAnalysis::getModRefInfo(const AtomicRMWInst *RMW, const Location &Loc) { // BasicAA isn't willing to spend linear time determining whether an alloca // was captured before or after this particular call, while we are. However, // with a smarter AA in place, this test is just wasting compile time. -AliasAnalysis::ModRefResult -AliasAnalysis::callCapturesBefore(const Instruction *I, - const AliasAnalysis::Location &MemLoc, - DominatorTree *DT) { +AliasAnalysis::ModRefResult AliasAnalysis::callCapturesBefore( + const Instruction *I, const MemoryLocation &MemLoc, DominatorTree *DT) { if (!DT) return AliasAnalysis::ModRef; @@ -389,8 +389,7 @@ AliasAnalysis::callCapturesBefore(const Instruction *I, // is impossible to alias the pointer we're checking. If not, we have to // assume that the call could touch the pointer, even though it doesn't // escape. - if (isNoAlias(AliasAnalysis::Location(*CI), - AliasAnalysis::Location(Object))) + if (isNoAlias(MemoryLocation(*CI), MemoryLocation(Object))) continue; if (CS.doesNotAccessMemory(ArgNo)) continue; @@ -437,7 +436,7 @@ uint64_t AliasAnalysis::getTypeStoreSize(Type *Ty) { /// specified basic block to modify the location Loc. /// bool AliasAnalysis::canBasicBlockModify(const BasicBlock &BB, - const Location &Loc) { + const MemoryLocation &Loc) { return canInstructionRangeModRef(BB.front(), BB.back(), Loc, Mod); } @@ -448,7 +447,7 @@ bool AliasAnalysis::canBasicBlockModify(const BasicBlock &BB, /// I1 and I2 must be in the same basic block. bool AliasAnalysis::canInstructionRangeModRef(const Instruction &I1, const Instruction &I2, - const Location &Loc, + const MemoryLocation &Loc, const ModRefResult Mode) { assert(I1.getParent() == I2.getParent() && "Instructions not in same basic block!"); diff --git a/llvm/lib/Analysis/AliasAnalysisCounter.cpp b/llvm/lib/Analysis/AliasAnalysisCounter.cpp index a1bfba1f002..77fe64baf71 100644 --- a/llvm/lib/Analysis/AliasAnalysisCounter.cpp +++ b/llvm/lib/Analysis/AliasAnalysisCounter.cpp @@ -98,16 +98,18 @@ namespace { } // FIXME: We could count these too... - bool pointsToConstantMemory(const Location &Loc, bool OrLocal) override { + bool pointsToConstantMemory(const MemoryLocation &Loc, + bool OrLocal) override { return getAnalysis<AliasAnalysis>().pointsToConstantMemory(Loc, OrLocal); } // Forwarding functions: just delegate to a real AA implementation, counting // the number of responses... - AliasResult alias(const Location &LocA, const Location &LocB) override; + AliasResult alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) override; ModRefResult getModRefInfo(ImmutableCallSite CS, - const Location &Loc) override; + const MemoryLocation &Loc) override; ModRefResult getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) override { return AliasAnalysis::getModRefInfo(CS1,CS2); @@ -124,7 +126,8 @@ ModulePass *llvm::createAliasAnalysisCounterPass() { } AliasAnalysis::AliasResult -AliasAnalysisCounter::alias(const Location &LocA, const Location &LocB) { +AliasAnalysisCounter::alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) { AliasResult R = getAnalysis<AliasAnalysis>().alias(LocA, LocB); const char *AliasString = nullptr; @@ -150,7 +153,7 @@ AliasAnalysisCounter::alias(const Location &LocA, const Location &LocB) { AliasAnalysis::ModRefResult AliasAnalysisCounter::getModRefInfo(ImmutableCallSite CS, - const Location &Loc) { + const MemoryLocation &Loc) { ModRefResult R = getAnalysis<AliasAnalysis>().getModRefInfo(CS, Loc); const char *MRString = nullptr; diff --git a/llvm/lib/Analysis/AliasDebugger.cpp b/llvm/lib/Analysis/AliasDebugger.cpp index f98b5781960..1ef49fc02fe 100644 --- a/llvm/lib/Analysis/AliasDebugger.cpp +++ b/llvm/lib/Analysis/AliasDebugger.cpp @@ -94,7 +94,8 @@ namespace { //------------------------------------------------ // Implement the AliasAnalysis API // - AliasResult alias(const Location &LocA, const Location &LocB) override { + AliasResult alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) override { assert(Vals.find(LocA.Ptr) != Vals.end() && "Never seen value in AA before"); assert(Vals.find(LocB.Ptr) != Vals.end() && @@ -103,7 +104,7 @@ namespace { } ModRefResult getModRefInfo(ImmutableCallSite CS, - const Location &Loc) override { + const MemoryLocation &Loc) override { assert(Vals.find(Loc.Ptr) != Vals.end() && "Never seen value in AA before"); return AliasAnalysis::getModRefInfo(CS, Loc); } @@ -113,7 +114,8 @@ namespace { return AliasAnalysis::getModRefInfo(CS1,CS2); } - bool pointsToConstantMemory(const Location &Loc, bool OrLocal) override { + bool pointsToConstantMemory(const MemoryLocation &Loc, + bool OrLocal) override { assert(Vals.find(Loc.Ptr) != Vals.end() && "Never seen value in AA before"); return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal); } diff --git a/llvm/lib/Analysis/AliasSetTracker.cpp b/llvm/lib/Analysis/AliasSetTracker.cpp index 12c1c7d4af9..fd7e7215a0a 100644 --- a/llvm/lib/Analysis/AliasSetTracker.cpp +++ b/llvm/lib/Analysis/AliasSetTracker.cpp @@ -45,13 +45,9 @@ void AliasSet::mergeSetIn(AliasSet &AS, AliasSetTracker &AST) { PointerRec *R = AS.getSomePointer(); // If the pointers are not a must-alias pair, this set becomes a may alias. - if (AA.alias(AliasAnalysis::Location(L->getValue(), - L->getSize(), - L->getAAInfo()), - AliasAnalysis::Location(R->getValue(), - R->getSize(), - R->getAAInfo())) - != AliasAnalysis::MustAlias) + if (AA.alias(MemoryLocation(L->getValue(), L->getSize(), L->getAAInfo()), + MemoryLocation(R->getValue(), R->getSize(), R->getAAInfo())) != + AliasAnalysis::MustAlias) AliasTy = MayAlias; } @@ -106,9 +102,8 @@ void AliasSet::addPointer(AliasSetTracker &AST, PointerRec &Entry, if (PointerRec *P = getSomePointer()) { AliasAnalysis &AA = AST.getAliasAnalysis(); AliasAnalysis::AliasResult Result = - AA.alias(AliasAnalysis::Location(P->getValue(), P->getSize(), - P->getAAInfo()), - AliasAnalysis::Location(Entry.getValue(), Size, AAInfo)); + AA.alias(MemoryLocation(P->getValue(), P->getSize(), P->getAAInfo()), + MemoryLocation(Entry.getValue(), Size, AAInfo)); if (Result != AliasAnalysis::MustAlias) AliasTy = MayAlias; else // First entry of must alias must have maximum size! @@ -156,26 +151,24 @@ bool AliasSet::aliasesPointer(const Value *Ptr, uint64_t Size, // SOME value in the set. PointerRec *SomePtr = getSomePointer(); assert(SomePtr && "Empty must-alias set??"); - return AA.alias(AliasAnalysis::Location(SomePtr->getValue(), - SomePtr->getSize(), - SomePtr->getAAInfo()), - AliasAnalysis::Location(Ptr, Size, AAInfo)); + return AA.alias(MemoryLocation(SomePtr->getValue(), SomePtr->getSize(), + SomePtr->getAAInfo()), + MemoryLocation(Ptr, Size, AAInfo)); } // If this is a may-alias set, we have to check all of the pointers in the set // to be sure it doesn't alias the set... for (iterator I = begin(), E = end(); I != E; ++I) - if (AA.alias(AliasAnalysis::Location(Ptr, Size, AAInfo), - AliasAnalysis::Location(I.getPointer(), I.getSize(), - I.getAAInfo()))) + if (AA.alias(MemoryLocation(Ptr, Size, AAInfo), + MemoryLocation(I.getPointer(), I.getSize(), I.getAAInfo()))) return true; // Check the unknown instructions... if (!UnknownInsts.empty()) { for (unsigned i = 0, e = UnknownInsts.size(); i != e; ++i) if (AA.getModRefInfo(UnknownInsts[i], - AliasAnalysis::Location(Ptr, Size, AAInfo)) != - AliasAnalysis::NoModRef) + MemoryLocation(Ptr, Size, AAInfo)) != + AliasAnalysis::NoModRef) return true; } @@ -196,10 +189,9 @@ bool AliasSet::aliasesUnknownInst(const Instruction *Inst, } for (iterator I = begin(), E = end(); I != E; ++I) - if (AA.getModRefInfo(Inst, AliasAnalysis::Location(I.getPointer(), - I.getSize(), - I.getAAInfo())) != - AliasAnalysis::NoModRef) + if (AA.getModRefInfo( + Inst, MemoryLocation(I.getPointer(), I.getSize(), I.getAAInfo())) != + AliasAnalysis::NoModRef) return true; return false; diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp index a7f7380b345..2da64c279f9 100644 --- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp +++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp @@ -459,7 +459,8 @@ namespace { AU.addRequired<TargetLibraryInfoWrapperPass>(); } - AliasResult alias(const Location &LocA, const Location &LocB) override { + AliasResult alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) override { assert(AliasCache.empty() && "AliasCache must be cleared after use!"); assert(notDifferentParent(LocA.Ptr, LocB.Ptr) && "BasicAliasAnalysis doesn't support interprocedural queries."); @@ -475,14 +476,15 @@ namespace { } ModRefResult getModRefInfo(ImmutableCallSite CS, - const Location &Loc) override; + const MemoryLocation &Loc) override; ModRefResult getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) override; /// pointsToConstantMemory - Chase pointers until we find a (constant /// global) or not. - bool pointsToConstantMemory(const Location &Loc, bool OrLocal) override; + bool pointsToConstantMemory(const MemoryLocation &Loc, + bool OrLocal) override; /// Get the location associated with a pointer argument of a callsite. ModRefResult getArgModRefInfo(ImmutableCallSite CS, @@ -508,7 +510,7 @@ namespace { private: // AliasCache - Track alias queries to guard against recursion. - typedef std::pair<Location, Location> LocPair; + typedef std::pair<MemoryLocation, MemoryLocation> LocPair; typedef SmallDenseMap<LocPair, AliasResult, 8> AliasCacheTy; AliasCacheTy AliasCache; @@ -592,8 +594,8 @@ ImmutablePass *llvm::createBasicAliasAnalysisPass() { /// pointsToConstantMemory - Returns whether the given pointer value /// points to memory that is local to the function, with global constants being /// considered local to all functions. -bool -BasicAliasAnalysis::pointsToConstantMemory(const Location &Loc, bool OrLocal) { +bool BasicAliasAnalysis::pointsToConstantMemory(const MemoryLocation &Loc, + bool OrLocal) { assert(Visited.empty() && "Visited must be cleared after use!"); unsigned MaxLookup = 8; @@ -765,7 +767,7 @@ bool BasicAliasAnalysis::doInitialization(Module &M) { /// simple "address taken" analysis on local objects. AliasAnalysis::ModRefResult BasicAliasAnalysis::getModRefInfo(ImmutableCallSite CS, - const Location &Loc) { + const MemoryLocation &Loc) { assert(notDifferentParent(CS.getInstruction(), Loc.Ptr) && "AliasAnalysis query involving multiple functions!"); @@ -801,7 +803,7 @@ BasicAliasAnalysis::getModRefInfo(ImmutableCallSite CS, // is impossible to alias the pointer we're checking. If not, we have to // assume that the call could touch the pointer, even though it doesn't // escape. - if (!isNoAlias(Location(*CI), Location(Object))) { + if (!isNoAlias(MemoryLocation(*CI), MemoryLocation(Object))) { PassedAsArg = true; break; } @@ -1253,8 +1255,8 @@ BasicAliasAnalysis::aliasPHI(const PHINode *PN, uint64_t PNSize, // on corresponding edges. if (const PHINode *PN2 = dyn_cast<PHINode>(V2)) if (PN2->getParent() == PN->getParent()) { - LocPair Locs(Location(PN, PNSize, PNAAInfo), - Location(V2, V2Size, V2AAInfo)); + LocPair Locs(MemoryLocation(PN, PNSize, PNAAInfo), + MemoryLocation(V2, V2Size, V2AAInfo)); if (PN > V2) std::swap(Locs.first, Locs.second); // Analyse the PHIs' inputs under the assumption that the PHIs are @@ -1414,8 +1416,8 @@ BasicAliasAnalysis::aliasCheck(const Value *V1, uint64_t V1Size, // Check the cache before climbing up use-def chains. This also terminates // otherwise infinitely recursive queries. - LocPair Locs(Location(V1, V1Size, V1AAInfo), - Location(V2, V2Size, V2AAInfo)); + LocPair Locs(MemoryLocation(V1, V1Size, V1AAInfo), + MemoryLocation(V2, V2Size, V2AAInfo)); if (V1 > V2) std::swap(Locs.first, Locs.second); std::pair<AliasCacheTy::iterator, bool> Pair = @@ -1467,8 +1469,8 @@ BasicAliasAnalysis::aliasCheck(const Value *V1, uint64_t V1Size, return AliasCache[Locs] = PartialAlias; AliasResult Result = - AliasAnalysis::alias(Location(V1, V1Size, V1AAInfo), - Location(V2, V2Size, V2AAInfo)); + AliasAnalysis::alias(MemoryLocation(V1, V1Size, V1AAInfo), + MemoryLocation(V2, V2Size, V2AAInfo)); return AliasCache[Locs] = Result; } diff --git a/llvm/lib/Analysis/CFLAliasAnalysis.cpp b/llvm/lib/Analysis/CFLAliasAnalysis.cpp index c262b9ea2ad..ee76317ca71 100644 --- a/llvm/lib/Analysis/CFLAliasAnalysis.cpp +++ b/llvm/lib/Analysis/CFLAliasAnalysis.cpp @@ -219,9 +219,10 @@ public: return Iter->second; } - AliasResult query(const Location &LocA, const Location &LocB); + AliasResult query(const MemoryLocation &LocA, const MemoryLocation &LocB); - AliasResult alias(const Location &LocA, const Location &LocB) override { + AliasResult alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) override { if (LocA.Ptr == LocB.Ptr) { if (LocA.Size == LocB.Size) { return MustAlias; @@ -1109,9 +1110,8 @@ void CFLAliasAnalysis::scan(Function *Fn) { Handles.push_front(FunctionHandle(Fn, this)); } -AliasAnalysis::AliasResult -CFLAliasAnalysis::query(const AliasAnalysis::Location &LocA, - const AliasAnalysis::Location &LocB) { +AliasAnalysis::AliasResult CFLAliasAnalysis::query(const MemoryLocation &LocA, + const MemoryLocation &LocB) { auto *ValA = const_cast<Value *>(LocA.Ptr); auto *ValB = const_cast<Value *>(LocB.Ptr); diff --git a/llvm/lib/Analysis/IPA/GlobalsModRef.cpp b/llvm/lib/Analysis/IPA/GlobalsModRef.cpp index 018ae99d661..3e47c69a1ee 100644 --- a/llvm/lib/Analysis/IPA/GlobalsModRef.cpp +++ b/llvm/lib/Analysis/IPA/GlobalsModRef.cpp @@ -115,9 +115,10 @@ namespace { //------------------------------------------------ // Implement the AliasAnalysis API // - AliasResult alias(const Location &LocA, const Location &LocB) override; + AliasResult alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) override; ModRefResult getModRefInfo(ImmutableCallSite CS, - const Location &Loc) override; + const MemoryLocation &Loc) override; ModRefResult getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) override { return AliasAnalysis::getModRefInfo(CS1, CS2); @@ -478,9 +479,8 @@ void GlobalsModRef::AnalyzeCallGraph(CallGraph &CG, Module &M) { /// alias - If one of the pointers is to a global that we are tracking, and the /// other is some random pointer, we know there cannot be an alias, because the /// address of the global isn't taken. -AliasAnalysis::AliasResult -GlobalsModRef::alias(const Location &LocA, - const Location &LocB) { +AliasAnalysis::AliasResult GlobalsModRef::alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) { // Get the base object these pointers point to. const Value *UV1 = GetUnderlyingObject(LocA.Ptr, *DL); const Value *UV2 = GetUnderlyingObject(LocB.Ptr, *DL); @@ -535,8 +535,7 @@ GlobalsModRef::alias(const Location &LocA, } AliasAnalysis::ModRefResult -GlobalsModRef::getModRefInfo(ImmutableCallSite CS, - const Location &Loc) { +GlobalsModRef::getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc) { unsigned Known = ModRef; // If we are asking for mod/ref info of a direct call with a pointer to a diff --git a/llvm/lib/Analysis/LibCallAliasAnalysis.cpp b/llvm/lib/Analysis/LibCallAliasAnalysis.cpp index f6025e3252e..991a0e3e275 100644 --- a/llvm/lib/Analysis/LibCallAliasAnalysis.cpp +++ b/llvm/lib/Analysis/LibCallAliasAnalysis.cpp @@ -48,7 +48,7 @@ bool LibCallAliasAnalysis::runOnFunction(Function &F) { AliasAnalysis::ModRefResult LibCallAliasAnalysis::AnalyzeLibCallDetails(const LibCallFunctionInfo *FI, ImmutableCallSite CS, - const Location &Loc) { + const MemoryLocation &Loc) { // If we have a function, check to see what kind of mod/ref effects it // has. Start by including any info globally known about the function. AliasAnalysis::ModRefResult MRInfo = FI->UniversalBehavior; @@ -122,7 +122,7 @@ LibCallAliasAnalysis::AnalyzeLibCallDetails(const LibCallFunctionInfo *FI, // AliasAnalysis::ModRefResult LibCallAliasAnalysis::getModRefInfo(ImmutableCallSite CS, - const Location &Loc) { + const MemoryLocation &Loc) { ModRefResult MRInfo = ModRef; // If this is a direct call to a function that LCI knows about, get the diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp index c661c7b87dc..3dcb13b5360 100644 --- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp +++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp @@ -210,7 +210,7 @@ public: : DL(Dl), AST(*AA), LI(LI), DepCands(DA), IsRTCheckNeeded(false) {} /// \brief Register a load and whether it is only read from. - void addLoad(AliasAnalysis::Location &Loc, bool IsReadOnly) { + void addLoad(MemoryLocation &Loc, bool IsReadOnly) { Value *Ptr = const_cast<Value*>(Loc.Ptr); AST.add(Ptr, AliasAnalysis::UnknownSize, Loc.AATags); Accesses.insert(MemAccessInfo(Ptr, false)); @@ -219,7 +219,7 @@ public: } /// \brief Register a store. - void addStore(AliasAnalysis::Location &Loc) { + void addStore(MemoryLocation &Loc) { Value *Ptr = const_cast<Value*>(Loc.Ptr); AST.add(Ptr, AliasAnalysis::UnknownSize, Loc.AATags); Accesses.insert(MemAccessInfo(Ptr, true)); @@ -1150,7 +1150,7 @@ void LoopAccessInfo::analyzeLoop(const ValueToValueMap &Strides) { if (Seen.insert(Ptr).second) { ++NumReadWrites; - AliasAnalysis::Location Loc = MemoryLocation::get(ST); + MemoryLocation Loc = MemoryLocation::get(ST); // The TBAA metadata could have a control dependency on the predication // condition, so we cannot rely on it when determining whether or not we // need runtime pointer checks. @@ -1186,7 +1186,7 @@ void LoopAccessInfo::analyzeLoop(const ValueToValueMap &Strides) { IsReadOnlyPtr = true; } - AliasAnalysis::Location Loc = MemoryLocation::get(LD); + MemoryLocation Loc = MemoryLocation::get(LD); // The TBAA metadata could have a control dependency on the predication // condition, so we cannot rely on it when determining whether or not we // need runtime pointer checks. diff --git a/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp b/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp index 255bae61eb2..cf8ba5ccb72 100644 --- a/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp +++ b/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp @@ -118,10 +118,8 @@ static void RemoveFromReverseMap(DenseMap<Instruction*, /// location, fill in Loc with the details, otherwise set Loc.Ptr to null. /// Return a ModRefInfo value describing the general behavior of the /// instruction. -static -AliasAnalysis::ModRefResult GetLocation(const Instruction *Inst, - AliasAnalysis::Location &Loc, - AliasAnalysis *AA) { +static AliasAnalysis::ModRefResult +GetLocation(const Instruction *Inst, MemoryLocation &Loc, AliasAnalysis *AA) { if (const LoadInst *LI = dyn_cast<LoadInst>(Inst)) { if (LI->isUnordered()) { Loc = MemoryLocation::get(LI); @@ -131,7 +129,7 @@ AliasAnalysis::ModRefResult GetLocation(const Instruction *Inst, Loc = MemoryLocation::get(LI); return AliasAnalysis::ModRef; } - Loc = AliasAnalysis::Location(); + Loc = MemoryLocation(); return AliasAnalysis::ModRef; } @@ -144,7 +142,7 @@ AliasAnalysis::ModRefResult GetLocation(const Instruction *Inst, Loc = MemoryLocation::get(SI); return AliasAnalysis::ModRef; } - Loc = AliasAnalysis::Location(); + Loc = MemoryLocation(); return AliasAnalysis::ModRef; } @@ -155,7 +153,7 @@ AliasAnalysis::ModRefResult GetLocation(const Instruction *Inst, if (const CallInst *CI = isFreeCall(Inst, AA->getTargetLibraryInfo())) { // calls to free() deallocate the entire structure - Loc = AliasAnalysis::Location(CI->getArgOperand(0)); + Loc = MemoryLocation(CI->getArgOperand(0)); return AliasAnalysis::Mod; } @@ -167,17 +165,17 @@ AliasAnalysis::ModRefResult GetLocation(const Instruction *Inst, case Intrinsic::lifetime_end: case Intrinsic::invariant_start: II->getAAMetadata(AAInfo); - Loc = AliasAnalysis::Location(II->getArgOperand(1), - cast<ConstantInt>(II->getArgOperand(0)) - ->getZExtValue(), AAInfo); + Loc = MemoryLocation( + II->getArgOperand(1), + cast<ConstantInt>(II->getArgOperand(0))->getZExtValue(), AAInfo); // These intrinsics don't really modify the memory, but returning Mod // will allow them to be handled conservatively. return AliasAnalysis::Mod; case Intrinsic::invariant_end: II->getAAMetadata(AAInfo); - Loc = AliasAnalysis::Location(II->getArgOperand(2), - cast<ConstantInt>(II->getArgOperand(1)) - ->getZExtValue(), AAInfo); + Loc = MemoryLocation( + II->getArgOperand(2), + cast<ConstantInt>(II->getArgOperand(1))->getZExtValue(), AAInfo); // These intrinsics don't really modify the memory, but returning Mod // will allow them to be handled conservatively. return AliasAnalysis::Mod; @@ -212,7 +210,7 @@ getCallSiteDependencyFrom(CallSite CS, bool isReadOnlyCall, Instruction *Inst = --ScanIt; // If this inst is a memory op, get the pointer it accessed - AliasAnalysis::Location Loc; + MemoryLocation Loc; AliasAnalysis::ModRefResult MR = GetLocation(Inst, Loc, AA); if (Loc.Ptr) { // A simple instruction. @@ -259,9 +257,10 @@ getCallSiteDependencyFrom(CallSite CS, bool isReadOnlyCall, /// /// MemLocBase, MemLocOffset are lazily computed here the first time the /// base/offs of memloc is needed. -static bool isLoadLoadClobberIfExtendedToFullWidth( - const AliasAnalysis::Location &MemLoc, const Value *&MemLocBase, - int64_t &MemLocOffs, const LoadInst *LI) { +static bool isLoadLoadClobberIfExtendedToFullWidth(const MemoryLocation &MemLoc, + const Value *&MemLocBase, + int64_t &MemLocOffs, + const LoadInst *LI) { const DataLayout &DL = LI->getModule()->getDataLayout(); // If we haven't already computed the base/offset of MemLoc, do so now. @@ -368,10 +367,9 @@ static bool isVolatile(Instruction *Inst) { /// with reads from read-only locations. If possible, pass the query /// instruction as well; this function may take advantage of the metadata /// annotated to the query instruction to refine the result. -MemDepResult MemoryDependenceAnalysis:: -getPointerDependencyFrom(const AliasAnalysis::Location &MemLoc, bool isLoad, - BasicBlock::iterator ScanIt, BasicBlock *BB, - Instruction *QueryInst) { +MemDepResult MemoryDependenceAnalysis::getPointerDependencyFrom( + const MemoryLocation &MemLoc, bool isLoad, BasicBlock::iterator ScanIt, + BasicBlock *BB, Instruction *QueryInst) { const Value *MemLocBase = nullptr; int64_t MemLocOffset = 0; @@ -440,8 +438,7 @@ getPointerDependencyFrom(const AliasAnalysis::Location &MemLoc, bool isLoad, // pointer, not on query pointers that are indexed off of them. It'd // be nice to handle that at some point (the right approach is to use // GetPointerBaseWithConstantOffset). - if (AA->isMustAlias(AliasAnalysis::Location(II->getArgOperand(1)), - MemLoc)) + if (AA->isMustAlias(MemoryLocation(II->getArgOperand(1)), MemLoc)) return MemDepResult::getDef(II); continue; } @@ -486,7 +483,7 @@ getPointerDependencyFrom(const AliasAnalysis::Location &MemLoc, bool isLoad, } } - AliasAnalysis::Location LoadLoc = MemoryLocation::get(LI); + MemoryLocation LoadLoc = MemoryLocation::get(LI); // If we found a pointer, check if it could be the same as our pointer. AliasAnalysis::AliasResult R = AA->alias(LoadLoc, MemLoc); @@ -575,7 +572,7 @@ getPointerDependencyFrom(const AliasAnalysis::Location &MemLoc, bool isLoad, // Ok, this store might clobber the query pointer. Check to see if it is // a must alias: in this case, we want to return this as a def. - AliasAnalysis::Location StoreLoc = MemoryLocation::get(SI); + MemoryLocation StoreLoc = MemoryLocation::get(SI); // If we found a pointer, check if it could be the same as our pointer. AliasAnalysis::AliasResult R = AA->alias(StoreLoc, MemLoc); @@ -679,7 +676,7 @@ MemDepResult MemoryDependenceAnalysis::getDependency(Instruction *QueryInst) { else LocalCache = MemDepResult::getNonFuncLocal(); } else { - AliasAnalysis::Location MemLoc; + MemoryLocation MemLoc; AliasAnalysis::ModRefResult MR = GetLocation(QueryInst, MemLoc, AA); if (MemLoc.Ptr) { // If we can do a pointer scan, make it happen. @@ -872,7 +869,7 @@ MemoryDependenceAnalysis::getNonLocalCallDependency(CallSite QueryCS) { void MemoryDependenceAnalysis:: getNonLocalPointerDependency(Instruction *QueryInst, SmallVectorImpl<NonLocalDepResult> &Result) { - const AliasAnalysis::Location Loc = MemoryLocation::get(QueryInst); + const MemoryLocation Loc = MemoryLocation::get(QueryInst); bool isLoad = isa<LoadInst>(QueryInst); BasicBlock *FromBB = QueryInst->getParent(); assert(FromBB); @@ -924,11 +921,9 @@ getNonLocalPointerDependency(Instruction *QueryInst, /// Pointer/PointeeSize using either cached information in Cache or by doing a /// lookup (which may use dirty cache info if available). If we do a lookup, /// add the result to the cache. -MemDepResult MemoryDependenceAnalysis:: -GetNonLocalInfoForBlock(Instruction *QueryInst, - const AliasAnalysis::Location &Loc, - bool isLoad, BasicBlock *BB, - NonLocalDepInfo *Cache, unsigned NumSortedEntries) { +MemDepResult MemoryDependenceAnalysis::GetNonLocalInfoForBlock( + Instruction *QueryInst, const MemoryLocation &Loc, bool isLoad, + BasicBlock *BB, NonLocalDepInfo *Cache, unsigned NumSortedEntries) { // Do a binary search to see if we already have an entry for this block in // the cache set. If so, find it. @@ -1040,14 +1035,11 @@ SortNonLocalDepInfoCache(MemoryDependenceAnalysis::NonLocalDepInfo &Cache, /// This function returns false on success, or true to indicate that it could /// not compute dependence information for some reason. This should be treated /// as a clobber dependence on the first instruction in the predecessor block. -bool MemoryDependenceAnalysis:: -getNonLocalPointerDepFromBB(Instruction *QueryInst, - const PHITransAddr &Pointer, - const AliasAnalysis::Location &Loc, - bool isLoad, BasicBlock *StartBB, - SmallVectorImpl<NonLocalDepResult> &Result, - DenseMap<BasicBlock*, Value*> &Visited, - bool SkipFirstBlock) { +bool MemoryDependenceAnalysis::getNonLocalPointerDepFromBB( + Instruction *QueryInst, const PHITransAddr &Pointer, + const MemoryLocation &Loc, bool isLoad, BasicBlock *StartBB, + SmallVectorImpl<NonLocalDepResult> &Result, + DenseMap<BasicBlock *, Value *> &Visited, bool SkipFirstBlock) { // Look up the cached info for Pointer. ValueIsLoadPair CacheKey(Pointer.getAddr(), isLoad); diff --git a/llvm/lib/Analysis/NoAliasAnalysis.cpp b/llvm/lib/Analysis/NoAliasAnalysis.cpp index 9a5430e0bc0..7617622b9ab 100644 --- a/llvm/lib/Analysis/NoAliasAnalysis.cpp +++ b/llvm/lib/Analysis/NoAliasAnalysis.cpp @@ -41,7 +41,8 @@ namespace { return true; } - AliasResult alias(const Location &LocA, const Location &LocB) override { + AliasResult alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) override { return MayAlias; } @@ -52,7 +53,8 @@ namespace { return UnknownModRefBehavior; } - bool pointsToConstantMemory(const Location &Loc, bool OrLocal) override { + bool pointsToConstantMemory(const MemoryLocation &Loc, + bool OrLocal) override { return false; } ModRefResult getArgModRefInfo(ImmutableCallSite CS, @@ -61,7 +63,7 @@ namespace { } ModRefResult getModRefInfo(ImmutableCallSite CS, - const Location &Loc) override { + const MemoryLocation &Loc) override { return ModRef; } ModRefResult getModRefInfo(ImmutableCallSite CS1, diff --git a/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp b/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp index ccec0a877f5..682f38b7412 100644 --- a/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp +++ b/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp @@ -53,7 +53,8 @@ namespace { private: void getAnalysisUsage(AnalysisUsage &AU) const override; bool runOnFunction(Function &F) override; - AliasResult alias(const Location &LocA, const Location &LocB) override; + AliasResult alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) override; Value *GetBaseValue(const SCEV *S); }; @@ -107,8 +108,8 @@ ScalarEvolutionAliasAnalysis::GetBaseValue(const SCEV *S) { } AliasAnalysis::AliasResult -ScalarEvolutionAliasAnalysis::alias(const Location &LocA, - const Location &LocB) { +ScalarEvolutionAliasAnalysis::alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) { // If either of the memory references is empty, it doesn't matter what the // pointer values are. This allows the code below to ignore this special // case. @@ -161,12 +162,10 @@ ScalarEvolutionAliasAnalysis::alias(const Location &LocA, Value *AO = GetBaseValue(AS); Value *BO = GetBaseValue(BS); if ((AO && AO != LocA.Ptr) || (BO && BO != LocB.Ptr)) - if (alias(Location(AO ? AO : LocA.Ptr, - AO ? +UnknownSize : LocA.Size, - AO ? AAMDNodes() : LocA.AATags), - Location(BO ? BO : LocB.Ptr, - BO ? +UnknownSize : LocB.Size, - BO ? AAMDNodes() : LocB.AATags)) == NoAlias) + if (alias(MemoryLocation(AO ? AO : LocA.Ptr, AO ? +UnknownSize : LocA.Size, + AO ? AAMDNodes() : LocA.AATags), + MemoryLocation(BO ? BO : LocB.Ptr, BO ? +UnknownSize : LocB.Size, + BO ? AAMDNodes() : LocB.AATags)) == NoAlias) return NoAlias; // Forward the query to the next analysis. diff --git a/llvm/lib/Analysis/ScopedNoAliasAA.cpp b/llvm/lib/Analysis/ScopedNoAliasAA.cpp index 02f8b0b1384..a8cfeb67ef9 100644 --- a/llvm/lib/Analysis/ScopedNoAliasAA.cpp +++ b/llvm/lib/Analysis/ScopedNoAliasAA.cpp @@ -99,12 +99,13 @@ protected: private: void getAnalysisUsage(AnalysisUsage &AU) const override; - AliasResult alias(const Location &LocA, const Location &LocB) override; - bool pointsToConstantMemory(const Location &Loc, bool OrLocal) override; + AliasResult alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) override; + bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) override; ModRefBehavior getModRefBehavior(ImmutableCallSite CS) override; ModRefBehavior getModRefBehavior(const Function *F) override; ModRefResult getModRefInfo(ImmutableCallSite CS, - const Location &Loc) override; + const MemoryLocation &Loc) override; ModRefResult getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) override; }; @@ -176,8 +177,8 @@ ScopedNoAliasAA::mayAliasInScopes(const MDNode *Scopes, return true; } -AliasAnalysis::AliasResult -ScopedNoAliasAA::alias(const Location &LocA, const Location &LocB) { +AliasAnalysis::AliasResult ScopedNoAliasAA::alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) { if (!EnableScopedNoAlias) return AliasAnalysis::alias(LocA, LocB); @@ -198,7 +199,7 @@ ScopedNoAliasAA::alias(const Location &LocA, const Location &LocB) { return AliasAnalysis::alias(LocA, LocB); } -bool ScopedNoAliasAA::pointsToConstantMemory(const Location &Loc, +bool ScopedNoAliasAA::pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) { return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal); } @@ -214,7 +215,8 @@ ScopedNoAliasAA::getModRefBehavior(const Function *F) { } AliasAnalysis::ModRefResult -ScopedNoAliasAA::getModRefInfo(ImmutableCallSite CS, const Location &Loc) { +ScopedNoAliasAA::getModRefInfo(ImmutableCallSite CS, + const MemoryLocation &Loc) { if (!EnableScopedNoAlias) return AliasAnalysis::getModRefInfo(CS, Loc); diff --git a/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp b/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp index 115872584cb..aadee9e3fcc 100644 --- a/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp +++ b/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp @@ -300,12 +300,14 @@ namespace { private: void getAnalysisUsage(AnalysisUsage &AU) const override; - AliasResult alias(const Location &LocA, const Location &LocB) override; - bool pointsToConstantMemory(const Location &Loc, bool OrLocal) override; + AliasResult alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) override; + bool pointsToConstantMemory(const MemoryLocation &Loc, + bool OrLocal) override; ModRefBehavior getModRefBehavior(ImmutableCallSite CS) override; ModRefBehavior getModRefBehavior(const Function *F) override; ModRefResult getModRefInfo(ImmutableCallSite CS, - const Location &Loc) override; + const MemoryLocation &Loc) override; ModRefResult getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) override; }; @@ -453,8 +455,8 @@ TypeBasedAliasAnalysis::PathAliases(const MDNode *A, } AliasAnalysis::AliasResult -TypeBasedAliasAnalysis::alias(const Location &LocA, - const Location &LocB) { +TypeBasedAliasAnalysis::alias(const MemoryLocation &LocA, + const MemoryLocation &LocB) { if (!EnableTBAA) return AliasAnalysis::alias(LocA, LocB); @@ -473,7 +475,7 @@ TypeBasedAliasAnalysis::alias(const Location &LocA, return NoAlias; } -bool TypeBasedAliasAnalysis::pointsToConstantMemory(const Location &Loc, +bool TypeBasedAliasAnalysis::pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) { if (!EnableTBAA) return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal); @@ -515,7 +517,7 @@ TypeBasedAliasAnalysis::getModRefBehavior(const Function *F) { AliasAnalysis::ModRefResult TypeBasedAliasAnalysis::getModRefInfo(ImmutableCallSite CS, - const Location &Loc) { + const MemoryLocation &Loc) { if (!EnableTBAA) return AliasAnalysis::getModRefInfo(CS, Loc); |