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

   }
   default:
     break;
   }
 
   return nullptr;
 }
 
-static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) {
+static Value *simplifySideNoalias(const Value *V) {
+  const IntrinsicInst *II = cast<IntrinsicInst>(V);
+  assert(II->getIntrinsicID() == Intrinsic::side_noalias);
+
+  // check for undef
+  Value *Op0 = II->getOperand(0);
+  if (isa<UndefValue>(Op0) || (isa<ConstantPointerNull>(Op0) &&
+                               Op0->getType()->getPointerAddressSpace() == 0)) {
+    return Op0;
+  }
+
+  // check for compatibility
+  if (llvm::IntrinsicInst *DepII = dyn_cast<IntrinsicInst>(Op0)) {
+    if (DepII->getIntrinsicID() == Intrinsic::side_noalias) {
+      if (llvm::areSideNoaliasCompatible(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();
-
-  // 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.

   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_arg_guard: {
+    // only follow the plain path if undefined
+    Value *Op0 = Call->getArgOperand(0);
+    if (isa<UndefValue>(Op0) ||
+        (isa<ConstantPointerNull>(Op0) &&
+         Op0->getType()->getPointerAddressSpace() == 0)) {
+      return Op0;
+    }
+    return nullptr;
+  }
+  case Intrinsic::side_noalias: {
+    return simplifySideNoalias(Call);
+  }
   default:
     return nullptr;
   }
 }
 
 Value *llvm::SimplifyCall(CallBase *Call, const SimplifyQuery &Q) {
   Value *Callee = Call->getCalledValue();
 

llvm/lib/Transforms/Utils/Local.cpp

         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)
+    if (II->getIntrinsicID() == Intrinsic::noalias ||
+        II->getIntrinsicID() == Intrinsic::side_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 @test1(i8* %ptr) {
-  call i8* @llvm.noalias.p0i8(i8* %ptr, metadata !1)
+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: @test1
+; CHECK-LABEL: @test01
 ; CHECK-NOT: llvm.noalias.p0i8
 ; CHECK: ret void
 }
 
-define i8* @test2a() {
-  %v = call i8* @llvm.noalias.p0i8(i8* null, metadata !1)
+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: @test2a
+; CHECK-LABEL: @test02
 ; CHECK-NOT: llvm.noalias.p0i8
 ; CHECK: ret i8* null
 }
 
-define i8* @test2() {
-  %v = call i8* @llvm.noalias.p0i8(i8* undef, metadata !1)
+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: @test2
+; CHECK-LABEL: @test03
 ; CHECK-NOT: llvm.noalias.p0i8
 ; CHECK: ret i8* undef
 }
 
-declare i8* @llvm.noalias.p0i8(i8*, metadata) nounwind
+declare i8*  @llvm.noalias.p0i8.p0i8.p0p0i8.i32(i8*, i8*, i8**, i32, metadata ) nounwind
+
+define void @test11(i8* %ptr) {
+  call i8* @llvm.side.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.side.noalias.p0i8
+; CHECK: ret void
+}
+
+define i8* @test12() {
+  %v = call i8* @llvm.side.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-NOT: llvm.side.noalias.p0i8
+; CHECK: ret i8* null
+}
+
+define i8* @test13() {
+  %v = call i8* @llvm.side.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.side.noalias.p0i8
+; CHECK: ret i8* undef
+}
+
+declare i8*  @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8*, i8*, i8**, i8**, i32, metadata ) nounwind
 
 !0 = !{!0, !"some domain"}
 !1 = !{!1, !0, !"some scope"}