RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 02:52:53 +02:00
Code Issues Projects Releases Wiki Activity

[LVI] Extract helper for binary range calculations; NFC

Browse Source 
llvm-svn: 361692
This commit is contained in:
Nikita Popov 2019-05-25 09:53:37 +00:00
parent 9d88bde411
commit e405dadc9f
1 changed files with 28 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
lib/Analysis/LazyValueInfo.cpp
View File

@ -422,6 +422,10 @@ namespace {
BasicBlock *BB);
Optional<ConstantRange> getRangeForOperand(unsigned Op, Instruction *I,
BasicBlock *BB);
bool solveBlockValueBinaryOpImpl(
ValueLatticeElement &BBLV, Instruction *I, BasicBlock *BB,
std::function<ConstantRange(const ConstantRange &,
const ConstantRange &)> OpFn);
bool solveBlockValueBinaryOp(ValueLatticeElement &BBLV, BinaryOperator *BBI,
BasicBlock *BB);
bool solveBlockValueCast(ValueLatticeElement &BBLV, CastInst *CI,
@ -1040,6 +1044,26 @@ bool LazyValueInfoImpl::solveBlockValueCast(ValueLatticeElement &BBLV,
return true;
}
bool LazyValueInfoImpl::solveBlockValueBinaryOpImpl(
ValueLatticeElement &BBLV, Instruction *I, BasicBlock *BB,
std::function<ConstantRange(const ConstantRange &,
const ConstantRange &)> OpFn) {
// Figure out the ranges of the operands. If that fails, use a
// conservative range, but apply the transfer rule anyways. This
// lets us pick up facts from expressions like "and i32 (call i32
// @foo()), 32"
Optional<ConstantRange> LHSRes = getRangeForOperand(0, I, BB);
Optional<ConstantRange> RHSRes = getRangeForOperand(1, I, BB);
if (!LHSRes.hasValue() || !RHSRes.hasValue())
// More work to do before applying this transfer rule.
return false;
ConstantRange LHSRange = LHSRes.getValue();
ConstantRange RHSRange = RHSRes.getValue();
BBLV = ValueLatticeElement::getRange(OpFn(LHSRange, RHSRange));
return true;
}
bool LazyValueInfoImpl::solveBlockValueBinaryOp(ValueLatticeElement &BBLV,
BinaryOperator *BO,
BasicBlock *BB) {
@ -1060,8 +1084,10 @@ bool LazyValueInfoImpl::solveBlockValueBinaryOp(ValueLatticeElement &BBLV,
case Instruction::AShr:
case Instruction::And:
case Instruction::Or:
// continue into the code below
break;
return solveBlockValueBinaryOpImpl(BBLV, BO, BB,
[BO](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.binaryOp(BO->getOpcode(), CR2);
});
default:
// Unhandled instructions are overdefined.
LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
@ -1069,27 +1095,6 @@ bool LazyValueInfoImpl::solveBlockValueBinaryOp(ValueLatticeElement &BBLV,
BBLV = ValueLatticeElement::getOverdefined();
return true;
};
// Figure out the ranges of the operands. If that fails, use a
// conservative range, but apply the transfer rule anyways. This
// lets us pick up facts from expressions like "and i32 (call i32
// @foo()), 32"
Optional<ConstantRange> LHSRes = getRangeForOperand(0, BO, BB);
Optional<ConstantRange> RHSRes = getRangeForOperand(1, BO, BB);
if (!LHSRes.hasValue() || !RHSRes.hasValue())
// More work to do before applying this transfer rule.
return false;
ConstantRange LHSRange = LHSRes.getValue();
ConstantRange RHSRange = RHSRes.getValue();
// NOTE: We're currently limited by the set of operations that ConstantRange
// can evaluate symbolically. Enhancing that set will allows us to analyze
// more definitions.
Instruction::BinaryOps BinOp = BO->getOpcode();
BBLV = ValueLatticeElement::getRange(LHSRange.binaryOp(BinOp, RHSRange));
return true;
}
static ValueLatticeElement getValueFromICmpCondition(Value *Val, ICmpInst *ICI,