[llvm] e275faa - [Analysis] Use std::optional in LazyValueInfo.cpp (NFC)
Kazu Hirata via llvm-commits
llvm-commits at lists.llvm.org
Sun Dec 11 01:18:42 PST 2022
Author: Kazu Hirata
Date: 2022-12-11T01:18:36-08:00
New Revision: e275faa5fef3dd001e7e5bfda35bd541cc841c84
URL: https://github.com/llvm/llvm-project/commit/e275faa5fef3dd001e7e5bfda35bd541cc841c84
DIFF: https://github.com/llvm/llvm-project/commit/e275faa5fef3dd001e7e5bfda35bd541cc841c84.diff
LOG: [Analysis] Use std::optional in LazyValueInfo.cpp (NFC)
This is part of an effort to migrate from llvm::Optional to
std::optional:
https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716
Added:
Modified:
llvm/lib/Analysis/LazyValueInfo.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Analysis/LazyValueInfo.cpp b/llvm/lib/Analysis/LazyValueInfo.cpp
index 1e0b9c27fd8b2..ba91c35b25a1c 100644
--- a/llvm/lib/Analysis/LazyValueInfo.cpp
+++ b/llvm/lib/Analysis/LazyValueInfo.cpp
@@ -211,8 +211,8 @@ namespace {
addValueHandle(Val);
}
- Optional<ValueLatticeElement> getCachedValueInfo(Value *V,
- BasicBlock *BB) const {
+ std::optional<ValueLatticeElement>
+ getCachedValueInfo(Value *V, BasicBlock *BB) const {
const BlockCacheEntry *Entry = getBlockEntry(BB);
if (!Entry)
return std::nullopt;
@@ -395,38 +395,40 @@ class LazyValueInfoImpl {
/// if it exists in the module.
Function *GuardDecl;
- Optional<ValueLatticeElement> getBlockValue(Value *Val, BasicBlock *BB,
- Instruction *CxtI);
- Optional<ValueLatticeElement> getEdgeValue(Value *V, BasicBlock *F,
- BasicBlock *T, Instruction *CxtI = nullptr);
+ std::optional<ValueLatticeElement> getBlockValue(Value *Val, BasicBlock *BB,
+ Instruction *CxtI);
+ std::optional<ValueLatticeElement> getEdgeValue(Value *V, BasicBlock *F,
+ BasicBlock *T,
+ Instruction *CxtI = nullptr);
// These methods process one work item and may add more. A false value
// returned means that the work item was not completely processed and must
// be revisited after going through the new items.
bool solveBlockValue(Value *Val, BasicBlock *BB);
- Optional<ValueLatticeElement> solveBlockValueImpl(Value *Val, BasicBlock *BB);
- Optional<ValueLatticeElement> solveBlockValueNonLocal(Value *Val,
- BasicBlock *BB);
- Optional<ValueLatticeElement> solveBlockValuePHINode(PHINode *PN,
- BasicBlock *BB);
- Optional<ValueLatticeElement> solveBlockValueSelect(SelectInst *S,
- BasicBlock *BB);
- Optional<ConstantRange> getRangeFor(Value *V, Instruction *CxtI,
- BasicBlock *BB);
- Optional<ValueLatticeElement> solveBlockValueBinaryOpImpl(
+ std::optional<ValueLatticeElement> solveBlockValueImpl(Value *Val,
+ BasicBlock *BB);
+ std::optional<ValueLatticeElement> solveBlockValueNonLocal(Value *Val,
+ BasicBlock *BB);
+ std::optional<ValueLatticeElement> solveBlockValuePHINode(PHINode *PN,
+ BasicBlock *BB);
+ std::optional<ValueLatticeElement> solveBlockValueSelect(SelectInst *S,
+ BasicBlock *BB);
+ std::optional<ConstantRange> getRangeFor(Value *V, Instruction *CxtI,
+ BasicBlock *BB);
+ std::optional<ValueLatticeElement> solveBlockValueBinaryOpImpl(
Instruction *I, BasicBlock *BB,
- std::function<ConstantRange(const ConstantRange &,
- const ConstantRange &)> OpFn);
- Optional<ValueLatticeElement> solveBlockValueBinaryOp(BinaryOperator *BBI,
- BasicBlock *BB);
- Optional<ValueLatticeElement> solveBlockValueCast(CastInst *CI,
- BasicBlock *BB);
- Optional<ValueLatticeElement> solveBlockValueOverflowIntrinsic(
- WithOverflowInst *WO, BasicBlock *BB);
- Optional<ValueLatticeElement> solveBlockValueIntrinsic(IntrinsicInst *II,
+ std::function<ConstantRange(const ConstantRange &, const ConstantRange &)>
+ OpFn);
+ std::optional<ValueLatticeElement>
+ solveBlockValueBinaryOp(BinaryOperator *BBI, BasicBlock *BB);
+ std::optional<ValueLatticeElement> solveBlockValueCast(CastInst *CI,
BasicBlock *BB);
- Optional<ValueLatticeElement> solveBlockValueExtractValue(
- ExtractValueInst *EVI, BasicBlock *BB);
+ std::optional<ValueLatticeElement>
+ solveBlockValueOverflowIntrinsic(WithOverflowInst *WO, BasicBlock *BB);
+ std::optional<ValueLatticeElement> solveBlockValueIntrinsic(IntrinsicInst *II,
+ BasicBlock *BB);
+ std::optional<ValueLatticeElement>
+ solveBlockValueExtractValue(ExtractValueInst *EVI, BasicBlock *BB);
bool isNonNullAtEndOfBlock(Value *Val, BasicBlock *BB);
void intersectAssumeOrGuardBlockValueConstantRange(Value *Val,
ValueLatticeElement &BBLV,
@@ -517,7 +519,7 @@ void LazyValueInfoImpl::solve() {
// The work item was completely processed.
assert(BlockValueStack.back() == e && "Nothing should have been pushed!");
#ifndef NDEBUG
- Optional<ValueLatticeElement> BBLV =
+ std::optional<ValueLatticeElement> BBLV =
TheCache.getCachedValueInfo(e.second, e.first);
assert(BBLV && "Result should be in cache!");
LLVM_DEBUG(
@@ -534,13 +536,14 @@ void LazyValueInfoImpl::solve() {
}
}
-Optional<ValueLatticeElement> LazyValueInfoImpl::getBlockValue(
- Value *Val, BasicBlock *BB, Instruction *CxtI) {
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::getBlockValue(Value *Val, BasicBlock *BB,
+ Instruction *CxtI) {
// If already a constant, there is nothing to compute.
if (Constant *VC = dyn_cast<Constant>(Val))
return ValueLatticeElement::get(VC);
- if (Optional<ValueLatticeElement> OptLatticeVal =
+ if (std::optional<ValueLatticeElement> OptLatticeVal =
TheCache.getCachedValueInfo(Val, BB)) {
intersectAssumeOrGuardBlockValueConstantRange(Val, *OptLatticeVal, CxtI);
return OptLatticeVal;
@@ -578,7 +581,7 @@ bool LazyValueInfoImpl::solveBlockValue(Value *Val, BasicBlock *BB) {
// Hold off inserting this value into the Cache in case we have to return
// false and come back later.
- Optional<ValueLatticeElement> Res = solveBlockValueImpl(Val, BB);
+ std::optional<ValueLatticeElement> Res = solveBlockValueImpl(Val, BB);
if (!Res)
// Work pushed, will revisit
return false;
@@ -587,8 +590,8 @@ bool LazyValueInfoImpl::solveBlockValue(Value *Val, BasicBlock *BB) {
return true;
}
-Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueImpl(
- Value *Val, BasicBlock *BB) {
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::solveBlockValueImpl(Value *Val, BasicBlock *BB) {
Instruction *BBI = dyn_cast<Instruction>(Val);
if (!BBI || BBI->getParent() != BB)
return solveBlockValueNonLocal(Val, BB);
@@ -670,8 +673,8 @@ bool LazyValueInfoImpl::isNonNullAtEndOfBlock(Value *Val, BasicBlock *BB) {
});
}
-Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueNonLocal(
- Value *Val, BasicBlock *BB) {
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::solveBlockValueNonLocal(Value *Val, BasicBlock *BB) {
ValueLatticeElement Result; // Start Undefined.
// If this is the entry block, we must be asking about an argument. The
@@ -691,7 +694,7 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueNonLocal(
// canonicalizing to make this true rather than relying on this happy
// accident.
for (BasicBlock *Pred : predecessors(BB)) {
- Optional<ValueLatticeElement> EdgeResult = getEdgeValue(Val, Pred, BB);
+ std::optional<ValueLatticeElement> EdgeResult = getEdgeValue(Val, Pred, BB);
if (!EdgeResult)
// Explore that input, then return here
return std::nullopt;
@@ -713,8 +716,8 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueNonLocal(
return Result;
}
-Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValuePHINode(
- PHINode *PN, BasicBlock *BB) {
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::solveBlockValuePHINode(PHINode *PN, BasicBlock *BB) {
ValueLatticeElement Result; // Start Undefined.
// Loop over all of our predecessors, merging what we know from them into
@@ -726,7 +729,7 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValuePHINode(
// Note that we can provide PN as the context value to getEdgeValue, even
// though the results will be cached, because PN is the value being used as
// the cache key in the caller.
- Optional<ValueLatticeElement> EdgeResult =
+ std::optional<ValueLatticeElement> EdgeResult =
getEdgeValue(PhiVal, PhiBB, BB, PN);
if (!EdgeResult)
// Explore that input, then return here
@@ -803,16 +806,16 @@ static ConstantRange getConstantRangeOrFull(const ValueLatticeElement &Val,
return ConstantRange::getFull(DL.getTypeSizeInBits(Ty));
}
-Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueSelect(
- SelectInst *SI, BasicBlock *BB) {
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::solveBlockValueSelect(SelectInst *SI, BasicBlock *BB) {
// Recurse on our inputs if needed
- Optional<ValueLatticeElement> OptTrueVal =
+ std::optional<ValueLatticeElement> OptTrueVal =
getBlockValue(SI->getTrueValue(), BB, SI);
if (!OptTrueVal)
return std::nullopt;
ValueLatticeElement &TrueVal = *OptTrueVal;
- Optional<ValueLatticeElement> OptFalseVal =
+ std::optional<ValueLatticeElement> OptFalseVal =
getBlockValue(SI->getFalseValue(), BB, SI);
if (!OptFalseVal)
return std::nullopt;
@@ -884,17 +887,16 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueSelect(
return Result;
}
-Optional<ConstantRange> LazyValueInfoImpl::getRangeFor(Value *V,
- Instruction *CxtI,
- BasicBlock *BB) {
- Optional<ValueLatticeElement> OptVal = getBlockValue(V, BB, CxtI);
+std::optional<ConstantRange>
+LazyValueInfoImpl::getRangeFor(Value *V, Instruction *CxtI, BasicBlock *BB) {
+ std::optional<ValueLatticeElement> OptVal = getBlockValue(V, BB, CxtI);
if (!OptVal)
return std::nullopt;
return getConstantRangeOrFull(*OptVal, V->getType(), DL);
}
-Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueCast(
- CastInst *CI, BasicBlock *BB) {
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::solveBlockValueCast(CastInst *CI, BasicBlock *BB) {
// Without knowing how wide the input is, we can't analyze it in any useful
// way.
if (!CI->getOperand(0)->getType()->isSized())
@@ -919,7 +921,7 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueCast(
// Figure out the range of the LHS. If that fails, we still apply the
// transfer rule on the full set since we may be able to locally infer
// interesting facts.
- Optional<ConstantRange> LHSRes = getRangeFor(CI->getOperand(0), CI, BB);
+ std::optional<ConstantRange> LHSRes = getRangeFor(CI->getOperand(0), CI, BB);
if (!LHSRes)
// More work to do before applying this transfer rule.
return std::nullopt;
@@ -934,16 +936,17 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueCast(
ResultBitWidth));
}
-Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueBinaryOpImpl(
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::solveBlockValueBinaryOpImpl(
Instruction *I, BasicBlock *BB,
- std::function<ConstantRange(const ConstantRange &,
- const ConstantRange &)> OpFn) {
+ 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 = getRangeFor(I->getOperand(0), I, BB);
- Optional<ConstantRange> RHSRes = getRangeFor(I->getOperand(1), I, BB);
+ std::optional<ConstantRange> LHSRes = getRangeFor(I->getOperand(0), I, BB);
+ std::optional<ConstantRange> RHSRes = getRangeFor(I->getOperand(1), I, BB);
if (!LHSRes || !RHSRes)
// More work to do before applying this transfer rule.
return std::nullopt;
@@ -953,8 +956,8 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueBinaryOpImpl(
return ValueLatticeElement::getRange(OpFn(LHSRange, RHSRange));
}
-Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueBinaryOp(
- BinaryOperator *BO, BasicBlock *BB) {
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::solveBlockValueBinaryOp(BinaryOperator *BO, BasicBlock *BB) {
assert(BO->getOperand(0)->getType()->isSized() &&
"all operands to binary operators are sized");
if (auto *OBO = dyn_cast<OverflowingBinaryOperator>(BO)) {
@@ -977,7 +980,7 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueBinaryOp(
});
}
-Optional<ValueLatticeElement>
+std::optional<ValueLatticeElement>
LazyValueInfoImpl::solveBlockValueOverflowIntrinsic(WithOverflowInst *WO,
BasicBlock *BB) {
return solveBlockValueBinaryOpImpl(
@@ -986,8 +989,8 @@ LazyValueInfoImpl::solveBlockValueOverflowIntrinsic(WithOverflowInst *WO,
});
}
-Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueIntrinsic(
- IntrinsicInst *II, BasicBlock *BB) {
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::solveBlockValueIntrinsic(IntrinsicInst *II, BasicBlock *BB) {
if (!ConstantRange::isIntrinsicSupported(II->getIntrinsicID())) {
LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
<< "' - unknown intrinsic.\n");
@@ -996,7 +999,7 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueIntrinsic(
SmallVector<ConstantRange, 2> OpRanges;
for (Value *Op : II->args()) {
- Optional<ConstantRange> Range = getRangeFor(Op, II, BB);
+ std::optional<ConstantRange> Range = getRangeFor(Op, II, BB);
if (!Range)
return std::nullopt;
OpRanges.push_back(*Range);
@@ -1006,8 +1009,9 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueIntrinsic(
ConstantRange::intrinsic(II->getIntrinsicID(), OpRanges));
}
-Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueExtractValue(
- ExtractValueInst *EVI, BasicBlock *BB) {
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::solveBlockValueExtractValue(ExtractValueInst *EVI,
+ BasicBlock *BB) {
if (auto *WO = dyn_cast<WithOverflowInst>(EVI->getAggregateOperand()))
if (EVI->getNumIndices() == 1 && *EVI->idx_begin() == 0)
return solveBlockValueOverflowIntrinsic(WO, BB);
@@ -1163,7 +1167,7 @@ static ValueLatticeElement getValueFromOverflowCondition(
return ValueLatticeElement::getRange(NWR);
}
-static Optional<ValueLatticeElement>
+static std::optional<ValueLatticeElement>
getValueFromConditionImpl(Value *Val, Value *Cond, bool isTrueDest,
bool isRevisit,
SmallDenseMap<Value *, ValueLatticeElement> &Visited,
@@ -1233,7 +1237,7 @@ ValueLatticeElement getValueFromCondition(Value *Val, Value *Cond,
auto Iter =
Visited.try_emplace(CurrentCond, ValueLatticeElement::getOverdefined());
bool isRevisit = !Iter.second;
- Optional<ValueLatticeElement> Result = getValueFromConditionImpl(
+ std::optional<ValueLatticeElement> Result = getValueFromConditionImpl(
Val, CurrentCond, isTrueDest, isRevisit, Visited, Worklist);
if (Result) {
Visited[CurrentCond] = *Result;
@@ -1420,8 +1424,9 @@ static std::optional<ValueLatticeElement> getEdgeValueLocal(Value *Val,
/// Compute the value of Val on the edge BBFrom -> BBTo or the value at
/// the basic block if the edge does not constrain Val.
-Optional<ValueLatticeElement> LazyValueInfoImpl::getEdgeValue(
- Value *Val, BasicBlock *BBFrom, BasicBlock *BBTo, Instruction *CxtI) {
+std::optional<ValueLatticeElement>
+LazyValueInfoImpl::getEdgeValue(Value *Val, BasicBlock *BBFrom,
+ BasicBlock *BBTo, Instruction *CxtI) {
// If already a constant, there is nothing to compute.
if (Constant *VC = dyn_cast<Constant>(Val))
return ValueLatticeElement::get(VC);
@@ -1433,7 +1438,7 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::getEdgeValue(
// Can't get any more precise here
return LocalResult;
- Optional<ValueLatticeElement> OptInBlock =
+ std::optional<ValueLatticeElement> OptInBlock =
getBlockValue(Val, BBFrom, BBFrom->getTerminator());
if (!OptInBlock)
return std::nullopt;
@@ -1458,7 +1463,7 @@ ValueLatticeElement LazyValueInfoImpl::getValueInBlock(Value *V, BasicBlock *BB,
<< BB->getName() << "'\n");
assert(BlockValueStack.empty() && BlockValueSet.empty());
- Optional<ValueLatticeElement> OptResult = getBlockValue(V, BB, CxtI);
+ std::optional<ValueLatticeElement> OptResult = getBlockValue(V, BB, CxtI);
if (!OptResult) {
solve();
OptResult = getBlockValue(V, BB, CxtI);
@@ -1493,7 +1498,8 @@ getValueOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
<< FromBB->getName() << "' to '" << ToBB->getName()
<< "'\n");
- Optional<ValueLatticeElement> Result = getEdgeValue(V, FromBB, ToBB, CxtI);
+ std::optional<ValueLatticeElement> Result =
+ getEdgeValue(V, FromBB, ToBB, CxtI);
if (!Result) {
solve();
Result = getEdgeValue(V, FromBB, ToBB, CxtI);
More information about the llvm-commits
mailing list