Invariant intrinsic canonicalization

[hfinkel]

Summary

This patch adds some simple canonicalization of invariant intrinsics to instcombine. For now, only this:

invariant(a && b) -> invariant(a); invariant(b)

[hfinkel]

No change, but rebased against the latest version of http://reviews.llvm.org/D4490 (because this patch adds to the end of the same regression test).

[hfinkel]

Also canonicalize: invariant(!(a || b)) -> invariant(!a); invariant(!b);

[hfinkel]

Rebased.

[chandlerc]

LGTM (when the prerequisite stuff is settled)

[hfinkel]

Renamed to llvm.assume.

[reames]

LGTM.

lib/Transforms/InstCombine/InstCombineCalls.cpp

1004

Extracting out II->getCalledValue with a name like "AssumeIntrinsic" would make this code easier to understand on first glance.

[hfinkel]

r213977, thanks!

lib/Transforms/InstCombine/InstCombineCalls.cpp

1004

Done.

lib/Transforms/InstCombine/InstCombineCalls.cpp

case Intrinsic::stackrestore: {
 
     // If the stack restore is in a return, resume, or unwind block and if there
     // are no allocas or calls between the restore and the return, nuke the
     // restore.
     if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI)))
       return EraseInstFromFunction(CI);
     break;
   }
+  case Intrinsic::invariant: {
+    // Canonicalize invariant(a && b) -> invariant(a); invariant(b);
+    Value *IIOperand = II->getArgOperand(0), *A, *B;
+    if (match(IIOperand, m_And(m_Value(A), m_Value(B)))) {
+      Builder->CreateCall(II->getCalledValue(), A, II->getName());
+      Builder->CreateCall(II->getCalledValue(), B, II->getName());
+      return EraseInstFromFunction(*II);
+    }
+    // invariant(!(a || b)) -> invariant(!a); invariant(!b);
+    if (match(IIOperand, m_Not(m_Or(m_Value(A), m_Value(B))))) {
+      Builder->CreateCall(II->getCalledValue(), Builder->CreateNot(A), II->getName());
+      Builder->CreateCall(II->getCalledValue(), Builder->CreateNot(B), II->getName());
+      return EraseInstFromFunction(*II);
+    }
+    break;
+  }
   }
 
   return visitCallSite(II);
 }
 
 // InvokeInst simplification
 //
 Instruction *InstCombiner::visitInvokeInst(InvokeInst &II) {

test/Transforms/InstCombine/invariants.ll

entry:
   tail call void @llvm.invariant(i1 %cmp)
   %0 = zext i1 %cmp to i32
   %lnot.ext = xor i32 %0, 1
   ret i32 %lnot.ext
 
 ; CHECK-LABEL: @icmp2
 ; CHECK: call void @llvm.invariant
 ; CHECK: ret i32 0
+}
+
+; Function Attrs: nounwind uwtable
+define i32 @can1(i1 %a, i1 %b, i1 %c) {
+entry:
+  %and1 = and i1 %a, %b
+  %and  = and i1 %and1, %c
+  tail call void @llvm.invariant(i1 %and)
+
+; CHECK-LABEL: @can1
+; CHECK: call void @llvm.invariant(i1 %a)
+; CHECK: call void @llvm.invariant(i1 %b)
+; CHECK: call void @llvm.invariant(i1 %c)
+; CHECK: ret i32
+
+  ret i32 5
+}
+
+; Function Attrs: nounwind uwtable
+define i32 @can2(i1 %a, i1 %b, i1 %c) {
+entry:
+  %v = or i1 %a, %b
+  %w = xor i1 %v, 1
+  tail call void @llvm.invariant(i1 %w)
+
+; CHECK-LABEL: @can2
+; CHECK: %[[V1:[^ ]+]] = xor i1 %a, true
+; CHECK: call void @llvm.invariant(i1 %[[V1]])
+; CHECK: %[[V2:[^ ]+]] = xor i1 %b, true
+; CHECK: call void @llvm.invariant(i1 %[[V2]])
+; CHECK: ret i32
 
+  ret i32 5
 }
 
 attributes #0 = { nounwind uwtable }
 attributes #1 = { nounwind }