[AA] Allow for flow-sensitive analyses.

[davidtgoldblatt]

Summary

All current analyses ignore the context. We make the argument mandatory
for analyses, but optional for the query interface.

[davidtgoldblatt]

Fixing an arc screwup

[davidtgoldblatt]

This (and subsequent diffs in the stack) is something I've been experimenting with at Meta (hence the "facebook" comment markers, which are just an accident of our internal patch tracking and will get removed if this direction gets support).

The end goal is to allow library code to express aliasing invariants that it knows but that cannot be easily deduced by alias analyses. The simplest example of these is std::vector; modifications to its contents can't change the vector itself, but there's no way to deduce this in general (see e.g. this blog post: https://travisdowns.github.io/blog/2019/08/26/vector-inc.html). Instead, within the vector implementation, we can add __builtin_experimental_separate_storage(this, this->_M_data) in accessors; this is a new builtin that results in UB if the two arguments did not come from the same allocation.

This isn't ready to merge, because of the statelessness issue called out in invalidate(). If there is buy-in for the overall approach, I'm happy to generalize the assumption cache to support more than just assumptions, allowing an efficient implementation.

With a couple judicious insertions, it's shown promising results in some extracted performance-sensitive code kernels (around a 5% speed improvement in a thrift serialization function when we assert that the output buffer does not alias the thrift parse state, and around a 30% speed improvement to a numerical loop that became vectorizable when the array contents don't alias). Just inserting the hints into std::vector results in around an 0.05% improvement in generated code size in a variety of large server workloads. We can also add additional builtins to support things like std::string or SmallVector; using the current builtin would not be correct for them as written (because they embed their storage alongside their control data down certain paths).

This is vaguely similar to restrict, but restrict can't address some of the issues that these hints can. In particular, restrict is local to a function, and so can't propagate its semantic requirements to callers and callees after inlining.

[davidtgoldblatt]

Removing from draft to get some feedback, but still more or less an RFC at the moment.

Added as reviewer anyone subscribed to AA changes + @wenlei, who's seen some of the evolution here.

[nikic]

Some initial notes:

• Rather than adding a separate aliasAt() API, we should add an extra optional argument to alias(). Especially when it comes to the Concept/Model/Base I don't see a value in having both alias() and aliasAt().
• An important limitation (which your patches do get right) is that BasicAA must not make use of the context instruction, otherwise it would invalidate our caching strategy. This does mean that recursive queries will not be able to benefit from the context instruction (or they would need to use a different context instruction that only depends on the memory locations, which is tricky in itself due to symmetry requirements).
• I don't really understand your invalidation troubles in the new AA pass. Your current implementation has a high compile-time impact (1% geomean on ctmark), but I think this mainly comes down to the fact that you are unnecessarily recalculating the dominator tree many times -- why doesn't this fetch the DT from the pass manager? BasicAA already does this, so it should be available and work fine. (Note that this is not just a performance concern, your current implementation is incorrect if the DT is updated within a pass -- this will update the DT from the PM, but not your internal instance.)
• It might make sense to use an assume operand bundle rather than a separate intrinsic, something like call void @llvm.assume(i1 true) ["noalias"(ptr %o1, ptr %o2)]. This could give you various things like ephemeral value skipping for "free". And probably also integrates with AssumptionCache already. Not sure if there's any downsides to this representation.
• The second patch does not apply cleanly, because your base sources seem to register an additional objc AA pass.

Generally, the approach looks viable to me though. To suggest a possible alternative, it should be possible to make some other pass add scoped noalias metadata to accesses based on this intrinsic. Not sure this would be better though.

[davidtgoldblatt]

Rather than adding a separate aliasAt() API, we should add an extra optional argument to alias(). Especially when it comes to the Concept/Model/Base I don't see a value in having both alias() and aliasAt().

Agreed, that's better.

An important limitation (which your patches do get right) is that BasicAA must not make use of the context instruction, otherwise it would invalidate our caching strategy. This does mean that recursive queries will not be able to benefit from the context instruction (or they would need to use a different context instruction that only depends on the memory locations, which is tricky in itself due to symmetry requirements).

Yeah. I think it's possible to extend it in certain cases, but didn't feel sure enough to try it.

I don't really understand your invalidation troubles in the new AA pass. Your current implementation has a high compile-time impact (1% geomean on ctmark), but I think this mainly comes down to the fact that you are unnecessarily recalculating the dominator tree many times -- why doesn't this fetch the DT from the pass manager? BasicAA already does this, so it should be available and work fine. (Note that this is not just a performance concern, your current implementation is incorrect if the DT is updated within a pass -- this will update the DT from the PM, but not your internal instance.)

I think practically the reason is that BasicAA is still fairly useful without the dominator tree, while SeparateStorageAA is much less so. But a hard DT dependency is somewhat burdensome because any AA result being invalidated acts to invalidate all of them (just because of the invalidate implementation in AAResults). But I think it's just a bullet this has to bite given the correctness/compile-time problems.

It might make sense to use an assume operand bundle rather than a separate intrinsic, something like call void @llvm.assume(i1 true) ["noalias"(ptr %o1, ptr %o2)]. This could give you various things like ephemeral value skipping for "free". And probably also integrates with AssumptionCache already. Not sure if there's any downsides to this representation.

This is a good idea, I'll do that. This also nicely solves various other annoyances: duplicated special-casing logic, the possibility of failing to notice intrinsic creations due to duplication when cloning, etc.

The second patch does not apply cleanly, because your base sources seem to register an additional objc AA pass.

Will fix.

To suggest a possible alternative, it should be possible to make some other pass add scoped noalias metadata to accesses based on this intrinsic. Not sure this would be better though.

I did some experiments in this direction; it turned out trickier than I expected because of the impedance mismatch with noalias scopes. Example: changes in control flow (inlining, DCE, etc.) can cause a llvm.experimental.separate.storage call to start dominating an instruction it previously didn't, but we'd need to re-run a metadata propagation pass for subsequent AA queries to notice. Entirely possible it's just due to me being dumb, but the similarity between the semantics of this and assumes make the operand-bundle approach feel right.

[nikic]

I don't really understand your invalidation troubles in the new AA pass. Your current implementation has a high compile-time impact (1% geomean on ctmark), but I think this mainly comes down to the fact that you are unnecessarily recalculating the dominator tree many times -- why doesn't this fetch the DT from the pass manager? BasicAA already does this, so it should be available and work fine. (Note that this is not just a performance concern, your current implementation is incorrect if the DT is updated within a pass -- this will update the DT from the PM, but not your internal instance.)

I think practically the reason is that BasicAA is still fairly useful without the dominator tree, while SeparateStorageAA is much less so. But a hard DT dependency is somewhat burdensome because any AA result being invalidated acts to invalidate all of them (just because of the invalidate implementation in AAResults). But I think it's just a bullet this has to bite given the correctness/compile-time problems.

BasicAA currently has a hard dependency on DominatorTree, it's not an optional analysis. So it should really be in the same boat as SeparateStorageAA... (We could make DT optional in BasicAA, but that's not how it is right now.)

[davidtgoldblatt]

Update per review comments.

[hiraditya]

llvm/include/llvm/Analysis/AliasAnalysis.h

318

I can be nullptr

Which I is this referring to?

[davidtgoldblatt]

Fix build, move out-of-date comment.

[davidtgoldblatt]

llvm/include/llvm/Analysis/AliasAnalysis.h

318

Woops, that should have been down below, on the internal query function.

[davidtgoldblatt]

ping @nikic, would you mind taking another look? I think with the changes you suggested this ends up as a much cleaner stack (being able to avoid duplicating so much of the assume handling really cuts down). My followup plan is to expand this to handle the possibility of inline storage (e.g. the small string optimization), which is where we incur more of the costs, but I'd rather build on something stable before going much further.

[nikic]

This looks fine, just some style nits.

llvm/include/llvm/Analysis/AliasAnalysis.h

624–629

We'd usually call this CxtI (the "context instruction").

760

You probably don't need = nullptr here and basically anywhere that is not public API.

llvm/include/llvm/Analysis/CFLSteensAliasAnalysis.h

70

I don't think such comments are typical in LLVM.

[davidtgoldblatt]

Per review comments.

[davidtgoldblatt]

Thanks, think I caught everything this time around.

[nikic]

LGTM

[nikic]

llvm/include/llvm/Analysis/CFLSteensAliasAnalysis.h

80

Just a note: You pass through CtxI to AAResultBase::alias() in some places, but not in others. Of course, this doesn't make any practical difference, because AAResultBase::alias() is a no-op that ignores all arguments. We should probably still either do one or the other for consistency.

(I'm kind of wondering if we shouldn't drop all these AAResultBase calls and just replace them with the appropriate values. I get the impression that these are causing a lot more confusion than they clarify, because people think they perform recursive AA, which they don't.)

[davidtgoldblatt]

llvm/include/llvm/Analysis/CFLSteensAliasAnalysis.h

80

Will fix; and agreed that it's better to just have all these return MayAlias instead of returning the base implementation and doing it indirectly (I think a vestige of when this stuff was CRTP-ified?).

Happy to put up a cleanup diff once it won't trigger any merge conflicts.

[davidtgoldblatt]

Clean up nit.

[nikic]

LG

[wenlei]

I pushed the first 2 (accepted) patches on behalf of David, since David doesn't have commit access yet.

llvm/include/llvm/Analysis/AliasAnalysis.h

public:
 
   //===--------------------------------------------------------------------===//
   /// \name Alias Queries
   /// @{
 
   /// The main low level interface to the alias analysis implementation.
   /// Returns an AliasResult indicating whether the two pointers are aliased to
   /// each other. This is the interface that must be implemented by specific
   /// alias analysis implementations.
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB);
 
+  // facebook begin T130678741
+  // I can be NULL, in which case we're querying as to whether an aliasing
+  // relationship holds through the entire function.
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *I);
+  // facebook end T130678741
+
   /// A convenience wrapper around the primary \c alias interface.
   AliasResult alias(const Value *V1, LocationSize V1Size, const Value *V2,
                     LocationSize V2Size) {
     return alias(MemoryLocation(V1, V1Size), MemoryLocation(V2, V2Size));
   }
 
   /// A convenience wrapper around the primary \c alias interface.
   AliasResult alias(const Value *V1, const Value *V2) {
public:
   /// A convenience wrapper synthesizing a memory location.
   bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2,
                                  const Value *Ptr, LocationSize Size,
                                  const ModRefInfo Mode) {
     return canInstructionRangeModRef(I1, I2, MemoryLocation(Ptr, Size), Mode);
   }
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
-                    AAQueryInfo &AAQI);
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *I, AAQueryInfo &AAQI);
+  // facebook end T130678741
+
   bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI,
                               bool OrLocal = false);
   ModRefInfo getModRefInfo(Instruction *I, const CallBase *Call2,
                            AAQueryInfo &AAQIP);
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
   ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2,
                            AAQueryInfo &AAQI);
public:
   /// @{
 
   /// The main low level interface to the alias analysis implementation.
   /// Returns an AliasResult indicating whether the two pointers are aliased to
   /// each other. This is the interface that must be implemented by specific
   /// alias analysis implementations.
   virtual AliasResult alias(const MemoryLocation &LocA,
                             const MemoryLocation &LocB, AAQueryInfo &AAQI) = 0;
 
+  // facebook begin T130678741
+  // For flow-sensitive queries
+  virtual AliasResult aliasAt(const MemoryLocation &LocA,
+                              const MemoryLocation &LocB, const Instruction *I,
+                              AAQueryInfo &AAQI) = 0;
+  // facebook end T130678741
+
   /// Checks whether the given location points to constant memory, or if
   /// \p OrLocal is true whether it points to a local alloca.
   virtual bool pointsToConstantMemory(const MemoryLocation &Loc,
                                       AAQueryInfo &AAQI, bool OrLocal) = 0;
 
   /// @}
   //===--------------------------------------------------------------------===//
   /// \name Simple mod/ref information
public:
   explicit Model(AAResultT &Result, AAResults &AAR) : Result(Result) {}
   ~Model() override = default;
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI) override {
     return Result.alias(LocA, LocB, AAQI);
   }
 
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *I, AAQueryInfo &AAQI) override {
+    return Result.aliasAt(LocA, LocB, I, AAQI);
+  }
+  // facebook end T130678741
+
   bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI,
                               bool OrLocal) override {
     return Result.pointsToConstantMemory(Loc, AAQI, OrLocal);
   }
 
   ModRefInfo getArgModRefInfo(const CallBase *Call, unsigned ArgIdx) override {
     return Result.getArgModRefInfo(Call, ArgIdx);
   }
protected:
   AAResultBase(AAResultBase &&Arg) {}
 
 public:
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI) {
     return AliasResult::MayAlias;
   }
 
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *I, AAQueryInfo &AAQI) {
+    return AliasResult::MayAlias;
+  }
+  // facebook end T130678741
+
   bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI,
                               bool OrLocal) {
     return false;
   }
 
   ModRefInfo getArgModRefInfo(const CallBase *Call, unsigned ArgIdx) {
     return ModRefInfo::ModRef;
   }

llvm/include/llvm/Analysis/BasicAliasAnalysis.h

BasicAAResult(BasicAAResult &&Arg)
         AC(Arg.AC), DT(Arg.DT), PV(Arg.PV) {}
 
   /// Handle invalidation events in the new pass manager.
   bool invalidate(Function &Fn, const PreservedAnalyses &PA,
                   FunctionAnalysisManager::Invalidator &Inv);
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI);
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *, AAQueryInfo &AAQI) {
+    return alias(LocA, LocB, AAQI);
+  }
+  // facebook end T130678741
 
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
 
   ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2,
                            AAQueryInfo &AAQI);
 
   /// Chases pointers until we find a (constant global) or not.

llvm/include/llvm/Analysis/CFLAndersAliasAnalysis.h

public:
 
   /// Get the alias summary for the given function
   /// Return nullptr if the summary is not found or not available
   const cflaa::AliasSummary *getAliasSummary(const Function &);
 
   AliasResult query(const MemoryLocation &, const MemoryLocation &);
   AliasResult alias(const MemoryLocation &, const MemoryLocation &,
                     AAQueryInfo &);
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *, AAQueryInfo &AAQI) {
+    return alias(LocA, LocB, AAQI);
+  }
+  // facebook end T130678741
 
 private:
   /// Ensures that the given function is available in the cache.
   /// Returns the appropriate entry from the cache.
   const Optional<FunctionInfo> &ensureCached(const Function &);
 
   /// Inserts the given Function into the cache.
   void scan(const Function &);

llvm/include/llvm/Analysis/CFLSteensAliasAnalysis.h

public:
 
   /// Get the alias summary for the given function
   /// Return nullptr if the summary is not found or not available
   const cflaa::AliasSummary *getAliasSummary(Function &Fn);
 
   AliasResult query(const MemoryLocation &LocA, const MemoryLocation &LocB);
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI) {
     if (LocA.Ptr == LocB.Ptr)
       return AliasResult::MustAlias;
 
     // Comparisons between global variables and other constants should be
     // handled by BasicAA.
     // CFLSteensAA may report NoAlias when comparing a GlobalValue and
     // ConstantExpr, but every query needs to have at least one Value tied to a
     // Function, and neither GlobalValues nor ConstantExprs are.
     if (isa<Constant>(LocA.Ptr) && isa<Constant>(LocB.Ptr))
       return AAResultBase::alias(LocA, LocB, AAQI);
 
     AliasResult QueryResult = query(LocA, LocB);
     if (QueryResult == AliasResult::MayAlias)
       return AAResultBase::alias(LocA, LocB, AAQI);
 
     return QueryResult;
   }
 
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *, AAQueryInfo &AAQI) {
+    return alias(LocA, LocB, AAQI);
+  }
+  // facebook end T130678741
+
 private:
   std::function<const TargetLibraryInfo &(Function &)> GetTLI;
 
   /// Cached mapping of Functions to their StratifiedSets.
   /// If a function's sets are currently being built, it is marked
   /// in the cache as an Optional without a value. This way, if we
   /// have any kind of recursion, it is discernable from a function
   /// that simply has empty sets.

llvm/include/llvm/Analysis/GlobalsModRef.h

analyzeModule(Module &M,
                 CallGraph &CG);
 
   //------------------------------------------------
   // Implement the AliasAnalysis API
   //
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI);
 
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *, AAQueryInfo &AAQI) {
+    return alias(LocA, LocB, AAQI);
+  }
+  // facebook end T130678741
+
   using AAResultBase::getModRefInfo;
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
 
   using AAResultBase::getMemoryEffects;
   /// getMemoryEffects - Return the behavior of the specified function if
   /// called from the specified call site.  The call site may be null in which
   /// case the most generic behavior of this function should be returned.

llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h

public:
   /// By definition, this result is stateless and so remains valid.
   bool invalidate(Function &, const PreservedAnalyses &,
                   FunctionAnalysisManager::Invalidator &) {
     return false;
   }
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI);
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *, AAQueryInfo &AAQI) {
+    return alias(LocA, LocB, AAQI);
+  }
+  // facebook end T130678741
   bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI,
                               bool OrLocal);
 
   using AAResultBase::getMemoryEffects;
   MemoryEffects getMemoryEffects(const Function *F);
 
   using AAResultBase::getModRefInfo;
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,

llvm/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h

 
 public:
   explicit SCEVAAResult(ScalarEvolution &SE) : SE(SE) {}
   SCEVAAResult(SCEVAAResult &&Arg) : AAResultBase(std::move(Arg)), SE(Arg.SE) {}
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI);
 
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *, AAQueryInfo &AAQI) {
+    return alias(LocA, LocB, AAQI);
+  }
+  // facebook end T130678741
+
   bool invalidate(Function &F, const PreservedAnalyses &PA,
                   FunctionAnalysisManager::Invalidator &Inv);
 
 private:
   Value *GetBaseValue(const SCEV *S);
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.

llvm/include/llvm/Analysis/ScopedNoAliasAA.h

public:
   /// By definition, this result is stateless and so remains valid.
   bool invalidate(Function &, const PreservedAnalyses &,
                   FunctionAnalysisManager::Invalidator &) {
     return false;
   }
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI);
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *, AAQueryInfo &AAQI) {
+    return alias(LocA, LocB, AAQI);
+  }
+  // facebook end T130678741
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
   ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2,
                            AAQueryInfo &AAQI);
 
 private:
   bool mayAliasInScopes(const MDNode *Scopes, const MDNode *NoAlias) const;
 };

llvm/include/llvm/Analysis/TypeBasedAliasAnalysis.h

public:
   /// By definition, this result is stateless and so remains valid.
   bool invalidate(Function &, const PreservedAnalyses &,
                   FunctionAnalysisManager::Invalidator &) {
     return false;
   }
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI);
+  // facebook begin T130678741
+  AliasResult aliasAt(const MemoryLocation &LocA, const MemoryLocation &LocB,
+                      const Instruction *, AAQueryInfo &AAQI) {
+    return alias(LocA, LocB, AAQI);
+  }
+  // facebook end T130678741
+
   bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI,
                               bool OrLocal);
   MemoryEffects getMemoryEffects(const CallBase *Call, AAQueryInfo &AAQI);
   MemoryEffects getMemoryEffects(const Function *F);
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
   ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2,
                            AAQueryInfo &AAQI);

llvm/lib/Analysis/AliasAnalysis.cpp

 AliasResult AAResults::alias(const MemoryLocation &LocA,
                              const MemoryLocation &LocB) {
   SimpleAAQueryInfo AAQIP(*this);
   return alias(LocA, LocB, AAQIP);
 }
 
 AliasResult AAResults::alias(const MemoryLocation &LocA,
                              const MemoryLocation &LocB, AAQueryInfo &AAQI) {
+  return aliasAt(LocA, LocB, nullptr, AAQI); // facebook T130678741
+}
+
+// facebook begin T130678741
+AliasResult AAResults::aliasAt(const MemoryLocation &LocA,
+                               const MemoryLocation &LocB, const Instruction *I,
+                               AAQueryInfo &AAQI) {
   AliasResult Result = AliasResult::MayAlias;
 
   if (EnableAATrace) {
     for (unsigned I = 0; I < AAQI.Depth; ++I)
       dbgs() << "  ";
     dbgs() << "Start " << *LocA.Ptr << " @ " << LocA.Size << ", "
            << *LocB.Ptr << " @ " << LocB.Size << "\n";
   }
 
   AAQI.Depth++;
   for (const auto &AA : AAs) {
+    if (I) {
+      Result = AA->aliasAt(LocA, LocB, I, AAQI);
+    } else {
       Result = AA->alias(LocA, LocB, AAQI);
+    }
     if (Result != AliasResult::MayAlias)
       break;
   }
   AAQI.Depth--;
 
   if (EnableAATrace) {
     for (unsigned I = 0; I < AAQI.Depth; ++I)
       dbgs() << "  ";
     dbgs() << "End " << *LocA.Ptr << " @ " << LocA.Size << ", "
            << *LocB.Ptr << " @ " << LocB.Size << " = " << Result << "\n";
   }
 
   if (AAQI.Depth == 0) {
     if (Result == AliasResult::NoAlias)
       ++NumNoAlias;
     else if (Result == AliasResult::MustAlias)
       ++NumMustAlias;
     else
       ++NumMayAlias;
   }
   return Result;
 }
+// facebook end T130678741
 
 bool AAResults::pointsToConstantMemory(const MemoryLocation &Loc,
                                        bool OrLocal) {
   SimpleAAQueryInfo AAQIP(*this);
   return pointsToConstantMemory(Loc, AAQIP, OrLocal);
 }
 
 bool AAResults::pointsToConstantMemory(const MemoryLocation &Loc,
if ((ArgMR | OtherMR) != OtherMR) {
     // on the final result.
     ModRefInfo AllArgsMask = ModRefInfo::NoModRef;
     for (const auto &I : llvm::enumerate(Call->args())) {
       const Value *Arg = I.value();
       if (!Arg->getType()->isPointerTy())
         continue;
       unsigned ArgIdx = I.index();
       MemoryLocation ArgLoc = MemoryLocation::getForArgument(Call, ArgIdx, TLI);
-      AliasResult ArgAlias = alias(ArgLoc, Loc, AAQI);
+      AliasResult ArgAlias = aliasAt(ArgLoc, Loc, Call, AAQI);
       if (ArgAlias != AliasResult::NoAlias)
         AllArgsMask |= getArgModRefInfo(Call, ArgIdx);
     }
     ArgMR &= AllArgsMask;
   }
 
   Result &= ArgMR | OtherMR;
 
ModRefInfo AAResults::getModRefInfo(const LoadInst *L,
                                     AAQueryInfo &AAQI) {
   // Be conservative in the face of atomic.
   if (isStrongerThan(L->getOrdering(), AtomicOrdering::Unordered))
     return ModRefInfo::ModRef;
 
   // If the load address doesn't alias the given address, it doesn't read
   // or write the specified memory.
   if (Loc.Ptr) {
-    AliasResult AR = alias(MemoryLocation::get(L), Loc, AAQI);
+    // facebook begin T130678741
+    AliasResult AR =
+        aliasAt(MemoryLocation::get(L), Loc, L, AAQI);
+    // facebook end T130678741
     if (AR == AliasResult::NoAlias)
       return ModRefInfo::NoModRef;
   }
   // Otherwise, a load just reads.
   return ModRefInfo::Ref;
 }
 
 ModRefInfo AAResults::getModRefInfo(const StoreInst *S,
                                     const MemoryLocation &Loc) {
   SimpleAAQueryInfo AAQIP(*this);
   return getModRefInfo(S, Loc, AAQIP);
 }
 ModRefInfo AAResults::getModRefInfo(const StoreInst *S,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   // Be conservative in the face of atomic.
   if (isStrongerThan(S->getOrdering(), AtomicOrdering::Unordered))
     return ModRefInfo::ModRef;
 
   if (Loc.Ptr) {
-    AliasResult AR = alias(MemoryLocation::get(S), Loc, AAQI);
+    // facebook begin T130678741
+    AliasResult AR = aliasAt(MemoryLocation::get(S), Loc, S, AAQI);
+    // facebook end T130678741
     // If the store address cannot alias the pointer in question, then the
     // specified memory cannot be modified by the store.
     if (AR == AliasResult::NoAlias)
       return ModRefInfo::NoModRef;
 
     // If the pointer is a pointer to constant memory, then it could not have
     // been modified by this store.
     if (pointsToConstantMemory(Loc, AAQI))
ModRefInfo AAResults::getModRefInfo(const VAArgInst *V,
   SimpleAAQueryInfo AAQIP(*this);
   return getModRefInfo(V, Loc, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const VAArgInst *V,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   if (Loc.Ptr) {
-    AliasResult AR = alias(MemoryLocation::get(V), Loc, AAQI);
+    // facebook begin T130678741
+    AliasResult AR = aliasAt(MemoryLocation::get(V), Loc, V, AAQI);
+    // facebook end T130678741
     // If the va_arg address cannot alias the pointer in question, then the
     // specified memory cannot be accessed by the va_arg.
     if (AR == AliasResult::NoAlias)
       return ModRefInfo::NoModRef;
 
     // If the pointer is a pointer to constant memory, then it could not have
     // been modified by this va_arg.
     if (pointsToConstantMemory(Loc, AAQI))

 ModRefInfo AAResults::getModRefInfo(const AtomicCmpXchgInst *CX,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   // Acquire/Release cmpxchg has properties that matter for arbitrary addresses.
   if (isStrongerThanMonotonic(CX->getSuccessOrdering()))
     return ModRefInfo::ModRef;
 
   if (Loc.Ptr) {
-    AliasResult AR = alias(MemoryLocation::get(CX), Loc, AAQI);
+    // facebook begin T130678741
+    AliasResult AR = aliasAt(MemoryLocation::get(CX), Loc, CX, AAQI);
+    // facebook end T130678741
     // If the cmpxchg address does not alias the location, it does not access
     // it.
     if (AR == AliasResult::NoAlias)
       return ModRefInfo::NoModRef;
   }
 
   return ModRefInfo::ModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const AtomicRMWInst *RMW,
                                     const MemoryLocation &Loc) {
   SimpleAAQueryInfo AAQIP(*this);
   return getModRefInfo(RMW, Loc, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const AtomicRMWInst *RMW,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   // Acquire/Release atomicrmw has properties that matter for arbitrary addresses.
   if (isStrongerThanMonotonic(RMW->getOrdering()))
     return ModRefInfo::ModRef;
 
   if (Loc.Ptr) {
-    AliasResult AR = alias(MemoryLocation::get(RMW), Loc, AAQI);
+    // facebook begin T130678741
+    AliasResult AR = aliasAt(MemoryLocation::get(RMW), Loc, RMW, AAQI);
+    // facebook end T130678741
     // If the atomicrmw address does not alias the location, it does not access
     // it.
     if (AR == AliasResult::NoAlias)
       return ModRefInfo::NoModRef;
   }
 
   return ModRefInfo::ModRef;
 }
for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end();
     // Only look at the no-capture or byval pointer arguments.  If this
     // pointer were passed to arguments that were neither of these, then it
     // couldn't be no-capture.
     if (!(*CI)->getType()->isPointerTy() ||
         (!Call->doesNotCapture(ArgNo) && ArgNo < Call->arg_size() &&
          !Call->isByValArgument(ArgNo)))
       continue;
 
-    AliasResult AR = alias(
+    // facebook begin T130678741
+    AliasResult AR = aliasAt(
         MemoryLocation::getBeforeOrAfter(*CI),
-        MemoryLocation::getBeforeOrAfter(Object), AAQI);
+        MemoryLocation::getBeforeOrAfter(Object), Call, AAQI);
+    // facebook end T130678741
     // If this is a no-capture pointer argument, see if we can tell that it
     // 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 (AR == AliasResult::NoAlias)
       continue;
     if (Call->doesNotAccessMemory(ArgNo))
       continue;