[PATCH 11/38] [noalias] D9377: llvm.noalias - don't block EarlyCSE

[jeroen.dobbelaere]

Summary

This is part of the series started by D68484.

Rebase of D9377

[lebedev.ri]

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

937

This looks incorrect to me.
Did you mean Intrinsic::noalias ?
Or does Intrinsic::noalias identify as Intrinsic::assume?

[jeroen.dobbelaere]

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

937

Yes, that should have been Intrinsic::noalias.

[jeroen.dobbelaere]

Fix bad rebase.

[jeroen.dobbelaere]

Rebased

[jeroen.dobbelaere]

For review convenience, all changes related to the original local restrict patches have now been incorporated in the full restrict patch series.

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

if (match(Inst, m_Intrinsic<Intrinsic::assume>())) {
                           << '\n');
         AvailableValues.insert(CondI, ConstantInt::getTrue(BB->getContext()));
       } else
         LLVM_DEBUG(dbgs() << "EarlyCSE skipping assumption: " << *Inst << '\n');
       continue;
     }
 
     // Skip sideeffect intrinsics, for the same reason as assume intrinsics.
-    if (match(Inst, m_Intrinsic<Intrinsic::sideeffect>())) {
-      LLVM_DEBUG(dbgs() << "EarlyCSE skipping sideeffect: " << *Inst << '\n');
+    // Likewise, noalias intrinsics don't actually write.
+    if (match(Inst, m_CombineOr(m_Intrinsic<Intrinsic::sideeffect>(),
+                                m_Intrinsic<Intrinsic::noalias>()))) {
+      LLVM_DEBUG(dbgs() << "EarlyCSE skipping intrinsic: " << *Inst << '\n');
       continue;
     }
 
     // We can skip all invariant.start intrinsics since they only read memory,
     // and we can forward values across it. For invariant starts without
     // invariant ends, we can use the fact that the invariantness never ends to
     // start a scope in the current generaton which is true for all future
     // generations.  Also, we dont need to consume the last store since the

llvm/test/Transforms/EarlyCSE/basic.ll

define i32 @test2a(i32 *%P, i1 %b) {
   %V1 = load i32, i32* %P
   tail call void @llvm.assume(i1 %b)
   %V2 = load i32, i32* %P
   %Diff = sub i32 %V1, %V2
   ret i32 %Diff
   ; CHECK: ret i32 0
 }
 
+; CHECK-LABEL: @test2b(
+define i32 @test2b(i32 *%P, i1 %b) {
+  %V1 = load i32, i32* %P
+  call i8* @llvm.noalias.p0i8(i8* undef, metadata !1)
+  %V2 = load i32, i32* %P
+  %Diff = sub i32 %V1, %V2
+  ret i32 %Diff
+  ; CHECK: ret i32 0
+}
+
 ;; Cross block load value numbering.
 ; CHECK-LABEL: @test3(
 define i32 @test3(i32 *%P, i1 %Cond) {
   %V1 = load i32, i32* %P
   br i1 %Cond, label %T, label %F
 T:
   store i32 4, i32* %P
   ret i32 42

 define i32 @test6a(i32 *%P, i1 %b) {
   store i32 42, i32* %P
   tail call void @llvm.assume(i1 %b)
   %V1 = load i32, i32* %P
   ret i32 %V1
   ; CHECK: ret i32 42
 }
 
+; CHECK-LABEL: @test6b(
+define i32 @test6b(i32 *%P, i1 %b) {
+  store i32 42, i32* %P
+  call i8* @llvm.noalias.p0i8(i8* undef, metadata !1)
+  %V1 = load i32, i32* %P
+  ret i32 %V1
+  ; CHECK: ret i32 42
+}
+
 ;; Trivial dead store elimination.
 ; CHECK-LABEL: @test7(
 define void @test7(i32 *%P) {
   store i32 42, i32* %P
   store i32 45, i32* %P
   ret void
   ; CHECK-NEXT: store i32 45
   ; CHECK-NEXT: ret void

 ; CHECK: call i32 @reads_c(i32 0)
 ; CHECK: store i32 2, i32* @c, align 4
   %load = load i32, i32* @c, align 4
   store i32 0, i32* @c, align 4
   %call = call i32 @reads_c(i32 0)
   store i32 2, i32* @c, align 4
   ret void
 }
+
+declare i8* @llvm.noalias.p0i8(i8*, metadata) nounwind
+
+!0 = !{!0, !"some domain"}
+!1 = !{!1, !0, !"some scope"}