Canonicalize guards for AND condition

[apilipenko]

lib/Transforms/InstCombine/InstCombineCalls.cpp

2883–2884 ↗

(On Diff #85552)

New guard ...

2885 ↗

(On Diff #85552)

Minor:

Function *GuardIntrinsic = II->getCalledFunction();

2888–2891 ↗

(On Diff #85552)

We might have a guard with non-standard calling convention. I guess you'll need to set the cc for new guards as well.

[mkazantsev]

Done fixes

[mkazantsev]

Rebase

[apilipenko]

lib/Transforms/InstCombine/InstCombineCalls.cpp

2889–2894 ↗

(On Diff #85691)

Maybe:

auto CC = II->getCallingConv()
Builder->CreateCall(A)->setCallingConv(CC)
Builder->CreateCall(B)->setCallingConv(CC)

test/Transforms/InstCombine/call-guard.ll

32 ↗

(On Diff #85691)

Please add a test with non-default calling convention

[mkazantsev]

lib/Transforms/InstCombine/InstCombineCalls.cpp

2889–2894 ↗

(On Diff #85691)

I would rather not do call creation and setting the convention in one line, because in case if we want to do to them something more than setting the CC in future, this code will need to be changed.

[mkazantsev]

Added test for non-standard CC

[apilipenko]

lib/Transforms/InstCombine/InstCombineCalls.cpp

2889–2894 ↗

(On Diff #85691)

Not a big deal IMO, but I leave it up to you.

test/Transforms/InstCombine/call-guard.ll

42 ↗

(On Diff #85710)

@test_guard_and_non_default_cc? There is nothing specific about cc99 in this test.

[mkazantsev]

Reformatted, renamed test

llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp

 
   case Intrinsic::experimental_guard: {
     Value *IIOperand = II->getArgOperand(0);
 
     // Remove a guard if it is immediately followed by an identical guard.
     if (match(II->getNextNode(),
               m_Intrinsic<Intrinsic::experimental_guard>(m_Specific(IIOperand))))
       return eraseInstFromFunction(*II);
+
+    // Canonicalize guard(a && b) -> guard(a); guard(b);
+    // Note: New guard intrinsics created here are registered by
+    // the InstCombineIRInserter object.
+    Function *GuardIntrinsic = II->getCalledFunction();
+    Value *A, *B;
+    OperandBundleDef DeoptOB(*II->getOperandBundle(LLVMContext::OB_deopt));
+    if (match(IIOperand, m_And(m_Value(A), m_Value(B)))) {
+      CallInst *GuardA =
+          Builder->CreateCall(GuardIntrinsic, A, {DeoptOB}, II->getName());
+      CallInst *GuardB =
+          Builder->CreateCall(GuardIntrinsic, B, {DeoptOB}, II->getName());
+      auto CC = II->getCallingConv();
+      GuardA->setCallingConv(CC);
+      GuardB->setCallingConv(CC);
+      return eraseInstFromFunction(*II);
+    }
     break;
   }
   }
 
   return visitCallSite(II);
 }
 
 // InvokeInst simplification

llvm/trunk/test/Transforms/InstCombine/call-guard.ll

 ; CHECK-LABEL: @test_guard_adjacent_neg(
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 %A) [ "deopt"() ]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 %B) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
   call void(i1, ...) @llvm.experimental.guard( i1 %A )[ "deopt"() ]
   call void(i1, ...) @llvm.experimental.guard( i1 %B )[ "deopt"() ]
   ret void
 }
+
+define void @test_guard_and(i1 %A, i1 %B) {
+; CHECK-LABEL: @test_guard_and(
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 %A) [ "deopt"() ]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 %B) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+  %C = and i1 %A, %B
+  call void(i1, ...) @llvm.experimental.guard( i1 %C )[ "deopt"() ]
+  ret void
+}
+
+define void @test_guard_and_non_default_cc(i1 %A, i1 %B) {
+; CHECK-LABEL: @test_guard_and_non_default_cc(
+; CHECK-NEXT:    call cc99 void (i1, ...) @llvm.experimental.guard(i1 %A) [ "deopt"() ]
+; CHECK-NEXT:    call cc99 void (i1, ...) @llvm.experimental.guard(i1 %B) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+  %C = and i1 %A, %B
+  call cc99 void(i1, ...) @llvm.experimental.guard( i1 %C )[ "deopt"() ]
+  ret void
+}