[OperandBundles] Teach AliasAnalysis about operand bundles

[sanjoy]

Summary

If a CallSite has operand bundles, then do not peek into the called
function to get a more precise ModRef answer.

This is tested using argmemonly, -basicaa and -gvn; but the
functionality is not specific to any of these.

Depends on D13961

[reames]

LGTM

include/llvm/Analysis/AliasAnalysis.h

762 ↗

(On Diff #38061)

This is rather conservative, but that's fine for the moment.

768 ↗

(On Diff #38061)

Unrelated to your change: I'm surprised we're not looking at CallSite attributes here..

llvm/trunk/include/llvm/Analysis/AliasAnalysis.h

bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) {
     return false;
   }
 
   ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) {
     return MRI_ModRef;
   }
 
   FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) {
+    if (!CS.hasOperandBundles())
+      // If CS has operand bundles then aliasing attributes from the function it
+      // calls do not directly apply to the CallSite.  This can be made more
+      // precise in the future.
       if (const Function *F = CS.getCalledFunction())
         return getBestAAResults().getModRefBehavior(F);
 
     return FMRB_UnknownModRefBehavior;
   }
 
   FunctionModRefBehavior getModRefBehavior(const Function *F) {
     return FMRB_UnknownModRefBehavior;
   }
 

llvm/trunk/include/llvm/IR/InstrTypes.h

bool hasClobberingOperandBundles() const {
     // read-write.
     return hasOperandBundles();
   }
 
 protected:
   /// \brief Is the function attribute S disallowed by some operand bundle on
   /// this operand bundle user?
   bool isFnAttrDisallowedByOpBundle(StringRef S) const {
-    // Operand bundles only possibly disallow readnone and readonly attributes.
-    // All String attributes are fine.
+    // Operand bundles only possibly disallow readnone, readonly and argmenonly
+    // attributes.  All String attributes are fine.
     return false;
   }
 
   /// \brief Is the function attribute A disallowed by some operand bundle on
   /// this operand bundle user?
   bool isFnAttrDisallowedByOpBundle(Attribute::AttrKind A) const {
     switch (A) {
     default:
       return false;
 
+    case Attribute::ArgMemOnly:
+      return hasReadingOperandBundles();
+
     case Attribute::ReadNone:
       return hasReadingOperandBundles();
 
     case Attribute::ReadOnly:
       return hasClobberingOperandBundles();
     }
 
     llvm_unreachable("switch has a default case!");

llvm/trunk/test/Feature/OperandBundles/basic-aa-argmemonly.ll

+; RUN: opt -S -basicaa -gvn < %s | FileCheck %s
+
+declare void @argmemonly_function(i32 *) argmemonly
+
+define i32 @test0(i32* %P, i32* noalias %P2) {
+; CHECK-LABEL: @test0(
+  %v1 = load i32, i32* %P
+; CHECK: %v1 = load i32, i32* %P
+  call void @argmemonly_function(i32* %P2) [ "tag"() ]
+; CHECK: call void @argmemonly_function(
+  %v2 = load i32, i32* %P
+; CHECK: %v2 = load i32, i32* %P
+  %diff = sub i32 %v1, %v2
+; CHECK: %diff = sub i32 %v1, %v2
+  ret i32 %diff
+; CHECK: ret i32 %diff
+}
+
+define i32 @test1(i32* %P, i32* noalias %P2) {
+; CHECK-LABEL: @test1(
+  %v1 = load i32, i32* %P
+  call void @argmemonly_function(i32* %P2) argmemonly [ "tag"() ]
+; CHECK: call void @argmemonly_function(
+  %v2 = load i32, i32* %P
+  %diff = sub i32 %v1, %v2
+  ret i32 %diff
+; CHECK: ret i32 0
+}