Simplify idempotent invariant.group.barriers

[Prazek]

Summary

Barriers are not fully idempotent, conside: :

%b1 = call i8* @llvm.invariant.group.barrier(i8* %p)
call void @foo(i8* %b1)
%b3 = call i8* @llvm.invariant.group.barrier(i8* %b1)

But we can do it safely if the barrier has only one use -
barrier(barrier(x))

[Prazek]

renamed function

[Prazek]

ping

[Prazek]

• fix test

[davide]

I'm not entirely sure about how this patch is implemented. Maybe you want to capture the fact this is idempotent inside the function? Otherwise using this in other places of the file becomes error prone as every caller has to check that the Instruction has only one use.

[Prazek]

Good point, I was writing it very late.

[Prazek]

ping

[Prazek]

ping2

lib/Analysis/InstructionSimplify.cpp

static bool IsIdempotent(Intrinsic::ID ID) {
   case Intrinsic::trunc:
   case Intrinsic::rint:
   case Intrinsic::nearbyint:
   case Intrinsic::round:
     return true;
   }
 }
 
+static bool isConditionallyIdempotent(Intrinsic::ID ID, const Value* Arg) {
+  // invariant.group.barrier is idempotent only if it has one use.
+  return ID == Intrinsic::invariant_group_barrier && Arg->hasOneUse();
+}
+
 static Value *SimplifyRelativeLoad(Constant *Ptr, Constant *Offset,
                                    const DataLayout &DL) {
   GlobalValue *PtrSym;
   APInt PtrOffset;
   if (!IsConstantOffsetFromGlobal(Ptr, PtrSym, PtrOffset, DL))
     return nullptr;
 
   Type *Int8PtrTy = Type::getInt8PtrTy(Ptr->getContext());

 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);
 
   // Unary Ops
   if (NumOperands == 1) {
     // Perform idempotent optimizations
-    if (IsIdempotent(IID)) {
+    if (IsIdempotent(IID) || isConditionallyIdempotent(IID, *ArgBegin)) {
       if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(*ArgBegin)) {
         if (II->getIntrinsicID() == IID)
           return II;
       }
     }
 
     switch (IID) {
     case Intrinsic::fabs: {

test/Transforms/GVN/invariant.group.ll

 
 _Z2g2R1A.exit.loopexit:                           ; preds = %._crit_edge
   br label %_Z2g2R1A.exit
 
 _Z2g2R1A.exit:                                    ; preds = %_Z2g2R1A.exit.loopexit, %.lr.ph.i, %0
   ret void
 }
 
+; Check if barrier is being simplified based on idempotent propery,
+; but only if it has one use.
+; CHECK-LABEL: i8* @simplifyBarrier(i8* %p)
+define i8* @simplifyBarrier(i8* %p) {
+; CHECK: %b1 = call i8* @llvm.invariant.group.barrier(i8* %p)
+; CHECK-NOT: %b2 = call i8* @llvm.invariant.group.barrier
+  %b1 = call i8* @llvm.invariant.group.barrier(i8* %p)
+  %b2 = call i8* @llvm.invariant.group.barrier(i8* %b1)
+  call void @foo(i8* %b2)
+
+; CHECK: %b3 = call i8* @llvm.invariant.group.barrier(i8* %b1)
+  %b3 = call i8* @llvm.invariant.group.barrier(i8* %b2)
+  call void @foo(i8* %b3)
+; CHECK: %b4 = call i8* @llvm.invariant.group.barrier(i8* %b3)
+  %b4 = call i8* @llvm.invariant.group.barrier(i8* %b3)
+  ret i8* %b4
+}
+
+; In this test we simplify barriers based on readonly&argmemonly attribute,
+; not on idempotent property.
+; CHECK-LABEL: void @simplifyBarrier2(i8* %p)
+define void @simplifyBarrier2(i8* %p) {
+; CHECK: %b1 = call i8* @llvm.invariant.group.barrier(i8* %p)
+; CHECK-NOT: %b2 = call i8* @llvm.invariant.group.barrier
+; CHECK-NOT: %b3 = call i8* @llvm.invariant.group.barrier
+  %b1 = call i8* @llvm.invariant.group.barrier(i8* %p)
+  %b2 = call i8* @llvm.invariant.group.barrier(i8* %b1)
+  %b3 = call i8* @llvm.invariant.group.barrier(i8* %b1)
+; CHECK: call void @foo(i8* %b1)
+; CHECK: call void @foo(i8* %b1)
+  call void @foo(i8* %b2)
+  call void @foo(i8* %b3)
+
+  ret void
+}
+
+; FIXME: all of the uses of %b1 are barriers, so we could simplify it, but
+; this case should be very uncommon. Note that we coud only simplify
+; one of the barriers %b2 or %b3, because simplifing it would add another
+; non-barrier use to %b1.
+; CHECK-LABEL: void @dontSimplifyBarrier(i8* %p)
+define void @dontSimplifyBarrier(i8* %p) {
+; CHECK: %b1 = call i8* @llvm.invariant.group.barrier(i8* %p)
+; CHECK: %b2 = call i8* @llvm.invariant.group.barrier(i8* %b1)
+; CHECK: %b3 = call i8* @llvm.invariant.group.barrier(i8* %b1)
+  %b1 = call i8* @llvm.invariant.group.barrier(i8* %p)
+  %b2 = call i8* @llvm.invariant.group.barrier(i8* %b1)
+  call void @foo(i8* %b2)
+  %b3 = call i8* @llvm.invariant.group.barrier(i8* %b1)
+  call void @foo(i8* %b3)
+  call void @foo(i8* %b3)
+  ret void
+}
+
 
 declare void @foo(i8*)
 declare void @foo2(i8*, i8)
 declare void @bar(i8)
 declare i8* @getPointer(i8*)
 declare void @_ZN1A3fooEv(%struct.A*)
 declare void @_ZN1AC1Ev(%struct.A*)
 declare void @fooBit(i1*, i1)