add 2 functions to the ALiasAnalysis interface (getAddressesDistance + ModRefSameBuffer)

[atheel.ma]

Summary

bool ModRefSameBuffer: returns if 2 Locations Mod/Ref same buff (same block in memory)
getAddressesDistance : returns the distance between 2 Locations if there are modifying the same block in memory and distance can be calculated

[hfinkel]

Can you please comment on how you intend to implement the interface and how you'd like to use it?

[atheel.ma]

Hi,
its very similar to the BasicAliasAnalysis aliasCheck() functions,
the declerations for the private function is:

BuffUseResult BasicAAResult::ModRefSameBufferCheck(
    const Value *V1, uint64_t V1Size, AAMDNodes V1AAInfo, int64_t ptr1Offset,
	const Value *V2, uint64_t V2Size, AAMDNodes V2AAInfo, int64_t ptr2Offset,
	Optional<int64_t> &LocDistance, const Value *O1, const Value *O2) { ... }

were ptr1Offset is "MMOa->getPointerInfo().Offset"

inside I will try to get to the GEP of the 2 memory operands this will tell me if its the same buffer (memory block)
I may pass throw PHI and SELECT nodes like in aliasCheck(),
after i will have 2 GEP I will calculate the distance using:

int64_t GEP1BaseOffset =
          DecompGEP1.StructOffset + DecompGEP1.OtherOffset + ptr1Offset;
      int64_t GEP2BaseOffset =
          DecompGEP2.StructOffset + DecompGEP2.OtherOffset + ptr2Offset;
      LocDistance = GEP2BaseOffset - GEP1BaseOffset;

and I will save it inside a cache like aliasCache...

I have implemented it and test it on my Core and it works for most cases...
it helps for detecting "Bank conflicts", when two memory instructions Mod/Ref from the same memory block, I can check if its also in the same bank if I have the distance between them and the size of each one of them...

the 2 functions I have added is generic and maybe other users will use it for something else...
If you also see how useful it is I will add a new patch with a first implementation (on BasicAliasAnalysis)

for being more clear, the call for the private function would be:

Optional<int64_t>
BasicAAResult::getAddressesDistance(const MemoryLocation &LocA,
	int64_t ptr1Offset, const MemoryLocation &LocB, int64_t ptr2Offset) {
  // LocA-LocB
  Optional<int64_t> LocDistance;
  BuffUseResult sameBuff =
      ModRefSameBufferCheck(LocA.Ptr, LocA.Size, LocA.AATags, ptr1Offset, 
		  LocB.Ptr, LocB.Size, LocB.AATags, ptr2Offset, LocDistance);

	return LocDistance;
}

[asbirlea]

Would be good if you can also add an implementation of this API (in a dependent patch).
I'm not entirely clear on the use yet, e.g. "BuffUseResult sameBuff" in your example is never used. An actual implementation would help with understanding and reviewing.

[atheel.ma]

implementation example added under:
https://reviews.llvm.org/D46928#1100610

[asbirlea]

Considered obsolete. Readd if active.

include/llvm/Analysis/AliasAnalysis.h

enum AliasResult : uint8_t {
   /// The two locations may or may not alias. This is the least precise result.
   MayAlias,
   /// The two locations alias, but only due to a partial overlap.
   PartialAlias,
   /// The two locations precisely alias each other.
   MustAlias,
 };
 
+enum BuffUseResult {
+  /// the two locations cant use the same memory block
+  NotSameBuff = 0,
+  /// The two locations may or may not use the same memory block. This is the
+  /// least precise result.
+  MayUseSameBuff,
+  /// The two locations precisely use the same memory block.
+  MustUseSameBuff
+
+};
 /// Flags indicating whether a memory access modifies or references memory.
 ///
 /// This is no access at all, a modification, a reference, or both
 /// a modification and a reference. These are specifically structured such that
 /// they form a three bit matrix and bit-tests for 'mod' or 'ref' or 'must'
 /// work with any of the possible values.
 enum class ModRefInfo : uint8_t {
   /// Must is provided for completeness, but no routines will return only
public:
   bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal = false);
 
   /// A convenience wrapper around the primary \c pointsToConstantMemory
   /// interface.
   bool pointsToConstantMemory(const Value *P, bool OrLocal = false) {
     return pointsToConstantMemory(MemoryLocation(P), OrLocal);
   }
 
+  /// Checks whether the given locations points to the same buffer.
+  bool ModRefSameBuffer(const MemoryLocation &LocA, int64_t ptr1Offset,
+                        const MemoryLocation &LocB, int64_t ptr2Offset);
+
+  /// A convenience wrapper around the \c ModRefSameBuffer helper interface.
+  bool ModRefSameBuffer(const Value *V1, int64_t ptr1Offset, const Value *V2,
+                        int64_t ptr2Offset) {
+    return ModRefSameBuffer(MemoryLocation(V1), ptr1Offset, MemoryLocation(V2),
+                            ptr2Offset);
+  }
   /// @}
   //===--------------------------------------------------------------------===//
   /// \name Simple mod/ref information
   /// @{
 
   /// Get the ModRef info associated with a pointer argument of a callsite. The
   /// result's bits are set to indicate the allowed aliasing ModRef kinds. Note
   /// that these bits do not necessarily account for the overall behavior of
   /// the function, but rather only provide additional per-argument
   /// information. This never sets ModRefInfo::Must.
   ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx);
 
   /// Return the behavior of the given call site.
   FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS);
 
   /// Return the behavior when calling the given function.
   FunctionModRefBehavior getModRefBehavior(const Function *F);
+  /// Return the Distance between 2 address.
+  Optional<int64_t> getAddressesDistance(const MemoryLocation &LocA,
+                                         int64_t ptr1Offset,
+                                         const MemoryLocation &LocB,
+                                         int64_t ptr2Offset);
+
+  Optional<int64_t> getAddressesDistance(const Value *V1, int64_t ptr1Offset,
+                                         const Value *V2, int64_t ptr2Offset) {
+    return getAddressesDistance(MemoryLocation(V1), ptr1Offset,
+                                MemoryLocation(V2), ptr2Offset);
+  }
 
   /// Checks if the specified call is known to never read or write memory.
   ///
   /// Note that if the call only reads from known-constant memory, it is also
   /// legal to return true. Also, calls that unwind the stack are legal for
   /// this predicate.
   ///
   /// Many optimizations (such as CSE and LICM) can be performed on such calls
public:
   virtual AliasResult alias(const MemoryLocation &LocA,
                             const MemoryLocation &LocB) = 0;
 
   /// 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,
                                       bool OrLocal) = 0;
 
+  /// Checks whether the given locations points to the same buffer.
+  virtual bool ModRefSameBuffer(const MemoryLocation &LocA, int64_t ptr1Offset,
+                                const MemoryLocation &LocB,
+                                int64_t ptr2Offset) = 0;
   /// @}
   //===--------------------------------------------------------------------===//
   /// \name Simple mod/ref information
   /// @{
 
   /// Get the ModRef info associated with a pointer argument of a callsite. The
   /// result's bits are set to indicate the allowed aliasing ModRef kinds. Note
   /// that these bits do not necessarily account for the overall behavior of
virtual ModRefInfo getModRefInfo(ImmutableCallSite CS,
                                    const MemoryLocation &Loc) = 0;
 
   /// Return information about whether two call sites may refer to the same set
   /// of memory locations. See the AA documentation for details:
   ///   http://llvm.org/docs/AliasAnalysis.html#ModRefInfo
   virtual ModRefInfo getModRefInfo(ImmutableCallSite CS1,
                                    ImmutableCallSite CS2) = 0;
 
+  /// Return the Distance between 2 address.
+  virtual Optional<int64_t> getAddressesDistance(const MemoryLocation &LocA,
+                                                 int64_t ptr1Offset,
+                                                 const MemoryLocation &LocB,
+                                                 int64_t ptr2Offset) = 0;
   /// @}
 };
 
 /// A private class template which derives from \c Concept and wraps some other
 /// type.
 ///
 /// This models the concept by directly forwarding each interface point to the
 /// wrapped type which must implement a compatible interface. This provides
AliasResult alias(const MemoryLocation &LocA,
                     const MemoryLocation &LocB) override {
     return Result.alias(LocA, LocB);
   }
 
   bool pointsToConstantMemory(const MemoryLocation &Loc,
                               bool OrLocal) override {
     return Result.pointsToConstantMemory(Loc, OrLocal);
   }
+  bool ModRefSameBuffer(const MemoryLocation &LocA, int64_t ptr1Offset,
+                        const MemoryLocation &LocB,
+                        int64_t ptr2Offset) override {
+    return Result.ModRefSameBuffer(LocA, ptr1Offset, LocB, ptr2Offset);
+  }
 
   ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) override {
     return Result.getArgModRefInfo(CS, ArgIdx);
   }
 
   FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) override {
     return Result.getModRefBehavior(CS);
   }
 
   FunctionModRefBehavior getModRefBehavior(const Function *F) override {
     return Result.getModRefBehavior(F);
   }
 
   ModRefInfo getModRefInfo(ImmutableCallSite CS,
                            const MemoryLocation &Loc) override {
     return Result.getModRefInfo(CS, Loc);
   }
 
   ModRefInfo getModRefInfo(ImmutableCallSite CS1,
                            ImmutableCallSite CS2) override {
     return Result.getModRefInfo(CS1, CS2);
   }
+  Optional<int64_t> getAddressesDistance(const MemoryLocation &LocA,
+                                         int64_t ptr1Offset,
+                                         const MemoryLocation &LocB,
+                                         int64_t ptr2Offset) override {
+    return Result.getAddressesDistance(LocA, ptr1Offset, LocB, ptr2Offset);
+  }
 };
 
 /// A CRTP-driven "mixin" base class to help implement the function alias
 /// analysis results concept.
 ///
 /// Because of the nature of many alias analysis implementations, they often
 /// only implement a subset of the interface. This base class will attempt to
 /// implement the remaining portions of the interface in terms of simpler forms
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
       return AAR ? AAR->alias(LocA, LocB) : CurrentResult.alias(LocA, LocB);
     }
 
     bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) {
       return AAR ? AAR->pointsToConstantMemory(Loc, OrLocal)
                  : CurrentResult.pointsToConstantMemory(Loc, OrLocal);
     }
 
+    bool ModRefSameBuffer(const MemoryLocation &LocA, int64_t ptr1Offset,
+                          const MemoryLocation &LocB, int64_t ptr2Offset) {
+      return AAR ? AAR->ModRefSameBuffer(LocA, ptr1Offset, LocB, ptr2Offset)
+                 : CurrentResult.ModRefSameBuffer(LocA, ptr1Offset, LocB,
+                                                  ptr2Offset);
+    }
     ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) {
       return AAR ? AAR->getArgModRefInfo(CS, ArgIdx) : CurrentResult.getArgModRefInfo(CS, ArgIdx);
     }
 
     FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) {
       return AAR ? AAR->getModRefBehavior(CS) : CurrentResult.getModRefBehavior(CS);
     }
 
     FunctionModRefBehavior getModRefBehavior(const Function *F) {
       return AAR ? AAR->getModRefBehavior(F) : CurrentResult.getModRefBehavior(F);
     }
 
     ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc) {
       return AAR ? AAR->getModRefInfo(CS, Loc)
                  : CurrentResult.getModRefInfo(CS, Loc);
     }
 
     ModRefInfo getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) {
       return AAR ? AAR->getModRefInfo(CS1, CS2) : CurrentResult.getModRefInfo(CS1, CS2);
     }
+    Optional<int64_t> getAddressesDistance(const MemoryLocation &LocA,
+                                           int64_t ptr1Offset,
+                                           const MemoryLocation &LocB,
+                                           int64_t ptr2Offset) {
+      return AAR ? AAR->getAddressesDistance(LocA, ptr1Offset, LocB, ptr2Offset)
+                 : CurrentResult.getAddressesDistance(LocA, ptr1Offset, LocB,
+                                                      ptr2Offset);
+    }
   };
 
   explicit AAResultBase() = default;
 
   // Provide all the copy and move constructors so that derived types aren't
   // constrained.
   AAResultBase(const AAResultBase &Arg) {}
   AAResultBase(AAResultBase &&Arg) {}

 public:
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
     return MayAlias;
   }
 
   bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) {
     return false;
   }
+  bool ModRefSameBuffer(const MemoryLocation &LocA, int64_t ptr1Offset,
+                        const MemoryLocation &LocB, int64_t ptr2Offset) {
+    return false;
+  }
 
   ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) {
     return ModRefInfo::ModRef;
   }
 
   FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) {
     return FMRB_UnknownModRefBehavior;
   }
 
   FunctionModRefBehavior getModRefBehavior(const Function *F) {
     return FMRB_UnknownModRefBehavior;
   }
 
   ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc) {
     return ModRefInfo::ModRef;
   }
 
   ModRefInfo getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) {
     return ModRefInfo::ModRef;
   }
+  Optional<int64_t> getAddressesDistance(const MemoryLocation &LocA,
+                                         int64_t ptr1Offset,
+                                         const MemoryLocation &LocB,
+                                         int64_t ptr2Offset) {
+    return None;
+  }
 };
 
 /// Return true if this pointer is returned by a noalias function.
 bool isNoAliasCall(const Value *V);
 
 /// Return true if this is an argument with the noalias attribute.
 bool isNoAliasArgument(const Value *V);
 

lib/Analysis/AliasAnalysis.cpp

bool AAResults::pointsToConstantMemory(const MemoryLocation &Loc,
                                        bool OrLocal) {
   for (const auto &AA : AAs)
     if (AA->pointsToConstantMemory(Loc, OrLocal))
       return true;
 
   return false;
 }
 
+bool AAResults::ModRefSameBuffer(const MemoryLocation &LocA, int64_t ptr1Offset,
+                                 const MemoryLocation &LocB,
+                                 int64_t ptr2Offset) {
+  for (const auto &AA : AAs)
+    if (AA->ModRefSameBuffer(LocA, ptr1Offset, LocB, ptr2Offset))
+      return true;
+
+  return false;
+}
+
+Optional<int64_t> AAResults::getAddressesDistance(const MemoryLocation &LocA,
+                                                  int64_t ptr1Offset,
+                                                  const MemoryLocation &LocB,
+                                                  int64_t ptr2Offset) {
+  for (const auto &AA : AAs) {
+    Optional<int64_t> res =
+        AA->getAddressesDistance(LocA, ptr1Offset, LocB, ptr2Offset);
+    if (res != None)
+      return res;
+  }
+
+  return None;
+}
 ModRefInfo AAResults::getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) {
   ModRefInfo Result = ModRefInfo::ModRef;
 
   for (const auto &AA : AAs) {
     Result = intersectModRef(Result, AA->getArgModRefInfo(CS, ArgIdx));
 
     // Early-exit the moment we reach the bottom of the lattice.
     if (isNoModRef(Result))