[llvm] 75801e3 - Transforms/IPO: llvm::Optional => std::optional
Fangrui Song via llvm-commits
llvm-commits at lists.llvm.org
Sun Dec 4 23:07:27 PST 2022
Author: Fangrui Song
Date: 2022-12-05T07:07:19Z
New Revision: 75801e3b45565d7d14ef6ead2132dc06fc009941
URL: https://github.com/llvm/llvm-project/commit/75801e3b45565d7d14ef6ead2132dc06fc009941
DIFF: https://github.com/llvm/llvm-project/commit/75801e3b45565d7d14ef6ead2132dc06fc009941.diff
LOG: Transforms/IPO: llvm::Optional => std::optional
Added:
Modified:
llvm/include/llvm/Transforms/IPO/Attributor.h
llvm/include/llvm/Transforms/IPO/SampleContextTracker.h
llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
llvm/lib/Transforms/IPO/Attributor.cpp
llvm/lib/Transforms/IPO/AttributorAttributes.cpp
llvm/lib/Transforms/IPO/IROutliner.cpp
llvm/lib/Transforms/IPO/OpenMPOpt.cpp
llvm/lib/Transforms/IPO/SampleContextTracker.cpp
llvm/lib/Transforms/IPO/SampleProfile.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Transforms/IPO/Attributor.h b/llvm/include/llvm/Transforms/IPO/Attributor.h
index 648bdd0750c7..94ce2933fd48 100644
--- a/llvm/include/llvm/Transforms/IPO/Attributor.h
+++ b/llvm/include/llvm/Transforms/IPO/Attributor.h
@@ -206,9 +206,9 @@ Value *getWithType(Value &V, Type &Ty);
/// X + none => X
/// not_none + undef => not_none
/// V1 + V2 => nullptr
-Optional<Value *>
-combineOptionalValuesInAAValueLatice(const Optional<Value *> &A,
- const Optional<Value *> &B, Type *Ty);
+std::optional<Value *>
+combineOptionalValuesInAAValueLatice(const std::optional<Value *> &A,
+ const std::optional<Value *> &B, Type *Ty);
/// Helper to represent an access offset and size, with logic to deal with
/// uncertainty and check for overlapping accesses.
@@ -1745,27 +1745,27 @@ struct Attributor {
/// If \p IRP is assumed to be a constant, return it, if it is unclear yet,
/// return std::nullopt, otherwise return `nullptr`.
- Optional<Constant *> getAssumedConstant(const IRPosition &IRP,
- const AbstractAttribute &AA,
- bool &UsedAssumedInformation);
- Optional<Constant *> getAssumedConstant(const Value &V,
- const AbstractAttribute &AA,
- bool &UsedAssumedInformation) {
+ std::optional<Constant *> getAssumedConstant(const IRPosition &IRP,
+ const AbstractAttribute &AA,
+ bool &UsedAssumedInformation);
+ std::optional<Constant *> getAssumedConstant(const Value &V,
+ const AbstractAttribute &AA,
+ bool &UsedAssumedInformation) {
return getAssumedConstant(IRPosition::value(V), AA, UsedAssumedInformation);
}
/// If \p V is assumed simplified, return it, if it is unclear yet,
/// return std::nullopt, otherwise return `nullptr`.
- Optional<Value *> getAssumedSimplified(const IRPosition &IRP,
- const AbstractAttribute &AA,
- bool &UsedAssumedInformation,
- AA::ValueScope S) {
+ std::optional<Value *> getAssumedSimplified(const IRPosition &IRP,
+ const AbstractAttribute &AA,
+ bool &UsedAssumedInformation,
+ AA::ValueScope S) {
return getAssumedSimplified(IRP, &AA, UsedAssumedInformation, S);
}
- Optional<Value *> getAssumedSimplified(const Value &V,
- const AbstractAttribute &AA,
- bool &UsedAssumedInformation,
- AA::ValueScope S) {
+ std::optional<Value *> getAssumedSimplified(const Value &V,
+ const AbstractAttribute &AA,
+ bool &UsedAssumedInformation,
+ AA::ValueScope S) {
return getAssumedSimplified(IRPosition::value(V), AA,
UsedAssumedInformation, S);
}
@@ -1774,10 +1774,10 @@ struct Attributor {
/// return std::nullopt, otherwise return `nullptr`. Same as the public
/// version except that it can be used without recording dependences on any \p
/// AA.
- Optional<Value *> getAssumedSimplified(const IRPosition &V,
- const AbstractAttribute *AA,
- bool &UsedAssumedInformation,
- AA::ValueScope S);
+ std::optional<Value *> getAssumedSimplified(const IRPosition &V,
+ const AbstractAttribute *AA,
+ bool &UsedAssumedInformation,
+ AA::ValueScope S);
/// Try to simplify \p IRP and in the scope \p S. If successful, true is
/// returned and all potential values \p IRP can take are put into \p Values.
@@ -1793,7 +1793,7 @@ struct Attributor {
/// we it will ask `AAValueSimplify`. It is important to ensure this
/// is called before `identifyDefaultAbstractAttributes`, assuming the
/// latter is called at all.
- using SimplifictionCallbackTy = std::function<Optional<Value *>(
+ using SimplifictionCallbackTy = std::function<std::optional<Value *>(
const IRPosition &, const AbstractAttribute *, bool &)>;
void registerSimplificationCallback(const IRPosition &IRP,
const SimplifictionCallbackTy &CB) {
@@ -1812,8 +1812,8 @@ struct Attributor {
public:
/// Translate \p V from the callee context into the call site context.
- Optional<Value *>
- translateArgumentToCallSiteContent(Optional<Value *> V, CallBase &CB,
+ std::optional<Value *>
+ translateArgumentToCallSiteContent(std::optional<Value *> V, CallBase &CB,
const AbstractAttribute &AA,
bool &UsedAssumedInformation);
@@ -3999,7 +3999,7 @@ struct ValueSimplifyStateType : public AbstractState {
Type *Ty;
/// Merge \p Other into the currently assumed simplified value
- bool unionAssumed(Optional<Value *> Other);
+ bool unionAssumed(std::optional<Value *> Other);
/// Helper to track validity and fixpoint
BooleanState BS;
@@ -4008,7 +4008,7 @@ struct ValueSimplifyStateType : public AbstractState {
/// means that the value is not clear under current assumption. If in the
/// pessimistic state, getAssumedSimplifiedValue doesn't return this value but
/// returns orignal associated value.
- Optional<Value *> SimplifiedAssociatedValue;
+ std::optional<Value *> SimplifiedAssociatedValue;
};
/// An abstract interface for value simplify abstract attribute.
@@ -4043,7 +4043,8 @@ struct AAValueSimplify
/// the Optional::NoneType.
///
/// Use `Attributor::getAssumedSimplified` for value simplification.
- virtual Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const = 0;
+ virtual std::optional<Value *>
+ getAssumedSimplifiedValue(Attributor &A) const = 0;
friend struct Attributor;
};
@@ -4100,7 +4101,7 @@ struct AAPrivatizablePtr
/// Return the type we can choose for a private copy of the underlying
/// value. None means it is not clear yet, nullptr means there is none.
- virtual Optional<Type *> getPrivatizableType() const = 0;
+ virtual std::optional<Type *> getPrivatizableType() const = 0;
/// Create an abstract attribute view for the position \p IRP.
static AAPrivatizablePtr &createForPosition(const IRPosition &IRP,
@@ -4384,7 +4385,7 @@ struct AAValueConstantRange
/// Return an assumed constant for the associated value a program point \p
/// CtxI.
- Optional<Constant *>
+ std::optional<Constant *>
getAssumedConstant(Attributor &A, const Instruction *CtxI = nullptr) const {
ConstantRange RangeV = getAssumedConstantRange(A, CtxI);
if (auto *C = RangeV.getSingleElement()) {
@@ -4635,7 +4636,7 @@ struct AAPotentialConstantValues
Attributor &A);
/// Return assumed constant for the associated value
- Optional<Constant *>
+ std::optional<Constant *>
getAssumedConstant(Attributor &A, const Instruction *CtxI = nullptr) const {
if (!isValidState())
return nullptr;
@@ -5006,13 +5007,14 @@ struct AAPointerInfo : public AbstractAttribute {
/// An access description.
struct Access {
Access(Instruction *I, int64_t Offset, int64_t Size,
- Optional<Value *> Content, AccessKind Kind, Type *Ty)
+ std::optional<Value *> Content, AccessKind Kind, Type *Ty)
: LocalI(I), RemoteI(I), Content(Content), OAS(Offset, Size),
Kind(Kind), Ty(Ty) {
verify();
}
Access(Instruction *LocalI, Instruction *RemoteI, int64_t Offset,
- int64_t Size, Optional<Value *> Content, AccessKind Kind, Type *Ty)
+ int64_t Size, std::optional<Value *> Content, AccessKind Kind,
+ Type *Ty)
: LocalI(LocalI), RemoteI(RemoteI), Content(Content), OAS(Offset, Size),
Kind(Kind), Ty(Ty) {
verify();
@@ -5096,7 +5098,7 @@ struct AAPointerInfo : public AbstractAttribute {
/// Return the written value which can be `llvm::null` if it is not yet
/// determined.
- Optional<Value *> getContent() const { return Content; }
+ std::optional<Value *> getContent() const { return Content; }
/// Return the offset for this access.
int64_t getOffset() const { return OAS.Offset; }
@@ -5114,7 +5116,7 @@ struct AAPointerInfo : public AbstractAttribute {
/// The value written, if any. `llvm::none` means "not known yet", `nullptr`
/// cannot be determined.
- Optional<Value *> Content;
+ std::optional<Value *> Content;
/// The object accessed, in terms of an offset and size in bytes.
AA::OffsetAndSize OAS;
diff --git a/llvm/include/llvm/Transforms/IPO/SampleContextTracker.h b/llvm/include/llvm/Transforms/IPO/SampleContextTracker.h
index 1b1d2ce818f0..347dac1e9684 100644
--- a/llvm/include/llvm/Transforms/IPO/SampleContextTracker.h
+++ b/llvm/include/llvm/Transforms/IPO/SampleContextTracker.h
@@ -51,7 +51,7 @@ class ContextTrieNode {
StringRef getFuncName() const;
FunctionSamples *getFunctionSamples() const;
void setFunctionSamples(FunctionSamples *FSamples);
- Optional<uint32_t> getFunctionSize() const;
+ std::optional<uint32_t> getFunctionSize() const;
void addFunctionSize(uint32_t FSize);
LineLocation getCallSiteLoc() const;
ContextTrieNode *getParentContext() const;
@@ -74,7 +74,7 @@ class ContextTrieNode {
FunctionSamples *FuncSamples;
// Function size for current context
- Optional<uint32_t> FuncSize;
+ std::optional<uint32_t> FuncSize;
// Callsite location in parent context
LineLocation CallSiteLoc;
diff --git a/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp b/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
index 2dbd64a16928..beeda0c25c7b 100644
--- a/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -479,7 +479,7 @@ static bool findArgParts(Argument *Arg, const DataLayout &DL, AAResults &AAR,
// Returns std::nullopt if this load or store is not based on the argument.
// Return true if we can promote the instruction, false otherwise.
auto HandleEndUser = [&](auto *I, Type *Ty,
- bool GuaranteedToExecute) -> Optional<bool> {
+ bool GuaranteedToExecute) -> std::optional<bool> {
// Don't promote volatile or atomic instructions.
if (!I->isSimple())
return false;
@@ -553,7 +553,7 @@ static bool findArgParts(Argument *Arg, const DataLayout &DL, AAResults &AAR,
// Look for loads and stores that are guaranteed to execute on entry.
for (Instruction &I : Arg->getParent()->getEntryBlock()) {
- Optional<bool> Res{};
+ std::optional<bool> Res{};
if (LoadInst *LI = dyn_cast<LoadInst>(&I))
Res = HandleEndUser(LI, LI->getType(), /* GuaranteedToExecute */ true);
else if (StoreInst *SI = dyn_cast<StoreInst>(&I))
diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp
index 820a45408a82..00be64e6ebbb 100644
--- a/llvm/lib/Transforms/IPO/Attributor.cpp
+++ b/llvm/lib/Transforms/IPO/Attributor.cpp
@@ -305,9 +305,10 @@ Value *AA::getWithType(Value &V, Type &Ty) {
return nullptr;
}
-Optional<Value *>
-AA::combineOptionalValuesInAAValueLatice(const Optional<Value *> &A,
- const Optional<Value *> &B, Type *Ty) {
+std::optional<Value *>
+AA::combineOptionalValuesInAAValueLatice(const std::optional<Value *> &A,
+ const std::optional<Value *> &B,
+ Type *Ty) {
if (A == B)
return A;
if (!B)
@@ -391,7 +392,8 @@ static bool getPotentialCopiesOfMemoryValue(
bool NullOnly = true;
bool NullRequired = false;
- auto CheckForNullOnlyAndUndef = [&](Optional<Value *> V, bool IsExact) {
+ auto CheckForNullOnlyAndUndef = [&](std::optional<Value *> V,
+ bool IsExact) {
if (!V || *V == nullptr)
NullOnly = false;
else if (isa<UndefValue>(*V))
@@ -1069,7 +1071,7 @@ void IRPosition::verify() {
#endif
}
-Optional<Constant *>
+std::optional<Constant *>
Attributor::getAssumedConstant(const IRPosition &IRP,
const AbstractAttribute &AA,
bool &UsedAssumedInformation) {
@@ -1077,7 +1079,7 @@ Attributor::getAssumedConstant(const IRPosition &IRP,
// a non-null value that is
diff erent from the associated value, or
// std::nullopt, we assume it's simplified.
for (auto &CB : SimplificationCallbacks.lookup(IRP)) {
- Optional<Value *> SimplifiedV = CB(IRP, &AA, UsedAssumedInformation);
+ std::optional<Value *> SimplifiedV = CB(IRP, &AA, UsedAssumedInformation);
if (!SimplifiedV)
return std::nullopt;
if (isa_and_nonnull<Constant>(*SimplifiedV))
@@ -1099,10 +1101,9 @@ Attributor::getAssumedConstant(const IRPosition &IRP,
return nullptr;
}
-Optional<Value *> Attributor::getAssumedSimplified(const IRPosition &IRP,
- const AbstractAttribute *AA,
- bool &UsedAssumedInformation,
- AA::ValueScope S) {
+std::optional<Value *> Attributor::getAssumedSimplified(
+ const IRPosition &IRP, const AbstractAttribute *AA,
+ bool &UsedAssumedInformation, AA::ValueScope S) {
// First check all callbacks provided by outside AAs. If any of them returns
// a non-null value that is
diff erent from the associated value, or
// std::nullopt, we assume it's simplified.
@@ -1132,7 +1133,7 @@ bool Attributor::getAssumedSimplifiedValues(
// std::nullopt, we assume it's simplified.
const auto &SimplificationCBs = SimplificationCallbacks.lookup(IRP);
for (const auto &CB : SimplificationCBs) {
- Optional<Value *> CBResult = CB(IRP, AA, UsedAssumedInformation);
+ std::optional<Value *> CBResult = CB(IRP, AA, UsedAssumedInformation);
if (!CBResult.has_value())
continue;
Value *V = CBResult.value();
@@ -1156,8 +1157,8 @@ bool Attributor::getAssumedSimplifiedValues(
return true;
}
-Optional<Value *> Attributor::translateArgumentToCallSiteContent(
- Optional<Value *> V, CallBase &CB, const AbstractAttribute &AA,
+std::optional<Value *> Attributor::translateArgumentToCallSiteContent(
+ std::optional<Value *> V, CallBase &CB, const AbstractAttribute &AA,
bool &UsedAssumedInformation) {
if (!V)
return V;
@@ -2779,7 +2780,7 @@ void InformationCache::initializeInformationCache(const Function &CF,
// queried by abstract attributes during their initialization or update.
// This has to happen before we create attributes.
- DenseMap<const Value *, Optional<short>> AssumeUsesMap;
+ DenseMap<const Value *, std::optional<short>> AssumeUsesMap;
// Add \p V to the assume uses map which track the number of uses outside of
// "visited" assumes. If no outside uses are left the value is added to the
@@ -2790,7 +2791,7 @@ void InformationCache::initializeInformationCache(const Function &CF,
Worklist.push_back(I);
while (!Worklist.empty()) {
const Instruction *I = Worklist.pop_back_val();
- Optional<short> &NumUses = AssumeUsesMap[I];
+ std::optional<short> &NumUses = AssumeUsesMap[I];
if (!NumUses)
NumUses = I->getNumUses();
NumUses = NumUses.value() - /* this assume */ 1;
diff --git a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
index cc667e511bf8..1d5565ebf815 100644
--- a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
+++ b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
@@ -404,7 +404,7 @@ static void clampReturnedValueStates(
// Use an optional state as there might not be any return values and we want
// to join (IntegerState::operator&) the state of all there are.
- Optional<StateType> T;
+ std::optional<StateType> T;
// Callback for each possibly returned value.
auto CheckReturnValue = [&](Value &RV) -> bool {
@@ -463,7 +463,7 @@ static void clampCallSiteArgumentStates(Attributor &A, const AAType &QueryingAA,
// Use an optional state as there might not be any return values and we want
// to join (IntegerState::operator&) the state of all there are.
- Optional<StateType> T;
+ std::optional<StateType> T;
// The argument number which is also the call site argument number.
unsigned ArgNo = QueryingAA.getIRPosition().getCallSiteArgNo();
@@ -820,7 +820,7 @@ struct AA::PointerInfo::State : public AbstractState {
///
/// \Returns CHANGED, if the state changed, UNCHANGED otherwise.
ChangeStatus addAccess(Attributor &A, int64_t Offset, int64_t Size,
- Instruction &I, Optional<Value *> Content,
+ Instruction &I, std::optional<Value *> Content,
AAPointerInfo::AccessKind Kind, Type *Ty,
Instruction *RemoteI = nullptr);
@@ -899,7 +899,7 @@ struct AA::PointerInfo::State : public AbstractState {
ChangeStatus AA::PointerInfo::State::addAccess(Attributor &A, int64_t Offset,
int64_t Size, Instruction &I,
- Optional<Value *> Content,
+ std::optional<Value *> Content,
AAPointerInfo::AccessKind Kind,
Type *Ty, Instruction *RemoteI) {
RemoteI = RemoteI ? RemoteI : &I;
@@ -1171,7 +1171,7 @@ struct AAPointerInfoImpl
continue;
bool UsedAssumedInformation = false;
AccessKind AK = RAcc.getKind();
- Optional<Value *> Content = RAcc.getContent();
+ std::optional<Value *> Content = RAcc.getContent();
if (FromCallee) {
Content = A.translateArgumentToCallSiteContent(
RAcc.getContent(), CB, *this, UsedAssumedInformation);
@@ -1219,8 +1219,8 @@ struct AAPointerInfoFloating : public AAPointerInfoImpl {
/// Deal with an access and signal if it was handled successfully.
bool handleAccess(Attributor &A, Instruction &I, Value &Ptr,
- Optional<Value *> Content, AccessKind Kind, int64_t Offset,
- ChangeStatus &Changed, Type *Ty,
+ std::optional<Value *> Content, AccessKind Kind,
+ int64_t Offset, ChangeStatus &Changed, Type *Ty,
int64_t Size = AA::OffsetAndSize::Unknown) {
using namespace AA::PointerInfo;
// No need to find a size if one is given.
@@ -1399,7 +1399,7 @@ struct AAPointerInfoFloating : public AAPointerInfoImpl {
else
AK = AccessKind(AK | AccessKind::AK_MAY);
bool UsedAssumedInformation = false;
- Optional<Value *> Content = nullptr;
+ std::optional<Value *> Content = nullptr;
if (ValueOp)
Content = A.getAssumedSimplified(
*ValueOp, *this, UsedAssumedInformation, AA::Interprocedural);
@@ -1768,7 +1768,7 @@ class AAReturnedValuesImpl : public AAReturnedValues, public AbstractState {
/// Return an assumed unique return value if a single candidate is found. If
/// there cannot be one, return a nullptr. If it is not clear yet, return the
/// Optional::NoneType.
- Optional<Value *> getAssumedUniqueReturnValue(Attributor &A) const;
+ std::optional<Value *> getAssumedUniqueReturnValue(Attributor &A) const;
/// See AbstractState::checkForAllReturnedValues(...).
bool checkForAllReturnedValuesAndReturnInsts(
@@ -1806,7 +1806,7 @@ ChangeStatus AAReturnedValuesImpl::manifest(Attributor &A) {
"Number of function with known return values");
// Check if we have an assumed unique return value that we could manifest.
- Optional<Value *> UniqueRV = getAssumedUniqueReturnValue(A);
+ std::optional<Value *> UniqueRV = getAssumedUniqueReturnValue(A);
if (!UniqueRV || !UniqueRV.value())
return Changed;
@@ -1830,19 +1830,19 @@ const std::string AAReturnedValuesImpl::getAsStr() const {
(isValidState() ? std::to_string(getNumReturnValues()) : "?") + ")";
}
-Optional<Value *>
+std::optional<Value *>
AAReturnedValuesImpl::getAssumedUniqueReturnValue(Attributor &A) const {
// If checkForAllReturnedValues provides a unique value, ignoring potential
// undef values that can also be present, it is assumed to be the actual
// return value and forwarded to the caller of this method. If there are
// multiple, a nullptr is returned indicating there cannot be a unique
// returned value.
- Optional<Value *> UniqueRV;
+ std::optional<Value *> UniqueRV;
Type *Ty = getAssociatedFunction()->getReturnType();
auto Pred = [&](Value &RV) -> bool {
UniqueRV = AA::combineOptionalValuesInAAValueLatice(UniqueRV, &RV, Ty);
- return UniqueRV != Optional<Value *>(nullptr);
+ return UniqueRV != std::optional<Value *>(nullptr);
};
if (!A.checkForAllReturnedValues(Pred, *this))
@@ -2591,7 +2591,8 @@ struct AAUndefinedBehaviorImpl : public AAUndefinedBehavior {
// Either we stopped and the appropriate action was taken,
// or we got back a simplified value to continue.
- Optional<Value *> SimplifiedPtrOp = stopOnUndefOrAssumed(A, PtrOp, &I);
+ std::optional<Value *> SimplifiedPtrOp =
+ stopOnUndefOrAssumed(A, PtrOp, &I);
if (!SimplifiedPtrOp || !SimplifiedPtrOp.value())
return true;
const Value *PtrOpVal = SimplifiedPtrOp.value();
@@ -2635,7 +2636,7 @@ struct AAUndefinedBehaviorImpl : public AAUndefinedBehavior {
// Either we stopped and the appropriate action was taken,
// or we got back a simplified value to continue.
- Optional<Value *> SimplifiedCond =
+ std::optional<Value *> SimplifiedCond =
stopOnUndefOrAssumed(A, BrInst->getCondition(), BrInst);
if (!SimplifiedCond || !*SimplifiedCond)
return true;
@@ -2679,7 +2680,7 @@ struct AAUndefinedBehaviorImpl : public AAUndefinedBehavior {
if (!NoUndefAA.isKnownNoUndef())
continue;
bool UsedAssumedInformation = false;
- Optional<Value *> SimplifiedVal =
+ std::optional<Value *> SimplifiedVal =
A.getAssumedSimplified(IRPosition::value(*ArgVal), *this,
UsedAssumedInformation, AA::Interprocedural);
if (UsedAssumedInformation)
@@ -2705,7 +2706,7 @@ struct AAUndefinedBehaviorImpl : public AAUndefinedBehavior {
auto &RI = cast<ReturnInst>(I);
// Either we stopped and the appropriate action was taken,
// or we got back a simplified return value to continue.
- Optional<Value *> SimplifiedRetValue =
+ std::optional<Value *> SimplifiedRetValue =
stopOnUndefOrAssumed(A, RI.getReturnValue(), &I);
if (!SimplifiedRetValue || !*SimplifiedRetValue)
return true;
@@ -2849,10 +2850,10 @@ struct AAUndefinedBehaviorImpl : public AAUndefinedBehavior {
// action was taken and the caller should stop.
// Otherwise, we return the simplified value that the caller should
// use for specific processing.
- Optional<Value *> stopOnUndefOrAssumed(Attributor &A, Value *V,
- Instruction *I) {
+ std::optional<Value *> stopOnUndefOrAssumed(Attributor &A, Value *V,
+ Instruction *I) {
bool UsedAssumedInformation = false;
- Optional<Value *> SimplifiedV =
+ std::optional<Value *> SimplifiedV =
A.getAssumedSimplified(IRPosition::value(*V), *this,
UsedAssumedInformation, AA::Interprocedural);
if (!UsedAssumedInformation) {
@@ -3500,7 +3501,7 @@ struct AAIsDeadValueImpl : public AAIsDead {
if (!A.isRunOn(*I->getFunction()))
return false;
bool UsedAssumedInformation = false;
- Optional<Constant *> C =
+ std::optional<Constant *> C =
A.getAssumedConstant(V, *this, UsedAssumedInformation);
if (!C || *C)
return true;
@@ -4017,7 +4018,7 @@ identifyAliveSuccessors(Attributor &A, const BranchInst &BI,
if (BI.getNumSuccessors() == 1) {
AliveSuccessors.push_back(&BI.getSuccessor(0)->front());
} else {
- Optional<Constant *> C =
+ std::optional<Constant *> C =
A.getAssumedConstant(*BI.getCondition(), AA, UsedAssumedInformation);
if (!C || isa_and_nonnull<UndefValue>(*C)) {
// No value yet, assume both edges are dead.
@@ -4039,7 +4040,7 @@ identifyAliveSuccessors(Attributor &A, const SwitchInst &SI,
AbstractAttribute &AA,
SmallVectorImpl<const Instruction *> &AliveSuccessors) {
bool UsedAssumedInformation = false;
- Optional<Constant *> C =
+ std::optional<Constant *> C =
A.getAssumedConstant(*SI.getCondition(), AA, UsedAssumedInformation);
if (!C || isa_and_nonnull<UndefValue>(C.value())) {
// No value yet, assume all edges are dead.
@@ -5365,11 +5366,11 @@ struct AANoCaptureCallSiteReturned final : AANoCaptureImpl {
/// ------------------ Value Simplify Attribute ----------------------------
-bool ValueSimplifyStateType::unionAssumed(Optional<Value *> Other) {
+bool ValueSimplifyStateType::unionAssumed(std::optional<Value *> Other) {
// FIXME: Add a typecast support.
SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
SimplifiedAssociatedValue, Other, Ty);
- if (SimplifiedAssociatedValue == Optional<Value *>(nullptr))
+ if (SimplifiedAssociatedValue == std::optional<Value *>(nullptr))
return false;
LLVM_DEBUG({
@@ -5410,7 +5411,8 @@ struct AAValueSimplifyImpl : AAValueSimplify {
void trackStatistics() const override {}
/// See AAValueSimplify::getAssumedSimplifiedValue()
- Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const override {
+ std::optional<Value *>
+ getAssumedSimplifiedValue(Attributor &A) const override {
return SimplifiedAssociatedValue;
}
@@ -5474,7 +5476,7 @@ struct AAValueSimplifyImpl : AAValueSimplify {
if (const auto &NewV = VMap.lookup(&V))
return NewV;
bool UsedAssumedInformation = false;
- Optional<Value *> SimpleV = A.getAssumedSimplified(
+ std::optional<Value *> SimpleV = A.getAssumedSimplified(
V, QueryingAA, UsedAssumedInformation, AA::Interprocedural);
if (!SimpleV.has_value())
return PoisonValue::get(&Ty);
@@ -5515,7 +5517,7 @@ struct AAValueSimplifyImpl : AAValueSimplify {
bool checkAndUpdate(Attributor &A, const AbstractAttribute &QueryingAA,
const IRPosition &IRP, bool Simplify = true) {
bool UsedAssumedInformation = false;
- Optional<Value *> QueryingValueSimplified = &IRP.getAssociatedValue();
+ std::optional<Value *> QueryingValueSimplified = &IRP.getAssociatedValue();
if (Simplify)
QueryingValueSimplified = A.getAssumedSimplified(
IRP, QueryingAA, UsedAssumedInformation, AA::Interprocedural);
@@ -5531,7 +5533,7 @@ struct AAValueSimplifyImpl : AAValueSimplify {
const auto &AA =
A.getAAFor<AAType>(*this, getIRPosition(), DepClassTy::NONE);
- Optional<Constant *> COpt = AA.getAssumedConstant(A);
+ std::optional<Constant *> COpt = AA.getAssumedConstant(A);
if (!COpt) {
SimplifiedAssociatedValue = std::nullopt;
@@ -5623,7 +5625,7 @@ struct AAValueSimplifyArgument final : AAValueSimplifyImpl {
// in other functions, e.g., we don't want to say a an argument in a
// static function is actually an argument in a
diff erent function.
bool UsedAssumedInformation = false;
- Optional<Constant *> SimpleArgOp =
+ std::optional<Constant *> SimpleArgOp =
A.getAssumedConstant(ACSArgPos, *this, UsedAssumedInformation);
if (!SimpleArgOp)
return true;
@@ -5665,7 +5667,8 @@ struct AAValueSimplifyReturned : AAValueSimplifyImpl {
: AAValueSimplifyImpl(IRP, A) {}
/// See AAValueSimplify::getAssumedSimplifiedValue()
- Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const override {
+ std::optional<Value *>
+ getAssumedSimplifiedValue(Attributor &A) const override {
if (!isValidState())
return nullptr;
return SimplifiedAssociatedValue;
@@ -5799,12 +5802,13 @@ struct AAValueSimplifyCallSiteReturned : AAValueSimplifyImpl {
auto PredForReturned =
[&](Value &RetVal, const SmallSetVector<ReturnInst *, 4> &RetInsts) {
bool UsedAssumedInformation = false;
- Optional<Value *> CSRetVal = A.translateArgumentToCallSiteContent(
- &RetVal, *cast<CallBase>(getCtxI()), *this,
- UsedAssumedInformation);
+ std::optional<Value *> CSRetVal =
+ A.translateArgumentToCallSiteContent(
+ &RetVal, *cast<CallBase>(getCtxI()), *this,
+ UsedAssumedInformation);
SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
SimplifiedAssociatedValue, CSRetVal, getAssociatedType());
- return SimplifiedAssociatedValue != Optional<Value *>(nullptr);
+ return SimplifiedAssociatedValue != std::optional<Value *>(nullptr);
};
if (!RetAA.checkForAllReturnedValuesAndReturnInsts(PredForReturned))
if (!askSimplifiedValueForOtherAAs(A))
@@ -5942,7 +5946,7 @@ struct AAHeapToStackFunction final : public AAHeapToStack {
Attributor::SimplifictionCallbackTy SCB =
[](const IRPosition &, const AbstractAttribute *,
- bool &) -> Optional<Value *> { return nullptr; };
+ bool &) -> std::optional<Value *> { return nullptr; };
for (const auto &It : AllocationInfos)
A.registerSimplificationCallback(IRPosition::callsite_returned(*It.first),
SCB);
@@ -6053,7 +6057,7 @@ struct AAHeapToStackFunction final : public AAHeapToStack {
if (MaybeAlign RetAlign = AI.CB->getRetAlign())
Alignment = std::max(Alignment, *RetAlign);
if (Value *Align = getAllocAlignment(AI.CB, TLI)) {
- Optional<APInt> AlignmentAPI = getAPInt(A, *this, *Align);
+ std::optional<APInt> AlignmentAPI = getAPInt(A, *this, *Align);
assert(AlignmentAPI && AlignmentAPI.value().getZExtValue() > 0 &&
"Expected an alignment during manifest!");
Alignment = std::max(
@@ -6099,10 +6103,10 @@ struct AAHeapToStackFunction final : public AAHeapToStack {
return HasChanged;
}
- Optional<APInt> getAPInt(Attributor &A, const AbstractAttribute &AA,
- Value &V) {
+ std::optional<APInt> getAPInt(Attributor &A, const AbstractAttribute &AA,
+ Value &V) {
bool UsedAssumedInformation = false;
- Optional<Constant *> SimpleV =
+ std::optional<Constant *> SimpleV =
A.getAssumedConstant(V, AA, UsedAssumedInformation);
if (!SimpleV)
return APInt(64, 0);
@@ -6115,7 +6119,7 @@ struct AAHeapToStackFunction final : public AAHeapToStack {
AllocationInfo &AI) {
auto Mapper = [&](const Value *V) -> const Value * {
bool UsedAssumedInformation = false;
- if (Optional<Constant *> SimpleV =
+ if (std::optional<Constant *> SimpleV =
A.getAssumedConstant(*V, AA, UsedAssumedInformation))
if (*SimpleV)
return *SimpleV;
@@ -6367,7 +6371,7 @@ ChangeStatus AAHeapToStackFunction::updateImpl(Attributor &A) {
continue;
if (Value *Align = getAllocAlignment(AI.CB, TLI)) {
- Optional<APInt> APAlign = getAPInt(A, *this, *Align);
+ std::optional<APInt> APAlign = getAPInt(A, *this, *Align);
if (!APAlign) {
// Can't generate an alloca which respects the required alignment
// on the allocation.
@@ -6449,11 +6453,12 @@ struct AAPrivatizablePtrImpl : public AAPrivatizablePtr {
/// Identify the type we can chose for a private copy of the underlying
/// argument. None means it is not clear yet, nullptr means there is none.
- virtual Optional<Type *> identifyPrivatizableType(Attributor &A) = 0;
+ virtual std::optional<Type *> identifyPrivatizableType(Attributor &A) = 0;
/// Return a privatizable type that encloses both T0 and T1.
/// TODO: This is merely a stub for now as we should manage a mapping as well.
- Optional<Type *> combineTypes(Optional<Type *> T0, Optional<Type *> T1) {
+ std::optional<Type *> combineTypes(std::optional<Type *> T0,
+ std::optional<Type *> T1) {
if (!T0)
return T1;
if (!T1)
@@ -6463,7 +6468,7 @@ struct AAPrivatizablePtrImpl : public AAPrivatizablePtr {
return nullptr;
}
- Optional<Type *> getPrivatizableType() const override {
+ std::optional<Type *> getPrivatizableType() const override {
return PrivatizableType;
}
@@ -6472,7 +6477,7 @@ struct AAPrivatizablePtrImpl : public AAPrivatizablePtr {
}
protected:
- Optional<Type *> PrivatizableType;
+ std::optional<Type *> PrivatizableType;
};
// TODO: Do this for call site arguments (probably also other values) as well.
@@ -6482,7 +6487,7 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl {
: AAPrivatizablePtrImpl(IRP, A) {}
/// See AAPrivatizablePtrImpl::identifyPrivatizableType(...)
- Optional<Type *> identifyPrivatizableType(Attributor &A) override {
+ std::optional<Type *> identifyPrivatizableType(Attributor &A) override {
// If this is a byval argument and we know all the call sites (so we can
// rewrite them), there is no need to check them explicitly.
bool UsedAssumedInformation = false;
@@ -6493,7 +6498,7 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl {
true, UsedAssumedInformation))
return Attrs[0].getValueAsType();
- Optional<Type *> Ty;
+ std::optional<Type *> Ty;
unsigned ArgNo = getIRPosition().getCallSiteArgNo();
// Make sure the associated call site argument has the same type at all call
@@ -6512,7 +6517,7 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl {
// Check that all call sites agree on a type.
auto &PrivCSArgAA =
A.getAAFor<AAPrivatizablePtr>(*this, ACSArgPos, DepClassTy::REQUIRED);
- Optional<Type *> CSTy = PrivCSArgAA.getPrivatizableType();
+ std::optional<Type *> CSTy = PrivCSArgAA.getPrivatizableType();
LLVM_DEBUG({
dbgs() << "[AAPrivatizablePtr] ACSPos: " << ACSArgPos << ", CSTy: ";
@@ -6925,7 +6930,7 @@ struct AAPrivatizablePtrFloating : public AAPrivatizablePtrImpl {
}
/// See AAPrivatizablePtrImpl::identifyPrivatizableType(...)
- Optional<Type *> identifyPrivatizableType(Attributor &A) override {
+ std::optional<Type *> identifyPrivatizableType(Attributor &A) override {
Value *Obj = getUnderlyingObject(&getAssociatedValue());
if (!Obj) {
LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] No underlying object found!\n");
@@ -9086,8 +9091,8 @@ struct AAPotentialConstantValuesFloating : AAPotentialConstantValuesImpl {
Value *RHS = SI->getFalseValue();
bool UsedAssumedInformation = false;
- Optional<Constant *> C = A.getAssumedConstant(*SI->getCondition(), *this,
- UsedAssumedInformation);
+ std::optional<Constant *> C = A.getAssumedConstant(
+ *SI->getCondition(), *this, UsedAssumedInformation);
// Check if we only need one operand.
bool OnlyLeft = false, OnlyRight = false;
@@ -9618,7 +9623,7 @@ struct AAFunctionReachabilityFunction : public AAFunctionReachability {
}
/// If there is no information about the function std::nullopt is returned.
- Optional<bool> isCachedReachable(const Function &Fn) {
+ std::optional<bool> isCachedReachable(const Function &Fn) {
// Assume that we can reach the function.
// TODO: Be more specific with the unknown callee.
if (CanReachUnknownCallee)
@@ -9673,7 +9678,7 @@ struct AAFunctionReachabilityFunction : public AAFunctionReachability {
bool isReachable(Attributor &A, AAFunctionReachability &AA,
ArrayRef<const AACallEdges *> AAEdgesList,
const Function &Fn) {
- Optional<bool> Cached = isCachedReachable(Fn);
+ std::optional<bool> Cached = isCachedReachable(Fn);
if (Cached)
return Cached.value();
@@ -9896,7 +9901,7 @@ struct AAFunctionReachabilityFunction : public AAFunctionReachability {
} // namespace
template <typename AAType>
-static Optional<Constant *>
+static std::optional<Constant *>
askForAssumedConstant(Attributor &A, const AbstractAttribute &QueryingAA,
const IRPosition &IRP, Type &Ty) {
if (!Ty.isIntegerTy())
@@ -9905,7 +9910,7 @@ askForAssumedConstant(Attributor &A, const AbstractAttribute &QueryingAA,
// This will also pass the call base context.
const auto &AA = A.getAAFor<AAType>(QueryingAA, IRP, DepClassTy::NONE);
- Optional<Constant *> COpt = AA.getAssumedConstant(A);
+ std::optional<Constant *> COpt = AA.getAssumedConstant(A);
if (!COpt.has_value()) {
A.recordDependence(AA, QueryingAA, DepClassTy::OPTIONAL);
@@ -9922,7 +9927,7 @@ Value *AAPotentialValues::getSingleValue(
Attributor &A, const AbstractAttribute &AA, const IRPosition &IRP,
SmallVectorImpl<AA::ValueAndContext> &Values) {
Type &Ty = *IRP.getAssociatedType();
- Optional<Value *> V;
+ std::optional<Value *> V;
for (auto &It : Values) {
V = AA::combineOptionalValuesInAAValueLatice(V, It.getValue(), &Ty);
if (V.has_value() && !V.value())
@@ -9965,12 +9970,12 @@ struct AAPotentialValuesImpl : AAPotentialValues {
}
template <typename AAType>
- static Optional<Value *> askOtherAA(Attributor &A,
- const AbstractAttribute &AA,
- const IRPosition &IRP, Type &Ty) {
+ static std::optional<Value *> askOtherAA(Attributor &A,
+ const AbstractAttribute &AA,
+ const IRPosition &IRP, Type &Ty) {
if (isa<Constant>(IRP.getAssociatedValue()))
return &IRP.getAssociatedValue();
- Optional<Constant *> C = askForAssumedConstant<AAType>(A, AA, IRP, Ty);
+ std::optional<Constant *> C = askForAssumedConstant<AAType>(A, AA, IRP, Ty);
if (!C)
return std::nullopt;
if (C.value())
@@ -9996,7 +10001,7 @@ struct AAPotentialValuesImpl : AAPotentialValues {
Value *VPtr = &V;
if (ValIRP.getAssociatedType()->isIntegerTy()) {
Type &Ty = *getAssociatedType();
- Optional<Value *> SimpleV =
+ std::optional<Value *> SimpleV =
askOtherAA<AAValueConstantRange>(A, *this, ValIRP, Ty);
if (SimpleV.has_value() && !SimpleV.value()) {
auto &PotentialConstantsAA = A.getAAFor<AAPotentialConstantValues>(
@@ -10221,7 +10226,7 @@ struct AAPotentialValuesFloating : AAPotentialValuesImpl {
const Instruction *CtxI = II.I.getCtxI();
bool UsedAssumedInformation = false;
- Optional<Constant *> C =
+ std::optional<Constant *> C =
A.getAssumedConstant(*SI.getCondition(), *this, UsedAssumedInformation);
bool NoValueYet = !C.has_value();
if (NoValueYet || isa_and_nonnull<UndefValue>(*C))
@@ -10646,7 +10651,7 @@ struct AAPotentialValuesCallSiteReturned : AAPotentialValuesImpl {
bool AnyNonLocal = false;
for (auto &It : Values) {
Value *V = It.getValue();
- Optional<Value *> CallerV = A.translateArgumentToCallSiteContent(
+ std::optional<Value *> CallerV = A.translateArgumentToCallSiteContent(
V, *CB, *this, UsedAssumedInformation);
if (!CallerV.has_value()) {
// Nothing to do as long as no value was determined.
diff --git a/llvm/lib/Transforms/IPO/IROutliner.cpp b/llvm/lib/Transforms/IPO/IROutliner.cpp
index afa46f253bdb..16d0dc3ca2eb 100644
--- a/llvm/lib/Transforms/IPO/IROutliner.cpp
+++ b/llvm/lib/Transforms/IPO/IROutliner.cpp
@@ -463,7 +463,7 @@ void OutlinableRegion::reattachCandidate() {
/// \returns true if the Value matches the Constant mapped to by V and false if
/// it \p V is a Constant but does not match.
/// \returns std::nullopt if \p V is not a Constant.
-static Optional<bool>
+static std::optional<bool>
constantMatches(Value *V, unsigned GVN,
DenseMap<unsigned, Constant *> &GVNToConstant) {
// See if we have a constants
@@ -577,7 +577,8 @@ collectRegionsConstants(OutlinableRegion &Region,
// associated Constant value match the previous instances of the same
// global value number. If the global value does not map to a Constant,
// it is considered to not be the same value.
- Optional<bool> ConstantMatches = constantMatches(V, GVN, GVNToConstant);
+ std::optional<bool> ConstantMatches =
+ constantMatches(V, GVN, GVNToConstant);
if (ConstantMatches) {
if (ConstantMatches.value())
continue;
@@ -1968,7 +1969,7 @@ void replaceConstants(OutlinableRegion &Region) {
/// \param OutputBBs [in] the blocks we are looking for a duplicate of.
/// \param OutputStoreBBs [in] The existing output blocks.
/// \returns an optional value with the number output block if there is a match.
-Optional<unsigned> findDuplicateOutputBlock(
+std::optional<unsigned> findDuplicateOutputBlock(
DenseMap<Value *, BasicBlock *> &OutputBBs,
std::vector<DenseMap<Value *, BasicBlock *>> &OutputStoreBBs) {
@@ -2083,7 +2084,7 @@ static void alignOutputBlockWithAggFunc(
return;
// Determine is there is a duplicate set of blocks.
- Optional<unsigned> MatchingBB =
+ std::optional<unsigned> MatchingBB =
findDuplicateOutputBlock(OutputBBs, OutputStoreBBs);
// If there is, we remove the new output blocks. If it does not,
diff --git a/llvm/lib/Transforms/IPO/OpenMPOpt.cpp b/llvm/lib/Transforms/IPO/OpenMPOpt.cpp
index 9a7738f99e54..b6905ba512c5 100644
--- a/llvm/lib/Transforms/IPO/OpenMPOpt.cpp
+++ b/llvm/lib/Transforms/IPO/OpenMPOpt.cpp
@@ -2007,7 +2007,7 @@ struct OpenMPOpt {
bool isKernel(Function &F) { return OMPInfoCache.Kernels.count(&F); }
/// Cache to remember the unique kernel for a function.
- DenseMap<Function *, Optional<Kernel>> UniqueKernelMap;
+ DenseMap<Function *, std::optional<Kernel>> UniqueKernelMap;
/// Find the unique kernel that will execute \p F, if any.
Kernel getUniqueKernelFor(Function &F);
@@ -2153,7 +2153,7 @@ Kernel OpenMPOpt::getUniqueKernelFor(Function &F) {
// Use a scope to keep the lifetime of the CachedKernel short.
{
- Optional<Kernel> &CachedKernel = UniqueKernelMap[&F];
+ std::optional<Kernel> &CachedKernel = UniqueKernelMap[&F];
if (CachedKernel)
return *CachedKernel;
@@ -2339,16 +2339,16 @@ struct AAICVTracker : public StateWrapper<BooleanState, AbstractAttribute> {
static AAICVTracker &createForPosition(const IRPosition &IRP, Attributor &A);
/// Return the value with which \p I can be replaced for specific \p ICV.
- virtual Optional<Value *> getReplacementValue(InternalControlVar ICV,
- const Instruction *I,
- Attributor &A) const {
+ virtual std::optional<Value *> getReplacementValue(InternalControlVar ICV,
+ const Instruction *I,
+ Attributor &A) const {
return std::nullopt;
}
/// Return an assumed unique ICV value if a single candidate is found. If
/// there cannot be one, return a nullptr. If it is not clear yet, return the
/// Optional::NoneType.
- virtual Optional<Value *>
+ virtual std::optional<Value *>
getUniqueReplacementValue(InternalControlVar ICV) const = 0;
// Currently only nthreads is being tracked.
@@ -2414,7 +2414,7 @@ struct AAICVTrackerFunction : public AAICVTracker {
};
auto CallCheck = [&](Instruction &I) {
- Optional<Value *> ReplVal = getValueForCall(A, I, ICV);
+ std::optional<Value *> ReplVal = getValueForCall(A, I, ICV);
if (ReplVal && ValuesMap.insert(std::make_pair(&I, *ReplVal)).second)
HasChanged = ChangeStatus::CHANGED;
@@ -2441,8 +2441,8 @@ struct AAICVTrackerFunction : public AAICVTracker {
/// Helper to check if \p I is a call and get the value for it if it is
/// unique.
- Optional<Value *> getValueForCall(Attributor &A, const Instruction &I,
- InternalControlVar &ICV) const {
+ std::optional<Value *> getValueForCall(Attributor &A, const Instruction &I,
+ InternalControlVar &ICV) const {
const auto *CB = dyn_cast<CallBase>(&I);
if (!CB || CB->hasFnAttr("no_openmp") ||
@@ -2474,7 +2474,7 @@ struct AAICVTrackerFunction : public AAICVTracker {
*this, IRPosition::callsite_returned(*CB), DepClassTy::REQUIRED);
if (ICVTrackingAA.isAssumedTracked()) {
- Optional<Value *> URV = ICVTrackingAA.getUniqueReplacementValue(ICV);
+ std::optional<Value *> URV = ICVTrackingAA.getUniqueReplacementValue(ICV);
if (!URV || (*URV && AA::isValidAtPosition(AA::ValueAndContext(**URV, I),
OMPInfoCache)))
return URV;
@@ -2485,15 +2485,15 @@ struct AAICVTrackerFunction : public AAICVTracker {
}
// We don't check unique value for a function, so return std::nullopt.
- Optional<Value *>
+ std::optional<Value *>
getUniqueReplacementValue(InternalControlVar ICV) const override {
return std::nullopt;
}
/// Return the value with which \p I can be replaced for specific \p ICV.
- Optional<Value *> getReplacementValue(InternalControlVar ICV,
- const Instruction *I,
- Attributor &A) const override {
+ std::optional<Value *> getReplacementValue(InternalControlVar ICV,
+ const Instruction *I,
+ Attributor &A) const override {
const auto &ValuesMap = ICVReplacementValuesMap[ICV];
if (ValuesMap.count(I))
return ValuesMap.lookup(I);
@@ -2502,7 +2502,7 @@ struct AAICVTrackerFunction : public AAICVTracker {
SmallPtrSet<const Instruction *, 16> Visited;
Worklist.push_back(I);
- Optional<Value *> ReplVal;
+ std::optional<Value *> ReplVal;
while (!Worklist.empty()) {
const Instruction *CurrInst = Worklist.pop_back_val();
@@ -2515,7 +2515,7 @@ struct AAICVTrackerFunction : public AAICVTracker {
// ICV.
while ((CurrInst = CurrInst->getPrevNode())) {
if (ValuesMap.count(CurrInst)) {
- Optional<Value *> NewReplVal = ValuesMap.lookup(CurrInst);
+ std::optional<Value *> NewReplVal = ValuesMap.lookup(CurrInst);
// Unknown value, track new.
if (!ReplVal) {
ReplVal = NewReplVal;
@@ -2530,7 +2530,7 @@ struct AAICVTrackerFunction : public AAICVTracker {
break;
}
- Optional<Value *> NewReplVal = getValueForCall(A, *CurrInst, ICV);
+ std::optional<Value *> NewReplVal = getValueForCall(A, *CurrInst, ICV);
if (!NewReplVal)
continue;
@@ -2578,12 +2578,12 @@ struct AAICVTrackerFunctionReturned : AAICVTracker {
}
// Map of ICV to their values at specific program point.
- EnumeratedArray<Optional<Value *>, InternalControlVar,
+ EnumeratedArray<std::optional<Value *>, InternalControlVar,
InternalControlVar::ICV___last>
ICVReplacementValuesMap;
/// Return the value with which \p I can be replaced for specific \p ICV.
- Optional<Value *>
+ std::optional<Value *>
getUniqueReplacementValue(InternalControlVar ICV) const override {
return ICVReplacementValuesMap[ICV];
}
@@ -2597,11 +2597,11 @@ struct AAICVTrackerFunctionReturned : AAICVTracker {
return indicatePessimisticFixpoint();
for (InternalControlVar ICV : TrackableICVs) {
- Optional<Value *> &ReplVal = ICVReplacementValuesMap[ICV];
- Optional<Value *> UniqueICVValue;
+ std::optional<Value *> &ReplVal = ICVReplacementValuesMap[ICV];
+ std::optional<Value *> UniqueICVValue;
auto CheckReturnInst = [&](Instruction &I) {
- Optional<Value *> NewReplVal =
+ std::optional<Value *> NewReplVal =
ICVTrackingAA.getReplacementValue(ICV, &I, A);
// If we found a second ICV value there is no unique returned value.
@@ -2672,7 +2672,7 @@ struct AAICVTrackerCallSite : AAICVTracker {
void trackStatistics() const override {}
InternalControlVar AssociatedICV;
- Optional<Value *> ReplVal;
+ std::optional<Value *> ReplVal;
ChangeStatus updateImpl(Attributor &A) override {
const auto &ICVTrackingAA = A.getAAFor<AAICVTracker>(
@@ -2682,7 +2682,7 @@ struct AAICVTrackerCallSite : AAICVTracker {
if (!ICVTrackingAA.isAssumedTracked())
return indicatePessimisticFixpoint();
- Optional<Value *> NewReplVal =
+ std::optional<Value *> NewReplVal =
ICVTrackingAA.getReplacementValue(AssociatedICV, getCtxI(), A);
if (ReplVal == NewReplVal)
@@ -2694,7 +2694,7 @@ struct AAICVTrackerCallSite : AAICVTracker {
// Return the value with which associated value can be replaced for specific
// \p ICV.
- Optional<Value *>
+ std::optional<Value *>
getUniqueReplacementValue(InternalControlVar ICV) const override {
return ReplVal;
}
@@ -2718,13 +2718,13 @@ struct AAICVTrackerCallSiteReturned : AAICVTracker {
}
// Map of ICV to their values at specific program point.
- EnumeratedArray<Optional<Value *>, InternalControlVar,
+ EnumeratedArray<std::optional<Value *>, InternalControlVar,
InternalControlVar::ICV___last>
ICVReplacementValuesMap;
/// Return the value with which associated value can be replaced for specific
/// \p ICV.
- Optional<Value *>
+ std::optional<Value *>
getUniqueReplacementValue(InternalControlVar ICV) const override {
return ICVReplacementValuesMap[ICV];
}
@@ -2740,8 +2740,8 @@ struct AAICVTrackerCallSiteReturned : AAICVTracker {
return indicatePessimisticFixpoint();
for (InternalControlVar ICV : TrackableICVs) {
- Optional<Value *> &ReplVal = ICVReplacementValuesMap[ICV];
- Optional<Value *> NewReplVal =
+ std::optional<Value *> &ReplVal = ICVReplacementValuesMap[ICV];
+ std::optional<Value *> NewReplVal =
ICVTrackingAA.getUniqueReplacementValue(ICV);
if (ReplVal == NewReplVal)
@@ -2970,7 +2970,7 @@ struct AAHeapToSharedFunction : public AAHeapToShared {
Attributor::SimplifictionCallbackTy SCB =
[](const IRPosition &, const AbstractAttribute *,
- bool &) -> Optional<Value *> { return nullptr; };
+ bool &) -> std::optional<Value *> { return nullptr; };
for (User *U : RFI.Declaration->users())
if (CallBase *CB = dyn_cast<CallBase>(U)) {
MallocCalls.insert(CB);
@@ -3214,7 +3214,7 @@ struct AAKernelInfoFunction : AAKernelInfo {
Attributor::SimplifictionCallbackTy StateMachineSimplifyCB =
[&](const IRPosition &IRP, const AbstractAttribute *AA,
- bool &UsedAssumedInformation) -> Optional<Value *> {
+ bool &UsedAssumedInformation) -> std::optional<Value *> {
// IRP represents the "use generic state machine" argument of an
// __kmpc_target_init call. We will answer this one with the internal
// state. As long as we are not in an invalid state, we will create a
@@ -3235,7 +3235,7 @@ struct AAKernelInfoFunction : AAKernelInfo {
Attributor::SimplifictionCallbackTy ModeSimplifyCB =
[&](const IRPosition &IRP, const AbstractAttribute *AA,
- bool &UsedAssumedInformation) -> Optional<Value *> {
+ bool &UsedAssumedInformation) -> std::optional<Value *> {
// IRP represents the "SPMDCompatibilityTracker" argument of an
// __kmpc_target_init or
// __kmpc_target_deinit call. We will answer this one with the internal
@@ -3258,7 +3258,7 @@ struct AAKernelInfoFunction : AAKernelInfo {
Attributor::SimplifictionCallbackTy IsGenericModeSimplifyCB =
[&](const IRPosition &IRP, const AbstractAttribute *AA,
- bool &UsedAssumedInformation) -> Optional<Value *> {
+ bool &UsedAssumedInformation) -> std::optional<Value *> {
// IRP represents the "RequiresFullRuntime" argument of an
// __kmpc_target_init or __kmpc_target_deinit call. We will answer this
// one with the internal state of the SPMDCompatibilityTracker, so if
@@ -4510,7 +4510,7 @@ struct AAFoldRuntimeCallCallSiteReturned : AAFoldRuntimeCall {
A.registerSimplificationCallback(
IRPosition::callsite_returned(CB),
[&](const IRPosition &IRP, const AbstractAttribute *AA,
- bool &UsedAssumedInformation) -> Optional<Value *> {
+ bool &UsedAssumedInformation) -> std::optional<Value *> {
assert((isValidState() ||
(SimplifiedValue && SimplifiedValue.value() == nullptr)) &&
"Unexpected invalid state!");
@@ -4587,7 +4587,7 @@ struct AAFoldRuntimeCallCallSiteReturned : AAFoldRuntimeCall {
private:
/// Fold __kmpc_is_spmd_exec_mode into a constant if possible.
ChangeStatus foldIsSPMDExecMode(Attributor &A) {
- Optional<Value *> SimplifiedValueBefore = SimplifiedValue;
+ std::optional<Value *> SimplifiedValueBefore = SimplifiedValue;
unsigned AssumedSPMDCount = 0, KnownSPMDCount = 0;
unsigned AssumedNonSPMDCount = 0, KnownNonSPMDCount = 0;
@@ -4649,7 +4649,7 @@ struct AAFoldRuntimeCallCallSiteReturned : AAFoldRuntimeCall {
/// Fold __kmpc_is_generic_main_thread_id into a constant if possible.
ChangeStatus foldIsGenericMainThread(Attributor &A) {
- Optional<Value *> SimplifiedValueBefore = SimplifiedValue;
+ std::optional<Value *> SimplifiedValueBefore = SimplifiedValue;
CallBase &CB = cast<CallBase>(getAssociatedValue());
Function *F = CB.getFunction();
@@ -4671,7 +4671,7 @@ struct AAFoldRuntimeCallCallSiteReturned : AAFoldRuntimeCall {
/// Fold __kmpc_parallel_level into a constant if possible.
ChangeStatus foldParallelLevel(Attributor &A) {
- Optional<Value *> SimplifiedValueBefore = SimplifiedValue;
+ std::optional<Value *> SimplifiedValueBefore = SimplifiedValue;
auto &CallerKernelInfoAA = A.getAAFor<AAKernelInfo>(
*this, IRPosition::function(*getAnchorScope()), DepClassTy::REQUIRED);
@@ -4733,7 +4733,7 @@ struct AAFoldRuntimeCallCallSiteReturned : AAFoldRuntimeCall {
ChangeStatus foldKernelFnAttribute(Attributor &A, llvm::StringRef Attr) {
// Specialize only if all the calls agree with the attribute constant value
int32_t CurrentAttrValue = -1;
- Optional<Value *> SimplifiedValueBefore = SimplifiedValue;
+ std::optional<Value *> SimplifiedValueBefore = SimplifiedValue;
auto &CallerKernelInfoAA = A.getAAFor<AAKernelInfo>(
*this, IRPosition::function(*getAnchorScope()), DepClassTy::REQUIRED);
@@ -4766,7 +4766,7 @@ struct AAFoldRuntimeCallCallSiteReturned : AAFoldRuntimeCall {
/// An optional value the associated value is assumed to fold to. That is, we
/// assume the associated value (which is a call) can be replaced by this
/// simplified value.
- Optional<Value *> SimplifiedValue;
+ std::optional<Value *> SimplifiedValue;
/// The runtime function kind of the callee of the associated call site.
RuntimeFunction RFKind;
diff --git a/llvm/lib/Transforms/IPO/SampleContextTracker.cpp b/llvm/lib/Transforms/IPO/SampleContextTracker.cpp
index 4cd360ff65a3..157114224c99 100644
--- a/llvm/lib/Transforms/IPO/SampleContextTracker.cpp
+++ b/llvm/lib/Transforms/IPO/SampleContextTracker.cpp
@@ -124,7 +124,9 @@ void ContextTrieNode::setFunctionSamples(FunctionSamples *FSamples) {
FuncSamples = FSamples;
}
-Optional<uint32_t> ContextTrieNode::getFunctionSize() const { return FuncSize; }
+std::optional<uint32_t> ContextTrieNode::getFunctionSize() const {
+ return FuncSize;
+}
void ContextTrieNode::addFunctionSize(uint32_t FSize) {
if (!FuncSize)
diff --git a/llvm/lib/Transforms/IPO/SampleProfile.cpp b/llvm/lib/Transforms/IPO/SampleProfile.cpp
index f3e8cda6642c..df5f91bc4499 100644
--- a/llvm/lib/Transforms/IPO/SampleProfile.cpp
+++ b/llvm/lib/Transforms/IPO/SampleProfile.cpp
@@ -494,7 +494,7 @@ class SampleProfileLoader final
bool inlineHotFunctions(Function &F,
DenseSet<GlobalValue::GUID> &InlinedGUIDs);
- Optional<InlineCost> getExternalInlineAdvisorCost(CallBase &CB);
+ std::optional<InlineCost> getExternalInlineAdvisorCost(CallBase &CB);
bool getExternalInlineAdvisorShouldInline(CallBase &CB);
InlineCost shouldInlineCandidate(InlineCandidate &Candidate);
bool getInlineCandidate(InlineCandidate *NewCandidate, CallBase *CB);
@@ -1320,7 +1320,7 @@ bool SampleProfileLoader::getInlineCandidate(InlineCandidate *NewCandidate,
return true;
}
-Optional<InlineCost>
+std::optional<InlineCost>
SampleProfileLoader::getExternalInlineAdvisorCost(CallBase &CB) {
std::unique_ptr<InlineAdvice> Advice = nullptr;
if (ExternalInlineAdvisor) {
@@ -1339,13 +1339,13 @@ SampleProfileLoader::getExternalInlineAdvisorCost(CallBase &CB) {
}
bool SampleProfileLoader::getExternalInlineAdvisorShouldInline(CallBase &CB) {
- Optional<InlineCost> Cost = getExternalInlineAdvisorCost(CB);
+ std::optional<InlineCost> Cost = getExternalInlineAdvisorCost(CB);
return Cost ? !!Cost.value() : false;
}
InlineCost
SampleProfileLoader::shouldInlineCandidate(InlineCandidate &Candidate) {
- if (Optional<InlineCost> ReplayCost =
+ if (std::optional<InlineCost> ReplayCost =
getExternalInlineAdvisorCost(*Candidate.CallInstr))
return ReplayCost.value();
// Adjust threshold based on call site hotness, only do this for callsite
More information about the llvm-commits
mailing list