[PATCH 07/27] [noalias] simplify noalias intrinsics

[jeroen.dobbelaere]

Summary

This is part of the series started by D68484.

Note: this is a stable point and tests should run fine with the patches applied up to this point.
Note: D68492 has been incorporated.

[lebedev.ri]

Comments need more work i think. Also, they are phrases, they should be grammatically correct, start with Uppercase letter.

[jeroen.dobbelaere]

llvm/lib/Analysis/InstructionSimplify.cpp

5148

As mentioned by a.elivikov in D68492: we should not propagate null through the intrinsics.

5225

Also here, we should not propagate null.

[jeroen.dobbelaere]

Do not propagate null. Improved tests.

[jeroen.dobbelaere]

Rebased

[jeroen.dobbelaere]

Rebased to c06b7e2ab5167ad031745a706204abed1aefd823 (July 14, 2020)

[jeroen.dobbelaere]

Rebased to 9fb46a452d4e5666828c95610ceac8dcd9e4ce16 (September 7, 2020)

[jeroen.dobbelaere]

Rebased to f8dbd61074176bae92ec360a093ac7bc498c9321.

llvm/lib/Analysis/InstructionSimplify.cpp

 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/KnownBits.h"
 #include <algorithm>
 using namespace llvm;
 using namespace llvm::PatternMatch;
 
case Intrinsic::fabs:
     break;
   case Intrinsic::bswap:
     // bswap(bswap(x)) -> x
     if (match(Op0, m_BSwap(m_Value(X)))) return X;
     break;
   case Intrinsic::bitreverse:
     // bitreverse(bitreverse(x)) -> x
     if (match(Op0, m_BitReverse(m_Value(X)))) return X;
     break;
   case Intrinsic::exp:
     // exp(log(x)) -> x
     if (Q.CxtI->hasAllowReassoc() &&
         match(Op0, m_Intrinsic<Intrinsic::log>(m_Value(X)))) return X;
     break;
   case Intrinsic::exp2:
     // exp2(log2(x)) -> x
     if (Q.CxtI->hasAllowReassoc() &&
case Intrinsic::sadd_with_overflow:
     // undef + x -> { undef, false }
     if (isa<UndefValue>(Op0) || isa<UndefValue>(Op1)) {
       return ConstantStruct::get(
           cast<StructType>(ReturnType),
           {UndefValue::get(ReturnType->getStructElementType(0)),
            Constant::getNullValue(ReturnType->getStructElementType(1))});
     }
     break;
   case Intrinsic::umul_with_overflow:
   case Intrinsic::smul_with_overflow:
     // 0 * X -> { 0, false }
     // X * 0 -> { 0, false }
     if (match(Op0, m_Zero()) || match(Op1, m_Zero()))
       return Constant::getNullValue(ReturnType);
     // undef * X -> { 0, false }
     // X * undef -> { 0, false }
     if (match(Op0, m_Undef()) || match(Op1, m_Undef()))
if ((match(Op0, m_APFloat(C)) && C->isInfinity() &&
       return ConstantFP::getInfinity(ReturnType, UseNegInf);
 
     // TODO: minnum(nnan x, inf) -> x
     // TODO: minnum(nnan ninf x, flt_max) -> x
     // TODO: maxnum(nnan x, -inf) -> x
     // TODO: maxnum(nnan ninf x, -flt_max) -> x
     break;
   }
+  case Intrinsic::noalias_arg_guard: {
+    // Only follow the plain path if undefined. Do not propagate null, that
+    // would incorrectly omit noalias information.
+    if (isa<UndefValue>(Op0))
+      return Op0;
+    break;
+  }
   default:
     break;
   }
 
   return nullptr;
 }
 
-static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) {
+static Value *simplifyProvenanceNoAlias(const Value *V) {
+  const IntrinsicInst *II = cast<IntrinsicInst>(V);
+  assert(II->getIntrinsicID() == Intrinsic::provenance_noalias);
+
+  // Only follow the plain path if undefined. Do not propagate null, that
+  // would incorrectly omit noalias information.
+  Value *Op0 = II->getOperand(0);
+  if (isa<UndefValue>(Op0)) {
+    return Op0;
+  }
+
+  // Check for compatibility: provenance.noalias(provenance.noalias) ->
+  // provenance.noalias
+  if (llvm::IntrinsicInst *DepII = dyn_cast<IntrinsicInst>(Op0)) {
+    if (DepII->getIntrinsicID() == Intrinsic::provenance_noalias) {
+      if (llvm::areProvenanceNoAliasCompatible(DepII, II)) {
+        return DepII;
+      }
+    }
+  }
+  return nullptr;
+}
 
+static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) {
   // 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();
   if (NumOperands == 1)
static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) {
   case Intrinsic::fmuladd: {
     Value *Op0 = Call->getArgOperand(0);
     Value *Op1 = Call->getArgOperand(1);
     Value *Op2 = Call->getArgOperand(2);
     if (Value *V = simplifyFPOp({ Op0, Op1, Op2 }))
       return V;
     return nullptr;
   }
+  case Intrinsic::noalias:
+  case Intrinsic::noalias_copy_guard: {
+    // Only follow the plain path if undefined. Do not propagate null, that
+    // would incorrectly omit noalias information.
+    if (auto Op0 = dyn_cast<UndefValue>(Call->getArgOperand(0))) {
+      return Op0;
+    }
+    return nullptr;
+  }
+  case Intrinsic::provenance_noalias: {
+    return simplifyProvenanceNoAlias(Call);
+  }
   default:
     return nullptr;
   }
 }
 
 Value *llvm::SimplifyCall(CallBase *Call, const SimplifyQuery &Q) {
   Value *Callee = Call->getCalledOperand();
 

llvm/lib/Transforms/Utils/Local.cpp

if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
     if ((II->getIntrinsicID() == Intrinsic::assume &&
          isAssumeWithEmptyBundle(*II)) ||
         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 ||
+        II->getIntrinsicID() == Intrinsic::provenance_noalias ||
+        II->getIntrinsicID() == Intrinsic::noalias_copy_guard ||
+        II->getIntrinsicID() == Intrinsic::noalias_arg_guard)
+      return II->use_empty();
+
+    // llvm.noalias.decl which operand only has a single use are trivially dead.
+    // NOTE: this assumes that noalias intrinsics nodes are never combined !
+    if (II->getIntrinsicID() == Intrinsic::noalias_decl) {
+      auto *DAA = II->getOperand(Intrinsic::NoAliasDeclAllocaArg);
+      if (isa<Constant>(DAA)) {
+        // no associated alloca -> if there are no uses, it is trivially dead
+        return II->getNumUses() == 0;
+      } else {
+        return (DAA->getNumUses() == 1) &&
+               (II->getOperand(Intrinsic::NoAliasDeclScopeArg)->getNumUses() ==
+                1);
+      }
+    }
   }
 
   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 @test01(i8* %ptr) {
+  call i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i32(i8* %ptr, i8* null, i8** null, i32 0, metadata !1)
+  ret void
+
+; CHECK-LABEL: @test01
+; CHECK-NOT: llvm.noalias.p0i8
+; CHECK: ret void
+}
+
+define i8* @test02() {
+  %v = call i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i32 0, metadata !1)
+  ret i8* %v
+
+; CHECK-LABEL: @test02
+; CHECK: llvm.noalias.p0i8
+; CHECK: ret i8* %v
+}
+
+define i8* @test03() {
+  %v = call i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i32(i8* undef, i8* null, i8** null, i32 0, metadata !1)
+  ret i8* %v
+
+; CHECK-LABEL: @test03
+; CHECK-NOT: llvm.noalias.p0i8
+; CHECK: ret i8* undef
+}
+
+declare i8*  @llvm.noalias.p0i8.p0i8.p0p0i8.i32(i8*, i8*, i8**, i32, metadata ) nounwind
+
+define void @test11(i8* %ptr) {
+  call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* %ptr, i8* null, i8** null, i8** null, i32 0, metadata !1)
+  ret void
+
+; CHECK-LABEL: @test11
+; CHECK-NOT: llvm.provenance.noalias.p0i8
+; CHECK: ret void
+}
+
+define i8* @test12() {
+  %v = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i8** null, i32 0, metadata !1)
+  ret i8* %v
+
+; CHECK-LABEL: @test12
+; CHECK: llvm.provenance.noalias.p0i8
+; CHECK: ret i8* %v
+}
+
+define i8* @test13() {
+  %v = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* undef, i8* null, i8** null, i8** null, i32 0, metadata !1)
+  ret i8* %v
+
+; CHECK-LABEL: @test13
+; CHECK-NOT: llvm.provenance.noalias.p0i8
+; CHECK: ret i8* undef
+}
+
+define i8* @test14() {
+  %u = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i8** null, i32 0, metadata !1)
+  %v = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* %u, i8* null, i8** null, i8** null, i32 0, metadata !1)
+  ret i8* %v
+
+; CHECK-LABEL: @test14
+; CHECK: llvm.provenance.noalias.p0i8
+; CHECK-NOT: llvm.provenance.noalias.p0i8
+; CHECK: ret i8* %u
+}
+
+define i8* @test15() {
+  %u = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i8** null, i32 1, metadata !1)
+  %v = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* %u, i8* null, i8** null, i8** null, i32 0, metadata !1)
+  ret i8* %v
+
+; CHECK-LABEL: @test15
+; CHECK: llvm.provenance.noalias.p0i8
+; CHECK: llvm.provenance.noalias.p0i8
+; CHECK: ret i8* %v
+}
+
+define i8* @test20() {
+  %u = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i8** null, i32 0, metadata !1)
+  %v = call i8* @llvm.noalias.arg.guard.p0i8.p0i8(i8* null, i8* %u)
+  ret i8* %v
+
+; CHECK-LABEL: @test20
+; CHECK: llvm.provenance.noalias.p0i8
+; CHECK: llvm.noalias.arg.guard.p0i8
+; CHECK: ret i8* %v
+}
+
+define i8* @test21() {
+  %u = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i8** null, i32 0, metadata !1)
+  %v = call i8* @llvm.noalias.arg.guard.p0i8.p0i8(i8* undef, i8* %u)
+  ret i8* %v
+
+; CHECK-LABEL: @test21
+; CHECK-NOT: llvm.provenance.noalias.p0i8
+; CHECK-NOT: llvm.noalias.arg.guard.p0i8
+; CHECK: ret i8* undef
+}
+
+define i8* @test30() {
+  %v = call i8* @llvm.noalias.copy.guard.p0i8.p0i8(i8* null, i8* null, metadata !2, metadata !1)
+  ret i8* %v
+
+; CHECK-LABEL: @test30
+; CHECK: llvm.noalias.copy.guard.p0i8
+; CHECK: ret i8* %v
+}
+
+define void @test31() {
+  %v = call i8* @llvm.noalias.copy.guard.p0i8.p0i8(i8* null, i8* null, metadata !2, metadata !1)
+  ret void
+
+; CHECK-LABEL: @test31
+; CHECK-NOT: llvm.noalias.copy.guard.p0i8
+; CHECK: ret void
+}
+
+define i8* @test32() {
+  %v = call i8* @llvm.noalias.copy.guard.p0i8.p0i8(i8* undef, i8* null, metadata !2, metadata !1)
+  ret i8* %v
+
+; CHECK-LABEL: @test32
+; CHECK-NOT: llvm.noalias.copy.guard.p0i8
+; CHECK: ret i8* undef
+}
+
+define void @test40() {
+  %v = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i8** null, i32 0, metadata !1)
+  ret void
+
+; CHECK-LABEL: @test40
+; CHECK-NOT: llvm.noalias.decl.p0i8
+; CHECK: ret void
+}
+
+define void @test41() {
+  %u = alloca i8*
+  %v = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i8** %u, i32 0, metadata !4)
+  ret void
+
+; CHECK-LABEL: @test41
+; CHECK-NOT: alloca
+; CHECK-NOT: llvm.noalias.decl.p0i8
+; CHECK: ret void
+}
+
+define i8** @test42() {
+  %u = alloca i8*
+  %v = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i8** %u, i32 0, metadata !0)
+  ret i8** %u
+
+; CHECK-LABEL: @test42
+; CHECK: alloca
+; CHECK: llvm.noalias.decl.p0i8
+; CHECK: ret i8** %u
+}
+
+
+declare i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8*, i8*, i8**, i8**, i32, metadata ) nounwind
+declare i8* @llvm.noalias.arg.guard.p0i8.p0i8(i8*, i8*) nounwind readnone
+declare i8* @llvm.noalias.copy.guard.p0i8.p0i8(i8*, i8*, metadata, metadata)
+declare i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i8**, i32, metadata) argmemonly nounwind
+
+!0 = !{!0, !"some domain"}
+!1 = !{!1, !0, !"some scope"}
+!2 = !{!3}
+!3 = !{ i64 -1, i64 0 }
+!4 = !{!4, !"some other domain"}
+!5 = !{!5, !4, !"some other scope"}