Canonicalize guards for NOT OR condition

[apilipenko]

lib/Transforms/InstCombine/InstCombineCalls.cpp

2897–2900 ↗

(On Diff #85556)

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]

Rebase

[apilipenko]

lib/Transforms/InstCombine/InstCombineCalls.cpp

2900–2905 ↗

(On Diff #85692)

Maybe:

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

test/Transforms/InstCombine/call-guard.ll

42 ↗

(On Diff #85692)

Please add a test for non-default calling convention.

[mkazantsev]

lib/Transforms/InstCombine/InstCombineCalls.cpp

2900–2905 ↗

(On Diff #85692)

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 cc99

[apilipenko]

test/Transforms/InstCombine/call-guard.ll

65 ↗

(On Diff #85713)

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

[mkazantsev]

Some reformating, renamed test.

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

if (match(IIOperand, m_And(m_Value(A), m_Value(B)))) {
           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);
     }
+
+    // guard(!(a || b)) -> guard(!a); guard(!b);
+    if (match(IIOperand, m_Not(m_Or(m_Value(A), m_Value(B))))) {
+      CallInst *GuardA = Builder->CreateCall(
+          GuardIntrinsic, Builder->CreateNot(A), {DeoptOB}, II->getName());
+      CallInst *GuardB = Builder->CreateCall(
+          GuardIntrinsic, Builder->CreateNot(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_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
 }
+
+define void @test_guard_not_or(i1 %A, i1 %B) {
+; CHECK-LABEL: @test_guard_not_or(
+; CHECK-NEXT:    %1 = xor i1 %A, true
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 %1) [ "deopt"() ]
+; CHECK-NEXT:    %2 = xor i1 %B, true
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 %2) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+  %C = or i1 %A, %B
+  %D = xor i1 %C, true
+  call void(i1, ...) @llvm.experimental.guard( i1 %D )[ "deopt"() ]
+  ret void
+}
+
+define void @test_guard_not_or_non_default_cc(i1 %A, i1 %B) {
+; CHECK-LABEL: @test_guard_not_or_non_default_cc(
+; CHECK-NEXT:    %1 = xor i1 %A, true
+; CHECK-NEXT:    call cc99 void (i1, ...) @llvm.experimental.guard(i1 %1) [ "deopt"() ]
+; CHECK-NEXT:    %2 = xor i1 %B, true
+; CHECK-NEXT:    call cc99 void (i1, ...) @llvm.experimental.guard(i1 %2) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+  %C = or i1 %A, %B
+  %D = xor i1 %C, true
+  call cc99 void(i1, ...) @llvm.experimental.guard( i1 %D )[ "deopt"() ]
+  ret void
+}