llvm.noalias - handling of dead intrinsics

[hfinkel]

Summary

This part of the series started by D9375, and adds some code to clean-up dead llvm.noalias intrinsics. Specifically:

1. The intrinsic is dead if it has no users
2. If the pointer argument is undef, the intrinsic can be removed (replaced by the undef).

[reames]

LGTM

[hfinkel]

Rebased.

[majnemer]

lib/Analysis/InstructionSimplify.cpp

3951–3952

Hmm. What about NULL in address space 0?

[hfinkel]

lib/Analysis/InstructionSimplify.cpp

3951–3952

Good point. We can drop them then too (nothing aliases with as-0 null). I'll update.

[hfinkel]

Updated per review comments (handle the null pointer in AS-0 case).

[majnemer]

LGTM

[majnemer]

lib/Analysis/InstructionSimplify.cpp

3957

This could be return Arg0;

[hfinkel]

Rebased (and addressed reviewer feedback)

[hfinkel]

Rebased.

[troyj]

This is marked Accepted and is first in the sequence in D9375. Is there some reason this isn't merged yet? LGTM too.

lib/Analysis/InstructionSimplify.cpp

 
 template <typename IterTy>
 static Value *SimplifyIntrinsic(Function *F, IterTy ArgBegin, IterTy ArgEnd,
                                 const Query &Q, unsigned MaxRecurse) {
   Intrinsic::ID IID = F->getIntrinsicID();
   unsigned NumOperands = std::distance(ArgBegin, ArgEnd);
   Type *ReturnType = F->getReturnType();
 
+  // 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 = *ArgBegin;
+    if (isa<UndefValue>(Arg0) ||
+        (isa<ConstantPointerNull>(Arg0) &&
+         Arg0->getType()->getPointerAddressSpace() == 0))
+      return *ArgBegin;
+  }
+
   // Binary Ops
   if (NumOperands == 2) {
     Value *LHS = *ArgBegin;
     Value *RHS = *(ArgBegin + 1);
     if (IID == Intrinsic::usub_with_overflow ||
         IID == Intrinsic::ssub_with_overflow) {
       // X - X -> { 0, false }
       if (LHS == RHS)

lib/Transforms/Utils/Local.cpp

if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
     // 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);
 

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"}
+