[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;
 

 /// Try to use FastMathFlags when folding the result.
 static Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                             const FastMathFlags &FMF, const SimplifyQuery &Q,
                             unsigned MaxRecurse) {
   switch (Opcode) {
   case Instruction::FAdd:
     return SimplifyFAddInst(LHS, RHS, FMF, Q, MaxRecurse);
   case Instruction::FSub:
     return SimplifyFSubInst(LHS, RHS, FMF, Q, MaxRecurse);
   case Instruction::FMul:
     return SimplifyFMulInst(LHS, RHS, FMF, Q, MaxRecurse);
   case Instruction::FDiv:
     return SimplifyFDivInst(LHS, RHS, FMF, Q, MaxRecurse);
   default:
     return SimplifyBinOp(Opcode, LHS, RHS, Q, MaxRecurse);
   }
 }
if (OffsetInt % 4 != 0)
     return nullptr;
 
   Constant *C = ConstantExpr::getGetElementPtr(
       Int32Ty, ConstantExpr::getBitCast(Ptr, Int32PtrTy),
       ConstantInt::get(Int64Ty, OffsetInt / 4));
   Constant *Loaded = ConstantFoldLoadFromConstPtr(C, Int32Ty, DL);
   if (!Loaded)
     return nullptr;
 
   auto *LoadedCE = dyn_cast<ConstantExpr>(Loaded);
   if (!LoadedCE)
     return nullptr;
 
   if (LoadedCE->getOpcode() == Instruction::Trunc) {
     LoadedCE = dyn_cast<ConstantExpr>(LoadedCE->getOperand(0));
     if (!LoadedCE)
       return nullptr;
case Intrinsic::experimental_vector_extract: {
     Value *X = nullptr;
     if (match(Op0, m_Intrinsic<Intrinsic::experimental_vector_insert>(
                        m_Value(), m_Value(X), m_Zero())) &&
         IdxN == 0 && X->getType() == ReturnType)
       return 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 (auto *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)
case Intrinsic::experimental_vector_insert: {
     Value *X = nullptr;
     if (match(SubVec, m_Intrinsic<Intrinsic::experimental_vector_extract>(
                           m_Value(X), m_Zero())) &&
         IdxN == 0 && X->getType() == ReturnType)
       return X;
 
     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;
   }
 }
 
 static Value *tryConstantFoldCall(CallBase *Call, const SimplifyQuery &Q) {
   auto *F = dyn_cast<Function>(Call->getCalledOperand());
   if (!F || !canConstantFoldCallTo(Call, F))

llvm/lib/Transforms/Utils/Local.cpp

if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
     if ((II->getIntrinsicID() == Intrinsic::assume &&
          isAssumeWithEmptyBundle(cast<AssumeInst>(*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"}