Commit cf1d9f9f authored by Nikita Popov's avatar Nikita Popov
Browse files

[InstSimplify] Fold icmp with dominating assume 

If we assume(x > y), then we should be able to fold the basic
implications of that, like x >= y. This already happens if either
one of the operands is constant (LVI) or if the conditions are
exactly the same (GVN), but not if we have an implication with
non-constant operands. Support this by querying AssumptionCache.

Fixes https://bugs.llvm.org/show_bug.cgi?id=40149.

Differential Revision: https://reviews.llvm.org/D82717
parent 6fa1343b

llvm/lib/Analysis/InstructionSimplify.cpp

+26 −0
Original line number Diff line number Diff line
@@ -3281,6 +3281,29 @@ static Value *simplifyICmpWithMinMax(CmpInst::Predicate Pred, Value *LHS, 
  return nullptr;

}



static Value *simplifyICmpWithDominatingAssume(CmpInst::Predicate Predicate,

                                               Value *LHS, Value *RHS,

                                               const SimplifyQuery &Q) {

  if (!Q.AC || !Q.CxtI)

    return nullptr;



  for (Value *AssumeBaseOp : {LHS, RHS}) {

    for (auto &AssumeVH : Q.AC->assumptionsFor(AssumeBaseOp)) {

      if (!AssumeVH)

        continue;



      CallInst *Assume = cast<CallInst>(AssumeVH);

      if (Optional<bool> Imp =

              isImpliedCondition(Assume->getArgOperand(0), Predicate, LHS, RHS,

                                 Q.DL))

        if (isValidAssumeForContext(Assume, Q.CxtI, Q.DT))

          return ConstantInt::get(GetCompareTy(LHS), *Imp);

    }

  }



  return nullptr;

}



/// Given operands for an ICmpInst, see if we can fold the result.

/// If not, this returns null.

static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
@@ -3515,6 +3538,9 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 
  if (Value *V = simplifyICmpWithMinMax(Pred, LHS, RHS, Q, MaxRecurse))

    return V;



  if (Value *V = simplifyICmpWithDominatingAssume(Pred, LHS, RHS, Q))

    return V;



  // Simplify comparisons of related pointers using a powerful, recursive

  // GEP-walk when we have target data available..

  if (LHS->getType()->isPointerTy())

llvm/test/Transforms/InstSimplify/assume_icmp.ll

+15 −24
Original line number Diff line number Diff line
@@ -8,22 +8,14 @@ define void @basic_ugt(i32 %x, i32 %y) { 
; CHECK-LABEL: @basic_ugt(

; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i32 [[X:%.*]], [[Y:%.*]]

; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP1]])

; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i32 [[X]], [[Y]]

; CHECK-NEXT:    call void @use(i1 [[CMP2]])

; CHECK-NEXT:    [[CMP3:%.*]] = icmp uge i32 [[X]], [[Y]]

; CHECK-NEXT:    call void @use(i1 [[CMP3]])

; CHECK-NEXT:    [[CMP4:%.*]] = icmp ult i32 [[X]], [[Y]]

; CHECK-NEXT:    call void @use(i1 [[CMP4]])

; CHECK-NEXT:    [[CMP5:%.*]] = icmp ule i32 [[X]], [[Y]]

; CHECK-NEXT:    call void @use(i1 [[CMP5]])

; CHECK-NEXT:    [[CMP6:%.*]] = icmp ugt i32 [[Y]], [[X]]

; CHECK-NEXT:    call void @use(i1 [[CMP6]])

; CHECK-NEXT:    [[CMP7:%.*]] = icmp uge i32 [[Y]], [[X]]

; CHECK-NEXT:    call void @use(i1 [[CMP7]])

; CHECK-NEXT:    [[CMP8:%.*]] = icmp ult i32 [[Y]], [[X]]

; CHECK-NEXT:    call void @use(i1 [[CMP8]])

; CHECK-NEXT:    [[CMP9:%.*]] = icmp ule i32 [[Y]], [[X]]

; CHECK-NEXT:    call void @use(i1 [[CMP9]])

; CHECK-NEXT:    call void @use(i1 true)

; CHECK-NEXT:    call void @use(i1 true)

; CHECK-NEXT:    call void @use(i1 false)

; CHECK-NEXT:    call void @use(i1 false)

; CHECK-NEXT:    call void @use(i1 false)

; CHECK-NEXT:    call void @use(i1 false)

; CHECK-NEXT:    call void @use(i1 true)

; CHECK-NEXT:    call void @use(i1 true)

; CHECK-NEXT:    ret void

;

  %cmp1 = icmp ugt i32 %x, %y
@@ -56,20 +48,16 @@ define void @basic_uge(i32 %x, i32 %y) { 
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP1]])

; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i32 [[X]], [[Y]]

; CHECK-NEXT:    call void @use(i1 [[CMP2]])

; CHECK-NEXT:    [[CMP3:%.*]] = icmp uge i32 [[X]], [[Y]]

; CHECK-NEXT:    call void @use(i1 [[CMP3]])

; CHECK-NEXT:    [[CMP4:%.*]] = icmp ult i32 [[X]], [[Y]]

; CHECK-NEXT:    call void @use(i1 [[CMP4]])

; CHECK-NEXT:    call void @use(i1 true)

; CHECK-NEXT:    call void @use(i1 false)

; CHECK-NEXT:    [[CMP5:%.*]] = icmp ule i32 [[X]], [[Y]]

; CHECK-NEXT:    call void @use(i1 [[CMP5]])

; CHECK-NEXT:    [[CMP6:%.*]] = icmp ugt i32 [[Y]], [[X]]

; CHECK-NEXT:    call void @use(i1 [[CMP6]])

; CHECK-NEXT:    call void @use(i1 false)

; CHECK-NEXT:    [[CMP7:%.*]] = icmp uge i32 [[Y]], [[X]]

; CHECK-NEXT:    call void @use(i1 [[CMP7]])

; CHECK-NEXT:    [[CMP8:%.*]] = icmp ult i32 [[Y]], [[X]]

; CHECK-NEXT:    call void @use(i1 [[CMP8]])

; CHECK-NEXT:    [[CMP9:%.*]] = icmp ule i32 [[Y]], [[X]]

; CHECK-NEXT:    call void @use(i1 [[CMP9]])

; CHECK-NEXT:    call void @use(i1 true)

; CHECK-NEXT:    ret void

;

  %cmp1 = icmp uge i32 %x, %y
@@ -96,6 +84,9 @@ define void @basic_uge(i32 %x, i32 %y) { 
  ret void

}



; This does not simplify in InstSimplify, because AssumptionCache tracker

; does not track values through "and". The "and" assume will be broken

; down into two separate assume calls by InstCombine.

define void @and(i32 %x, i32 %y, i32 %z) {

; CHECK-LABEL: @and(

; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i32 [[X:%.*]], [[Y:%.*]]