diff --git a/llvm/include/llvm/Analysis/BasicAliasAnalysis.h b/llvm/include/llvm/Analysis/BasicAliasAnalysis.h --- a/llvm/include/llvm/Analysis/BasicAliasAnalysis.h +++ b/llvm/include/llvm/Analysis/BasicAliasAnalysis.h @@ -208,29 +208,23 @@ const SmallVectorImpl &Src); AliasResult aliasGEP(const GEPOperator *V1, LocationSize V1Size, - const AAMDNodes &V1AAInfo, const Value *V2, - LocationSize V2Size, const AAMDNodes &V2AAInfo, + const Value *V2, LocationSize V2Size, const Value *UnderlyingV1, const Value *UnderlyingV2, AAQueryInfo &AAQI); AliasResult aliasPHI(const PHINode *PN, LocationSize PNSize, - const AAMDNodes &PNAAInfo, const Value *V2, - LocationSize V2Size, const AAMDNodes &V2AAInfo, - AAQueryInfo &AAQI); + const Value *V2, LocationSize V2Size, AAQueryInfo &AAQI); AliasResult aliasSelect(const SelectInst *SI, LocationSize SISize, - const AAMDNodes &SIAAInfo, const Value *V2, - LocationSize V2Size, const AAMDNodes &V2AAInfo, + const Value *V2, LocationSize V2Size, AAQueryInfo &AAQI); AliasResult aliasCheck(const Value *V1, LocationSize V1Size, - const AAMDNodes &V1AATag, const Value *V2, - LocationSize V2Size, const AAMDNodes &V2AATag, + const Value *V2, LocationSize V2Size, AAQueryInfo &AAQI); AliasResult aliasCheckRecursive(const Value *V1, LocationSize V1Size, - const AAMDNodes &V1AATag, const Value *V2, - LocationSize V2Size, const AAMDNodes &V2AATag, + const Value *V2, LocationSize V2Size, AAQueryInfo &AAQI, const Value *O1, const Value *O2); }; diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp --- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp +++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp @@ -783,8 +783,7 @@ AAQueryInfo &AAQI) { assert(notDifferentParent(LocA.Ptr, LocB.Ptr) && "BasicAliasAnalysis doesn't support interprocedural queries."); - return aliasCheck(LocA.Ptr, LocA.Size, LocA.AATags, LocB.Ptr, LocB.Size, - LocB.AATags, AAQI); + return aliasCheck(LocA.Ptr, LocA.Size, LocB.Ptr, LocB.Size, AAQI); } /// Checks to see if the specified callsite can clobber the specified memory @@ -1009,8 +1008,8 @@ /// UnderlyingV1 is getUnderlyingObject(GEP1), UnderlyingV2 is the same for /// V2. AliasResult BasicAAResult::aliasGEP( - const GEPOperator *GEP1, LocationSize V1Size, const AAMDNodes &V1AAInfo, - const Value *V2, LocationSize V2Size, const AAMDNodes &V2AAInfo, + const GEPOperator *GEP1, LocationSize V1Size, + const Value *V2, LocationSize V2Size, const Value *UnderlyingV1, const Value *UnderlyingV2, AAQueryInfo &AAQI) { if (!V1Size.hasValue() && !V2Size.hasValue()) { // TODO: This limitation exists for compile-time reasons. Relax it if we @@ -1063,8 +1062,8 @@ // when performing the alias check on the underlying objects. if (DecompGEP1.Offset == 0 && DecompGEP1.VarIndices.empty()) return getBestAAResults().alias( - MemoryLocation(UnderlyingV1, V1Size, V1AAInfo), - MemoryLocation(UnderlyingV2, V2Size, V2AAInfo), AAQI); + MemoryLocation(UnderlyingV1, V1Size), + MemoryLocation(UnderlyingV2, V2Size), AAQI); // Do the base pointers alias? AliasResult BaseAlias = getBestAAResults().alias( @@ -1247,44 +1246,41 @@ /// against another. AliasResult BasicAAResult::aliasSelect(const SelectInst *SI, LocationSize SISize, - const AAMDNodes &SIAAInfo, const Value *V2, - LocationSize V2Size, const AAMDNodes &V2AAInfo, + const Value *V2, LocationSize V2Size, AAQueryInfo &AAQI) { // If the values are Selects with the same condition, we can do a more precise // check: just check for aliases between the values on corresponding arms. if (const SelectInst *SI2 = dyn_cast(V2)) if (SI->getCondition() == SI2->getCondition()) { AliasResult Alias = getBestAAResults().alias( - MemoryLocation(SI->getTrueValue(), SISize, SIAAInfo), - MemoryLocation(SI2->getTrueValue(), V2Size, V2AAInfo), AAQI); + MemoryLocation(SI->getTrueValue(), SISize), + MemoryLocation(SI2->getTrueValue(), V2Size), AAQI); if (Alias == MayAlias) return MayAlias; AliasResult ThisAlias = getBestAAResults().alias( - MemoryLocation(SI->getFalseValue(), SISize, SIAAInfo), - MemoryLocation(SI2->getFalseValue(), V2Size, V2AAInfo), AAQI); + MemoryLocation(SI->getFalseValue(), SISize), + MemoryLocation(SI2->getFalseValue(), V2Size), AAQI); return MergeAliasResults(ThisAlias, Alias); } // If both arms of the Select node NoAlias or MustAlias V2, then returns // NoAlias / MustAlias. Otherwise, returns MayAlias. AliasResult Alias = getBestAAResults().alias( - MemoryLocation(V2, V2Size, V2AAInfo), - MemoryLocation(SI->getTrueValue(), SISize, SIAAInfo), AAQI); + MemoryLocation(V2, V2Size), + MemoryLocation(SI->getTrueValue(), SISize), AAQI); if (Alias == MayAlias) return MayAlias; AliasResult ThisAlias = getBestAAResults().alias( - MemoryLocation(V2, V2Size, V2AAInfo), - MemoryLocation(SI->getFalseValue(), SISize, SIAAInfo), AAQI); + MemoryLocation(V2, V2Size), + MemoryLocation(SI->getFalseValue(), SISize), AAQI); return MergeAliasResults(ThisAlias, Alias); } /// Provide a bunch of ad-hoc rules to disambiguate a PHI instruction against /// another. AliasResult BasicAAResult::aliasPHI(const PHINode *PN, LocationSize PNSize, - const AAMDNodes &PNAAInfo, const Value *V2, - LocationSize V2Size, - const AAMDNodes &V2AAInfo, + const Value *V2, LocationSize V2Size, AAQueryInfo &AAQI) { // If the values are PHIs in the same block, we can do a more precise // as well as efficient check: just check for aliases between the values @@ -1294,10 +1290,9 @@ Optional Alias; for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { AliasResult ThisAlias = getBestAAResults().alias( - MemoryLocation(PN->getIncomingValue(i), PNSize, PNAAInfo), + MemoryLocation(PN->getIncomingValue(i), PNSize), MemoryLocation( - PN2->getIncomingValueForBlock(PN->getIncomingBlock(i)), V2Size, - V2AAInfo), + PN2->getIncomingValueForBlock(PN->getIncomingBlock(i)), V2Size), AAQI); if (Alias) *Alias = MergeAliasResults(*Alias, ThisAlias); @@ -1398,8 +1393,8 @@ AAQueryInfo *UseAAQI = BlockInserted ? &NewAAQI : &AAQI; AliasResult Alias = getBestAAResults().alias( - MemoryLocation(V2, V2Size, V2AAInfo), - MemoryLocation(V1Srcs[0], PNSize, PNAAInfo), *UseAAQI); + MemoryLocation(V2, V2Size), + MemoryLocation(V1Srcs[0], PNSize), *UseAAQI); // Early exit if the check of the first PHI source against V2 is MayAlias. // Other results are not possible. @@ -1416,8 +1411,7 @@ Value *V = V1Srcs[i]; AliasResult ThisAlias = getBestAAResults().alias( - MemoryLocation(V2, V2Size, V2AAInfo), - MemoryLocation(V, PNSize, PNAAInfo), *UseAAQI); + MemoryLocation(V2, V2Size), MemoryLocation(V, PNSize), *UseAAQI); Alias = MergeAliasResults(ThisAlias, Alias); if (Alias == MayAlias) break; @@ -1429,9 +1423,7 @@ /// Provides a bunch of ad-hoc rules to disambiguate in common cases, such as /// array references. AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size, - const AAMDNodes &V1AAInfo, const Value *V2, LocationSize V2Size, - const AAMDNodes &V2AAInfo, AAQueryInfo &AAQI) { // If either of the memory references is empty, it doesn't matter what the // pointer values are. @@ -1537,8 +1529,8 @@ // Check the cache before climbing up use-def chains. This also terminates // otherwise infinitely recursive queries. - AAQueryInfo::LocPair Locs(MemoryLocation(V1, V1Size, V1AAInfo), - MemoryLocation(V2, V2Size, V2AAInfo)); + AAQueryInfo::LocPair Locs(MemoryLocation(V1, V1Size), + MemoryLocation(V2, V2Size)); if (V1 > V2) std::swap(Locs.first, Locs.second); const auto &Pair = AAQI.AliasCache.try_emplace( @@ -1555,8 +1547,8 @@ int OrigNumAssumptionUses = AAQI.NumAssumptionUses; unsigned OrigNumAssumptionBasedResults = AAQI.AssumptionBasedResults.size(); - AliasResult Result = aliasCheckRecursive(V1, V1Size, V1AAInfo, V2, V2Size, - V2AAInfo, AAQI, O1, O2); + AliasResult Result = + aliasCheckRecursive(V1, V1Size, V2, V2Size, AAQI, O1, O2); auto It = AAQI.AliasCache.find(Locs); assert(It != AAQI.AliasCache.end() && "Must be in cache"); @@ -1587,41 +1579,35 @@ } AliasResult BasicAAResult::aliasCheckRecursive( - const Value *V1, LocationSize V1Size, const AAMDNodes &V1AAInfo, - const Value *V2, LocationSize V2Size, const AAMDNodes &V2AAInfo, + const Value *V1, LocationSize V1Size, + const Value *V2, LocationSize V2Size, AAQueryInfo &AAQI, const Value *O1, const Value *O2) { if (const GEPOperator *GV1 = dyn_cast(V1)) { - AliasResult Result = - aliasGEP(GV1, V1Size, V1AAInfo, V2, V2Size, V2AAInfo, O1, O2, AAQI); + AliasResult Result = aliasGEP(GV1, V1Size, V2, V2Size, O1, O2, AAQI); if (Result != MayAlias) return Result; } else if (const GEPOperator *GV2 = dyn_cast(V2)) { - AliasResult Result = - aliasGEP(GV2, V2Size, V2AAInfo, V1, V1Size, V1AAInfo, O2, O1, AAQI); + AliasResult Result = aliasGEP(GV2, V2Size, V1, V1Size, O2, O1, AAQI); if (Result != MayAlias) return Result; } if (const PHINode *PN = dyn_cast(V1)) { - AliasResult Result = - aliasPHI(PN, V1Size, V1AAInfo, V2, V2Size, V2AAInfo, AAQI); + AliasResult Result = aliasPHI(PN, V1Size, V2, V2Size, AAQI); if (Result != MayAlias) return Result; } else if (const PHINode *PN = dyn_cast(V2)) { - AliasResult Result = - aliasPHI(PN, V2Size, V2AAInfo, V1, V1Size, V1AAInfo, AAQI); + AliasResult Result = aliasPHI(PN, V2Size, V1, V1Size, AAQI); if (Result != MayAlias) return Result; } if (const SelectInst *S1 = dyn_cast(V1)) { - AliasResult Result = - aliasSelect(S1, V1Size, V1AAInfo, V2, V2Size, V2AAInfo, AAQI); + AliasResult Result = aliasSelect(S1, V1Size, V2, V2Size, AAQI); if (Result != MayAlias) return Result; } else if (const SelectInst *S2 = dyn_cast(V2)) { - AliasResult Result = - aliasSelect(S2, V2Size, V2AAInfo, V1, V1Size, V1AAInfo, AAQI); + AliasResult Result = aliasSelect(S2, V2Size, V1, V1Size, AAQI); if (Result != MayAlias) return Result; }