[InlineCost] Simplify more 'and' and 'or' operations.

[mcrosier]

Summary

The idea is fairly straight forward. The primary advantage of this simplification is that it can cause parts of the CFG to become unreachable. See the fifth test case as an example.

Chad

[efriedma]

lib/Analysis/InlineCost.cpp

811

The isIntegerTy(1) check seems unnecessary.

[mcrosier]

Address Geoff's offline comments.
-Remove the constraint that the 'and' or 'or' is operating on an i1 value.

[mcrosier]

lib/Analysis/InlineCost.cpp

811

Yup! I've uploaded a new patch.

[mcrosier]

Update comments and minor formatting improvements.

[mcrosier]

Ping.

[chandlerc]

LGTM

It'd be nice if we could enhance the generic code to handle this and other fundamental identities, but still, seems fine and plugs a hole.

lib/Analysis/InlineCost.cpp

class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> {
   bool visitPHI(PHINode &I);
   bool visitGetElementPtr(GetElementPtrInst &I);
   bool visitBitCast(BitCastInst &I);
   bool visitPtrToInt(PtrToIntInst &I);
   bool visitIntToPtr(IntToPtrInst &I);
   bool visitCastInst(CastInst &I);
   bool visitUnaryInstruction(UnaryInstruction &I);
   bool visitCmpInst(CmpInst &I);
+  bool visitAnd(BinaryOperator &I);
+  bool visitOr(BinaryOperator &I);
   bool visitSub(BinaryOperator &I);
   bool visitBinaryOperator(BinaryOperator &I);
   bool visitLoad(LoadInst &I);
   bool visitStore(StoreInst &I);
   bool visitExtractValue(ExtractValueInst &I);
   bool visitInsertValue(InsertValueInst &I);
   bool visitCallSite(CallSite CS);
   bool visitReturnInst(ReturnInst &RI);
if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt)) {
     }
 
     disableSROA(CostIt);
   }
 
   return false;
 }
 
+bool CallAnalyzer::visitOr(BinaryOperator &I) {
+  // See if we can simplify a logical 'or'.  If either operand simplifies to
+  // true, the 'or' simplifies to true.  This is necessary because the generic
+  // simplify instruction only works if both operands are constants.
+  if (I.getType()->isIntegerTy(1)) {
+    for (unsigned i = 0; i < 2; ++i) {
+      Value *Op = I.getOperand(i);
+      if (ConstantInt *C =
+              dyn_cast_or_null<ConstantInt>(SimplifiedValues.lookup(Op)))
+        if (C->isOne()) {
+          SimplifiedValues[&I] = C;
+          return true;
+        }
+    }
+  }
+  return Base::visitOr(I);
+}
+
+bool CallAnalyzer::visitAnd(BinaryOperator &I) {
+  // See if we can simplify a logical 'and'.  If either operand simplifies to
+  // false, the 'and' simplifies to false.  This is necessary because the
+  // generic simplify instruction only works if both operands are constants.
+  if (I.getType()->isIntegerTy(1)) {
+    for (unsigned i = 0; i < 2; ++i) {
+      Value *Op = I.getOperand(i);
+      if (ConstantInt *C =
+              dyn_cast_or_null<ConstantInt>(SimplifiedValues.lookup(Op)))
+        if (C->isZero()) {
+          SimplifiedValues[&I] = C;
+          return true;
+        }
+    }
+  }
+  return Base::visitAnd(I);
+}
+
 bool CallAnalyzer::visitSub(BinaryOperator &I) {
   // Try to handle a special case: we can fold computing the difference of two
   // constant-related pointers.
   Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
   Value *LHSBase, *RHSBase;
   APInt LHSOffset, RHSOffset;
   std::tie(LHSBase, LHSOffset) = ConstantOffsetPtrs.lookup(LHS);
   if (LHSBase) {

test/Transforms/Inline/AArch64/logical-and-or.ll

+; REQUIRES: asserts
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
+
+target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
+target triple = "aarch64--linux-gnu"
+
+; FIXME: Once the 'or' or 'and' is simplified the second compare is dead, but
+; the inline cost model has already added the cost.
+
+define i1 @outer1(i32 %a) {
+  %C = call i1 @inner1(i32 0, i32 %a)
+  ret i1 %C
+}
+
+; CHECK: Analyzing call of inner1
+; CHECK: NumInstructionsSimplified: 3
+; CHECK: NumInstructions: 4
+define i1 @inner1(i32 %a, i32 %b) {
+  %tobool = icmp eq i32 %a, 0         ; Simplifies to true
+  %tobool1 = icmp eq i32 %b, 0        ; Should be dead once 'or' is simplified
+  %or.cond = or i1 %tobool, %tobool1  ; Simplifies to true
+  ret i1 %or.cond                     ; Simplifies to ret i1 true
+}
+
+define i1 @outer2(i32 %a) {
+  %C = call i1 @inner2(i32 1, i32 %a)
+  ret i1 %C
+}
+
+; CHECK: Analyzing call of inner2
+; CHECK: NumInstructionsSimplified: 3
+; CHECK: NumInstructions: 4
+define i1 @inner2(i32 %a, i32 %b) {
+  %tobool = icmp eq i32 %a, 0          ; Simplifies to false
+  %tobool1 = icmp eq i32 %b, 0         ; Should be dead once 'and' is simplified
+  %and.cond = and i1 %tobool, %tobool1 ; Simplifies to false
+  ret i1 %and.cond                     ; Simplifies to ret i1 false
+}
+
+define i1 @outer3(i32 %a) {
+  %C = call i1 @inner3(i32 0, i32 %a)
+  ret i1 %C
+}
+
+; CHECK: Analyzing call of inner3
+; CHECK: NumInstructionsSimplified: 3
+; CHECK: NumInstructions: 4
+define i1 @inner3(i32 %a, i32 %b) {
+  %tobool = icmp eq i32 %a, 0         ; Simplifies to true
+  %tobool1 = icmp eq i32 %b, 0        ; Should be dead once 'or' is simplified
+  %or.cond = or i1 %tobool, %tobool1  ; Simplifies to true
+  br i1 %or.cond, label %end, label %isfalse ; Simplifies to br label %end
+
+isfalse:             ; This block is unreachable once inlined
+  call void @dead()
+  call void @dead()
+  call void @dead()
+  call void @dead()
+  call void @dead()
+  br label %end
+
+end:
+  ret i1 %or.cond    ; Simplifies to ret i1 true
+}
+
+declare void @dead()