[Attributor] Deduce "noalias" attribute

[uenoku]

Summary

Toward noalias backward propagation(similar to D65402), this patch adds AANoAliasArgument and AANoAliasCallSiteArgument as staring point.

[uenoku]

Fix test filename.

[sstefan1]

Minor comments

llvm/lib/Transforms/IPO/Attributor.cpp

1358 ↗

(On Diff #215059)

this can now be auto CallSiteCheck = [&](CallSiteCheck CS){ ... }
In D66155 I changed checkForAllCallSites to also use llvm::function_ref

1375 ↗

(On Diff #215059)

It looks like this is not the latest version of checkForAllCallSites. Now it also takes a function as a parameter.

[uenoku]

llvm/lib/Transforms/IPO/Attributor.cpp

1375 ↗

(On Diff #215059)

I created this patch based on D65977. In that patch, the interface will be changed. I forgot to say it, sorry.

[jdoerfert]

Please add an SCC test and maybe also tests we cannot handle yet (see my link) and https://reviews.llvm.org/D50125#change-PYgdy9Zf8j2e

Edit: we don't need the extended functionality in this patch but tests would be nice.

llvm/lib/Transforms/IPO/Attributor.cpp

1398 ↗

(On Diff #215059)

This is a good first step.

For an extension we could do something like this:
https://reviews.llvm.org/D50125#C1138972NL755

[jdoerfert]

Can we make prioritize this, at least a simple version which is almost done, just the additional argument checks are missing (see below).

llvm/lib/Transforms/IPO/Attributor.cpp

1398 ↗

(On Diff #215059)

See my example below, we need to check the other uses in the call site as I did in the link above.

llvm/test/Transforms/FunctionAttrs/noalias.ll

164 ↗

(On Diff #215059)

; TEST 11
; CallSite Test

declare void @test11_helper(i8* %a, i8 *%b)
define void @test11(i8* noalias %a) {
; CHECK: define void @test11(i8* noalias %a)
; CHECK-NEXT:   tail call void @test11_helper(i8* %a, i8* %a)
  tail call void @test11_helper(i8* %a)
  ret void
}

[uenoku]

Rebase and add test.

[uenoku]

llvm/lib/Transforms/IPO/Attributor.cpp

396 ↗

(On Diff #217603)

About initialize, I think it suffices to ignore this line for call site argument.

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

1533 ↗

(On Diff #217603)

I do not understand. Could you elaborate or point me to a test case?

[uenoku]

llvm/lib/Transforms/IPO/Attributor.cpp

1533 ↗

(On Diff #217603)

declare void @test11_helper(i8* %a)
define void @test11(i8* noalias %a) {
  tail call void @test11_helper(i8* %a) ; maybe captured
  %c = load i8 , i8* %a ; It is invalid to deduce noalias for %a because of noalias in argument
  ret void
}

Isn't it?

[jdoerfert]

I think except the small nits below this is fine. We can get this in and work from there

llvm/lib/Transforms/IPO/Attributor.cpp

1533 ↗

(On Diff #217603)

Ah, now I see your point. thx

llvm/test/Transforms/FunctionAttrs/internal-noalias.ll

8 ↗

(On Diff #217603)

Add check lines above or use llvm/utils/update_test_checks.py for the test files.

llvm/test/Transforms/FunctionAttrs/noalias_returned.ll

145 ↗

(On Diff #217603)

Missing noalias where? Maybe show how it should look like.

[jdoerfert]

LGTM with small nits

[uenoku]

Address comment

[uenoku]

Minor update

[uenoku]

Fix.

llvm/trunk/lib/Transforms/IPO/Attributor.cpp

const std::string getAsStr() const override {
     return getAssumed() ? "noalias" : "may-alias";
   }
 };
 
 /// NoAlias attribute for a floating value.
 struct AANoAliasFloating final : AANoAliasImpl {
   AANoAliasFloating(const IRPosition &IRP) : AANoAliasImpl(IRP) {}
 
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    // TODO: It isn't sound to initialize as the same with `AANoAliasImpl`
+    // because `noalias` may not be valid in the current position.
+  }
+
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     // TODO: Implement this.
     return indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_FLOATING_ATTR(noalias)
   }
 };
 
 /// NoAlias attribute for an argument.
-struct AANoAliasArgument final : AANoAliasImpl {
-  AANoAliasArgument(const IRPosition &IRP) : AANoAliasImpl(IRP) {}
-
-  /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Implement this.
-    return indicatePessimisticFixpoint();
-  }
+struct AANoAliasArgument final
+    : AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl> {
+  AANoAliasArgument(const IRPosition &IRP)
+      : AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl>(IRP) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(noalias) }
 };
 
 struct AANoAliasCallSiteArgument final : AANoAliasImpl {
   AANoAliasCallSiteArgument(const IRPosition &IRP) : AANoAliasImpl(IRP) {}
 
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    // TODO: It isn't sound to initialize as the same with `AANoAliasImpl`
+    // because `noalias` may not be valid in the current position.
+  }
+
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     // TODO: Implement this.
     return indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(noalias) }
void Attributor::identifyDefaultAbstractAttributes(
   }
 
   for (Argument &Arg : F.args()) {
     if (Arg.getType()->isPointerTy()) {
       IRPosition ArgPos = IRPosition::argument(Arg);
       // Every argument with pointer type might be marked nonnull.
       checkAndRegisterAA<AANonNullArgument>(ArgPos, *this, Whitelist);
 
+      // Every argument with pointer type might be marked noalias.
+      checkAndRegisterAA<AANoAliasArgument>(ArgPos, *this, Whitelist);
+
       // Every argument with pointer type might be marked dereferenceable.
       checkAndRegisterAA<AADereferenceableArgument>(ArgPos, *this, Whitelist);
 
       // Every argument with pointer type might be marked align.
       checkAndRegisterAA<AAAlignArgument>(ArgPos, *this, Whitelist);
     }
   }
 
if (CS && CS.getCalledFunction()) {
         if (!CS.getArgument(i)->getType()->isPointerTy())
           continue;
         IRPosition CSArgPos = IRPosition::callsite_argument(CS, i);
 
         // Call site argument attribute "non-null".
         checkAndRegisterAA<AANonNullCallSiteArgument>(CSArgPos, *this,
                                                       Whitelist);
 
+        // Call site argument attribute "no-alias".
+        checkAndRegisterAA<AANoAliasCallSiteArgument>(CSArgPos, *this,
+                                                      Whitelist);
+
         // Call site argument attribute "dereferenceable".
         checkAndRegisterAA<AADereferenceableCallSiteArgument>(CSArgPos, *this,
                                                               Whitelist);
 
         // Call site argument attribute "align".
         checkAndRegisterAA<AAAlignCallSiteArgument>(CSArgPos, *this, Whitelist);
       }
     }

llvm/trunk/test/Transforms/FunctionAttrs/internal-noalias.ll

+; RUN: opt -S -attributor -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=9 < %s | FileCheck %s
+
+define dso_local i32 @visible(i32* noalias %A, i32* noalias %B) #0 {
+entry:
+  %call1 = call i32 @noalias_args(i32* %A, i32* %B)
+  %call2 = call i32 @noalias_args_argmem(i32* %A, i32* %B)
+  %add = add nsw i32 %call1, %call2
+  ret i32 %add
+}
+
+; FIXME: Should be something like this.
+; define internal i32 @noalias_args(i32* nocapture readonly %A, i32* noalias nocapture readonly %B)
+; CHECK: define internal i32 @noalias_args(i32* %A, i32* %B)
+
+define internal i32 @noalias_args(i32* %A, i32* %B) #0 {
+entry:
+  %0 = load i32, i32* %A, align 4
+  %1 = load i32, i32* %B, align 4
+  %add = add nsw i32 %0, %1
+  %call = call i32 @noalias_args_argmem(i32* %A, i32* %B)
+  %add2 = add nsw i32 %add, %call
+  ret i32 %add2
+}
+
+
+; FIXME: Should be something like this.
+; define internal i32 @noalias_args_argmem(i32* noalias nocapture readonly %A, i32* noalias nocapture readonly %B)
+; CHECK: define internal i32 @noalias_args_argmem(i32* %A, i32* %B)
+;
+define internal i32 @noalias_args_argmem(i32* %A, i32* %B) #1 {
+entry:
+  %0 = load i32, i32* %A, align 4
+  %1 = load i32, i32* %B, align 4
+  %add = add nsw i32 %0, %1
+  ret i32 %add
+}
+
+define dso_local i32 @visible_local(i32* %A) #0 {
+entry:
+  %B = alloca i32, align 4
+  store i32 5, i32* %B, align 4
+  %call1 = call i32 @noalias_args(i32* %A, i32* nonnull %B)
+  %call2 = call i32 @noalias_args_argmem(i32* %A, i32* nonnull %B)
+  %add = add nsw i32 %call1, %call2
+  ret i32 %add
+}
+
+attributes #0 = { noinline nounwind uwtable willreturn }
+attributes #1 = { argmemonly noinline nounwind uwtable willreturn}

llvm/trunk/test/Transforms/FunctionAttrs/noalias_returned.ll

 
 4:                                                ; preds = %1
   store i8 10, i8* %2
   br label %5
 
 5:                                                ; preds = %1, %4
   ret i8* %2
 }
+
+; TEST 9
+; Simple Argument Test
+define internal void @test9(i8* %a, i8* %b) {
+; FIXME: missing noalias
+; CHECK: define internal void @test9(i8* %a, i8* %b)
+  ret void
+}
+define void @test9_helper(i8* %a, i8* %b) {
+  tail call void @test9(i8* noalias %a, i8* %b)
+  tail call void @test9(i8* noalias %b, i8* noalias %a)
+  ret void
+}
+
+
+; TEST 10
+; Simple CallSite Test
+
+declare void @test10_helper(i8* %a)
+define void @test10(i8* noalias %a) {
+; CHECK: define void @test10(i8* noalias %a)
+; FIXME: missing noalias
+; CHECK-NEXT:   tail call void @test10_helper(i8* %a)
+  tail call void @test10_helper(i8* %a)
+  ret void
+}
+
+; TEST 11
+; CallSite Test
+
+declare void @test11_helper(i8* %a, i8 *%b)
+define void @test11(i8* noalias %a) {
+; CHECK: define void @test11(i8* noalias %a)
+; CHECK-NEXT:   tail call void @test11_helper(i8* %a, i8* %a)
+  tail call void @test11_helper(i8* %a, i8* %a)
+  ret void
+}