From 8391d18d9c69e9337b473f0af37e0d858bd55cd8 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Sat, 25 May 2019 09:53:45 +0000 Subject: [PATCH] [LVI][CVP] Calculate with.overflow result range In LVI, calculate the range of extractvalue(op.with.overflow(%x, %y), 0) as the range of op(%x, %y). This is mainly useful in conjunction with D60650: If the result of the operation is extracted in a branch guarded against overflow, then the value of %x will be appropriately constrained and the result range of the operation will be calculated taking that into account. Differential Revision: https://reviews.llvm.org/D60656 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@361693 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Analysis/LazyValueInfo.cpp | 15 +++++++++++++ .../overflow_predicate.ll | 21 +++++++------------ 2 files changed, 22 insertions(+), 14 deletions(-) diff --git a/lib/Analysis/LazyValueInfo.cpp b/lib/Analysis/LazyValueInfo.cpp index fab2bad16ff..4feff1c7764 100644 --- a/lib/Analysis/LazyValueInfo.cpp +++ b/lib/Analysis/LazyValueInfo.cpp @@ -430,6 +430,8 @@ namespace { BasicBlock *BB); bool solveBlockValueCast(ValueLatticeElement &BBLV, CastInst *CI, BasicBlock *BB); + bool solveBlockValueOverflowIntrinsic( + ValueLatticeElement &BBLV, WithOverflowInst *WO, BasicBlock *BB); void intersectAssumeOrGuardBlockValueConstantRange(Value *Val, ValueLatticeElement &BBLV, Instruction *BBI); @@ -642,6 +644,11 @@ bool LazyValueInfoImpl::solveBlockValueImpl(ValueLatticeElement &Res, if (BinaryOperator *BO = dyn_cast(BBI)) return solveBlockValueBinaryOp(Res, BO, BB); + + if (auto *EVI = dyn_cast(BBI)) + if (auto *WO = dyn_cast(EVI->getAggregateOperand())) + if (EVI->getNumIndices() == 1 && *EVI->idx_begin() == 0) + return solveBlockValueOverflowIntrinsic(Res, WO, BB); } LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName() @@ -1097,6 +1104,14 @@ bool LazyValueInfoImpl::solveBlockValueBinaryOp(ValueLatticeElement &BBLV, }; } +bool LazyValueInfoImpl::solveBlockValueOverflowIntrinsic( + ValueLatticeElement &BBLV, WithOverflowInst *WO, BasicBlock *BB) { + return solveBlockValueBinaryOpImpl(BBLV, WO, BB, + [WO](const ConstantRange &CR1, const ConstantRange &CR2) { + return CR1.binaryOp(WO->getBinaryOp(), CR2); + }); +} + static ValueLatticeElement getValueFromICmpCondition(Value *Val, ICmpInst *ICI, bool isTrueDest) { Value *LHS = ICI->getOperand(0); diff --git a/test/Transforms/CorrelatedValuePropagation/overflow_predicate.ll b/test/Transforms/CorrelatedValuePropagation/overflow_predicate.ll index e651237e65a..aff6e035534 100644 --- a/test/Transforms/CorrelatedValuePropagation/overflow_predicate.ll +++ b/test/Transforms/CorrelatedValuePropagation/overflow_predicate.ll @@ -470,8 +470,7 @@ define i1 @uadd_val(i8 %x, i1* %pc) { ; CHECK: split: ; CHECK-NEXT: [[C1:%.*]] = icmp ugt i8 [[VAL]], 100 ; CHECK-NEXT: store i1 [[C1]], i1* [[PC:%.*]] -; CHECK-NEXT: [[C2:%.*]] = icmp uge i8 [[VAL]], 100 -; CHECK-NEXT: ret i1 [[C2]] +; CHECK-NEXT: ret i1 true ; CHECK: trap: ; CHECK-NEXT: call void @llvm.trap() ; CHECK-NEXT: unreachable @@ -506,8 +505,7 @@ define i1 @sadd_val(i8 %x, i1* %pc) { ; CHECK: split: ; CHECK-NEXT: [[C1:%.*]] = icmp sgt i8 [[VAL]], -28 ; CHECK-NEXT: store i1 [[C1]], i1* [[PC:%.*]] -; CHECK-NEXT: [[C2:%.*]] = icmp sge i8 [[VAL]], -28 -; CHECK-NEXT: ret i1 [[C2]] +; CHECK-NEXT: ret i1 true ; CHECK: trap: ; CHECK-NEXT: call void @llvm.trap() ; CHECK-NEXT: unreachable @@ -542,8 +540,7 @@ define i1 @usub_val(i8 %x, i1* %pc) { ; CHECK: split: ; CHECK-NEXT: [[C1:%.*]] = icmp ult i8 [[VAL]], -101 ; CHECK-NEXT: store i1 [[C1]], i1* [[PC:%.*]] -; CHECK-NEXT: [[C2:%.*]] = icmp ule i8 [[VAL]], -101 -; CHECK-NEXT: ret i1 [[C2]] +; CHECK-NEXT: ret i1 true ; CHECK: trap: ; CHECK-NEXT: call void @llvm.trap() ; CHECK-NEXT: unreachable @@ -578,8 +575,7 @@ define i1 @ssub_val(i8 %x, i1* %pc) { ; CHECK: split: ; CHECK-NEXT: [[C1:%.*]] = icmp slt i8 [[VAL]], 27 ; CHECK-NEXT: store i1 [[C1]], i1* [[PC:%.*]] -; CHECK-NEXT: [[C2:%.*]] = icmp sle i8 [[VAL]], 27 -; CHECK-NEXT: ret i1 [[C2]] +; CHECK-NEXT: ret i1 true ; CHECK: trap: ; CHECK-NEXT: call void @llvm.trap() ; CHECK-NEXT: unreachable @@ -614,8 +610,7 @@ define i1 @umul_val(i8 %x, i1* %pc) { ; CHECK: split: ; CHECK-NEXT: [[C1:%.*]] = icmp ult i8 [[VAL]], -6 ; CHECK-NEXT: store i1 [[C1]], i1* [[PC:%.*]] -; CHECK-NEXT: [[C2:%.*]] = icmp ule i8 [[VAL]], -6 -; CHECK-NEXT: ret i1 [[C2]] +; CHECK-NEXT: ret i1 true ; CHECK: trap: ; CHECK-NEXT: call void @llvm.trap() ; CHECK-NEXT: unreachable @@ -650,8 +645,7 @@ define i1 @smul_val_bound1(i8 %x, i1* %pc) { ; CHECK: split: ; CHECK-NEXT: [[C1:%.*]] = icmp slt i8 [[VAL]], 120 ; CHECK-NEXT: store i1 [[C1]], i1* [[PC:%.*]] -; CHECK-NEXT: [[C2:%.*]] = icmp sle i8 [[VAL]], 120 -; CHECK-NEXT: ret i1 [[C2]] +; CHECK-NEXT: ret i1 true ; CHECK: trap: ; CHECK-NEXT: call void @llvm.trap() ; CHECK-NEXT: unreachable @@ -686,8 +680,7 @@ define i1 @smul_val_bound2(i8 %x, i1* %pc) { ; CHECK: split: ; CHECK-NEXT: [[C1:%.*]] = icmp sgt i8 [[VAL]], -120 ; CHECK-NEXT: store i1 [[C1]], i1* [[PC:%.*]] -; CHECK-NEXT: [[C2:%.*]] = icmp sge i8 [[VAL]], -120 -; CHECK-NEXT: ret i1 [[C2]] +; CHECK-NEXT: ret i1 true ; CHECK: trap: ; CHECK-NEXT: call void @llvm.trap() ; CHECK-NEXT: unreachable -- 2.40.0