[PATCH 09/38] [noalias] D9376: llvm.noalias - handling of dead intrinsics

[jeroen.dobbelaere]

Summary

This is part of the series started by D68484.

Rebase of D9376

[a.elovikov]

llvm/lib/Analysis/InstructionSimplify.cpp

5156

What if we have

%i = ptr2int %p
%null = sub %i, %i
%nullptr = int2ptr %null
%scope = call @llvm.noalias(%nullptr) ; introduce the scope
%null2 = ptr2int %scope
%i2 = add %null2, %i
%same.as.orig.p = int2ptr %i2

Why don't we want %same.as.orig.p to have the scope?

llvm/test/Transforms/InstSimplify/noalias.ll

8

Simplify to CHECK-NEXT: ret void?

[jeroen.dobbelaere]

llvm/lib/Analysis/InstructionSimplify.cpp

5156

A ptr2int will normally block the noalias propagation. Not sure if a

%same.as.orig.p = getelementptr %scope, %i

is valid when %scope is null. If that is valid, the noalias dependency should not be removed, and we should not short-circuit it here.

[lebedev.ri]

llvm/lib/Analysis/InstructionSimplify.cpp

5156

getelementptr is valid for null pointer.

[jeroen.dobbelaere]

llvm/lib/Analysis/InstructionSimplify.cpp

5156

Then this is wrong, but it should be fixed in D68493, not here.

[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/Analysis/InstructionSimplify.cpp

 
   // Intrinsics with no operands have some kind of side effect. Don't simplify.
   unsigned NumOperands = Call->getNumArgOperands();
   if (!NumOperands)
     return nullptr;
 
   Function *F = cast<Function>(Call->getCalledFunction());
   Intrinsic::ID IID = F->getIntrinsicID();
+
+  // We can remove a noalias intrinsic if the pointer value is undef (by
+  // forwarding the undef). The same goes for an address-space-zero null
+  // pointer.
+  if (IID == Intrinsic::noalias) {
+    Value *Arg0 = Call->getArgOperand(0);
+    if (isa<UndefValue>(Arg0) ||
+        (isa<ConstantPointerNull>(Arg0) &&
+         Arg0->getType()->getPointerAddressSpace() == 0))
+      return Arg0;
+  }
+
   if (NumOperands == 1)
     return simplifyUnaryIntrinsic(F, Call->getArgOperand(0), Q);
 
   if (NumOperands == 2)
     return simplifyBinaryIntrinsic(F, Call->getArgOperand(0),
                                    Call->getArgOperand(1), Q);
 
   // Handle intrinsics with 3 or more arguments.

llvm/lib/Transforms/Utils/Local.cpp

     // widening, but for now we keep things simple.
     if (II->getIntrinsicID() == Intrinsic::assume ||
         II->getIntrinsicID() == Intrinsic::experimental_guard) {
       if (ConstantInt *Cond = dyn_cast<ConstantInt>(II->getArgOperand(0)))
         return !Cond->isZero();
 
       return false;
     }
+
+    // noalias intrinsics are dead if they have no uses (they're tagged as
+    // writing, but that is only to maintain control dependencies, not because
+    // they actually write anything).
+    if (II->getIntrinsicID() == Intrinsic::noalias)
+      return II->use_empty();
   }
 
   if (isAllocLikeFn(I, TLI))
     return true;
 
   if (CallInst *CI = isFreeCall(I, TLI))
     if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
       return C->isNullValue() || isa<UndefValue>(C);

llvm/test/Transforms/InstSimplify/noalias.ll

+; RUN: opt -instsimplify -S < %s | FileCheck %s
+
+define void @test1(i8* %ptr) {
+  call i8* @llvm.noalias.p0i8(i8* %ptr, metadata !1)
+  ret void
+
+; CHECK-LABEL: @test1
+; CHECK-NOT: llvm.noalias.p0i8
+; CHECK: ret void
+}
+
+define i8* @test2a() {
+  %v = call i8* @llvm.noalias.p0i8(i8* null, metadata !1)
+  ret i8* %v
+
+; CHECK-LABEL: @test2a
+; CHECK-NOT: llvm.noalias.p0i8
+; CHECK: ret i8* null
+}
+
+define i8* @test2() {
+  %v = call i8* @llvm.noalias.p0i8(i8* undef, metadata !1)
+  ret i8* %v
+
+; CHECK-LABEL: @test2
+; CHECK-NOT: llvm.noalias.p0i8
+; CHECK: ret i8* undef
+}
+
+declare i8* @llvm.noalias.p0i8(i8*, metadata) nounwind
+
+!0 = !{!0, !"some domain"}
+!1 = !{!1, !0, !"some scope"}