[clang] 26424c9 - Attributes: convert Optional to std::optional
Krzysztof Parzyszek via cfe-commits
cfe-commits at lists.llvm.org
Fri Dec 2 06:16:18 PST 2022
Author: Krzysztof Parzyszek
Date: 2022-12-02T08:15:45-06:00
New Revision: 26424c96c03ee4098d7f129de9234a6f177e49ac
URL: https://github.com/llvm/llvm-project/commit/26424c96c03ee4098d7f129de9234a6f177e49ac
DIFF: https://github.com/llvm/llvm-project/commit/26424c96c03ee4098d7f129de9234a6f177e49ac.diff
LOG: Attributes: convert Optional to std::optional
Added:
Modified:
clang/lib/CodeGen/CGCall.cpp
llvm/include/llvm/Analysis/TargetTransformInfo.h
llvm/include/llvm/Analysis/TargetTransformInfoImpl.h
llvm/include/llvm/AsmParser/LLParser.h
llvm/include/llvm/CodeGen/BasicTTIImpl.h
llvm/include/llvm/IR/Attributes.h
llvm/lib/Analysis/InstructionSimplify.cpp
llvm/lib/Analysis/MemoryBuiltins.cpp
llvm/lib/Analysis/TargetTransformInfo.cpp
llvm/lib/Analysis/ValueTracking.cpp
llvm/lib/AsmParser/LLParser.cpp
llvm/lib/IR/AttributeImpl.h
llvm/lib/IR/Attributes.cpp
llvm/lib/IR/Verifier.cpp
llvm/lib/Target/AArch64/AArch64TargetMachine.cpp
llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h
llvm/lib/Target/AArch64/SVEIntrinsicOpts.cpp
llvm/lib/Target/RISCV/RISCVTargetTransformInfo.cpp
llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h
llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp
llvm/lib/Transforms/Utils/BuildLibCalls.cpp
llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
Removed:
################################################################################
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 0f410a8daae66..df500a5981f4c 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -40,6 +40,7 @@
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/Type.h"
#include "llvm/Transforms/Utils/Local.h"
+#include <optional>
using namespace clang;
using namespace CodeGen;
@@ -2205,7 +2206,7 @@ void CodeGenModule::ConstructAttributeList(StringRef Name,
HasOptnone = TargetDecl->hasAttr<OptimizeNoneAttr>();
if (auto *AllocSize = TargetDecl->getAttr<AllocSizeAttr>()) {
- Optional<unsigned> NumElemsParam;
+ std::optional<unsigned> NumElemsParam;
if (AllocSize->getNumElemsParam().isValid())
NumElemsParam = AllocSize->getNumElemsParam().getLLVMIndex();
FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam().getLLVMIndex(),
diff --git a/llvm/include/llvm/Analysis/TargetTransformInfo.h b/llvm/include/llvm/Analysis/TargetTransformInfo.h
index 592f1146b5cd5..f26fe677a8d1a 100644
--- a/llvm/include/llvm/Analysis/TargetTransformInfo.h
+++ b/llvm/include/llvm/Analysis/TargetTransformInfo.h
@@ -972,10 +972,10 @@ class TargetTransformInfo {
/// \return The maximum value of vscale if the target specifies an
/// architectural maximum vector length, and None otherwise.
- Optional<unsigned> getMaxVScale() const;
+ std::optional<unsigned> getMaxVScale() const;
/// \return the value of vscale to tune the cost model for.
- Optional<unsigned> getVScaleForTuning() const;
+ std::optional<unsigned> getVScaleForTuning() const;
/// \return True if the vectorization factor should be chosen to
/// make the vector of the smallest element type match the size of a
@@ -1715,8 +1715,8 @@ class TargetTransformInfo::Concept {
virtual const char *getRegisterClassName(unsigned ClassID) const = 0;
virtual TypeSize getRegisterBitWidth(RegisterKind K) const = 0;
virtual unsigned getMinVectorRegisterBitWidth() const = 0;
- virtual Optional<unsigned> getMaxVScale() const = 0;
- virtual Optional<unsigned> getVScaleForTuning() const = 0;
+ virtual std::optional<unsigned> getMaxVScale() const = 0;
+ virtual std::optional<unsigned> getVScaleForTuning() const = 0;
virtual bool
shouldMaximizeVectorBandwidth(TargetTransformInfo::RegisterKind K) const = 0;
virtual ElementCount getMinimumVF(unsigned ElemWidth,
@@ -2239,10 +2239,10 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
unsigned getMinVectorRegisterBitWidth() const override {
return Impl.getMinVectorRegisterBitWidth();
}
- Optional<unsigned> getMaxVScale() const override {
+ std::optional<unsigned> getMaxVScale() const override {
return Impl.getMaxVScale();
}
- Optional<unsigned> getVScaleForTuning() const override {
+ std::optional<unsigned> getVScaleForTuning() const override {
return Impl.getVScaleForTuning();
}
bool shouldMaximizeVectorBandwidth(
diff --git a/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h b/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h
index 05cab5b45e282..b21a001810938 100644
--- a/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h
+++ b/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h
@@ -22,6 +22,7 @@
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/PatternMatch.h"
+#include <optional>
#include <utility>
namespace llvm {
@@ -430,8 +431,8 @@ class TargetTransformInfoImplBase {
unsigned getMinVectorRegisterBitWidth() const { return 128; }
- Optional<unsigned> getMaxVScale() const { return None; }
- Optional<unsigned> getVScaleForTuning() const { return None; }
+ std::optional<unsigned> getMaxVScale() const { return std::nullopt; }
+ std::optional<unsigned> getVScaleForTuning() const { return std::nullopt; }
bool
shouldMaximizeVectorBandwidth(TargetTransformInfo::RegisterKind K) const {
diff --git a/llvm/include/llvm/AsmParser/LLParser.h b/llvm/include/llvm/AsmParser/LLParser.h
index d936c6f36b6f5..321b02c70cd39 100644
--- a/llvm/include/llvm/AsmParser/LLParser.h
+++ b/llvm/include/llvm/AsmParser/LLParser.h
@@ -21,6 +21,7 @@
#include "llvm/IR/Instructions.h"
#include "llvm/IR/ModuleSummaryIndex.h"
#include <map>
+#include <optional>
namespace llvm {
class Module;
@@ -301,7 +302,7 @@ namespace llvm {
bool parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
bool &AteExtraComma);
bool parseAllocSizeArguments(unsigned &BaseSizeArg,
- Optional<unsigned> &HowManyArg);
+ std::optional<unsigned> &HowManyArg);
bool parseVScaleRangeArguments(unsigned &MinValue, unsigned &MaxValue);
bool parseIndexList(SmallVectorImpl<unsigned> &Indices,
bool &AteExtraComma);
diff --git a/llvm/include/llvm/CodeGen/BasicTTIImpl.h b/llvm/include/llvm/CodeGen/BasicTTIImpl.h
index 3554c31a4f2f6..5786310aba00b 100644
--- a/llvm/include/llvm/CodeGen/BasicTTIImpl.h
+++ b/llvm/include/llvm/CodeGen/BasicTTIImpl.h
@@ -52,6 +52,7 @@
#include <cassert>
#include <cstdint>
#include <limits>
+#include <optional>
#include <utility>
namespace llvm {
@@ -698,8 +699,8 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
return TypeSize::getFixed(32);
}
- Optional<unsigned> getMaxVScale() const { return None; }
- Optional<unsigned> getVScaleForTuning() const { return None; }
+ std::optional<unsigned> getMaxVScale() const { return std::nullopt; }
+ std::optional<unsigned> getVScaleForTuning() const { return std::nullopt; }
/// Estimate the overhead of scalarizing an instruction. Insert and Extract
/// are set if the demanded result elements need to be inserted and/or
diff --git a/llvm/include/llvm/IR/Attributes.h b/llvm/include/llvm/IR/Attributes.h
index e2db9c6e80adc..505b42b948ff4 100644
--- a/llvm/include/llvm/IR/Attributes.h
+++ b/llvm/include/llvm/IR/Attributes.h
@@ -18,7 +18,6 @@
#include "llvm-c/Types.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/BitmaskEnum.h"
-#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Config/llvm-config.h"
@@ -28,6 +27,7 @@
#include <bitset>
#include <cassert>
#include <cstdint>
+#include <optional>
#include <set>
#include <string>
#include <utility>
@@ -135,9 +135,9 @@ class Attribute {
uint64_t Bytes);
static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context,
uint64_t Bytes);
- static Attribute getWithAllocSizeArgs(LLVMContext &Context,
- unsigned ElemSizeArg,
- const Optional<unsigned> &NumElemsArg);
+ static Attribute getWithAllocSizeArgs(
+ LLVMContext &Context, unsigned ElemSizeArg,
+ const std::optional<unsigned> &NumElemsArg);
static Attribute getWithVScaleRangeArgs(LLVMContext &Context,
unsigned MinValue, unsigned MaxValue);
static Attribute getWithByValType(LLVMContext &Context, Type *Ty);
@@ -230,14 +230,14 @@ class Attribute {
uint64_t getDereferenceableOrNullBytes() const;
/// Returns the argument numbers for the allocsize attribute.
- std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
+ std::pair<unsigned, std::optional<unsigned>> getAllocSizeArgs() const;
/// Returns the minimum value for the vscale_range attribute.
unsigned getVScaleRangeMin() const;
/// Returns the maximum value for the vscale_range attribute or None when
/// unknown.
- Optional<unsigned> getVScaleRangeMax() const;
+ std::optional<unsigned> getVScaleRangeMax() const;
// Returns the unwind table kind.
UWTableKind getUWTableKind() const;
@@ -375,9 +375,10 @@ class AttributeSet {
Type *getPreallocatedType() const;
Type *getInAllocaType() const;
Type *getElementType() const;
- Optional<std::pair<unsigned, Optional<unsigned>>> getAllocSizeArgs() const;
+ std::optional<std::pair<unsigned, std::optional<unsigned>>> getAllocSizeArgs()
+ const;
unsigned getVScaleRangeMin() const;
- Optional<unsigned> getVScaleRangeMax() const;
+ std::optional<unsigned> getVScaleRangeMax() const;
UWTableKind getUWTableKind() const;
AllocFnKind getAllocKind() const;
MemoryEffects getMemoryEffects() const;
@@ -730,7 +731,7 @@ class AttributeList {
/// Returns a new list because attribute lists are immutable.
[[nodiscard]] AttributeList
addAllocSizeParamAttr(LLVMContext &C, unsigned ArgNo, unsigned ElemSizeArg,
- const Optional<unsigned> &NumElemsArg);
+ const std::optional<unsigned> &NumElemsArg);
//===--------------------------------------------------------------------===//
// AttributeList Accessors
@@ -1106,7 +1107,7 @@ class AttrBuilder {
/// Return raw (possibly packed/encoded) value of integer attribute or None if
/// not set.
- Optional<uint64_t> getRawIntAttr(Attribute::AttrKind Kind) const;
+ std::optional<uint64_t> getRawIntAttr(Attribute::AttrKind Kind) const;
/// Retrieve the alignment attribute, if it exists.
MaybeAlign getAlignment() const {
@@ -1151,7 +1152,8 @@ class AttrBuilder {
Type *getInAllocaType() const { return getTypeAttr(Attribute::InAlloca); }
/// Retrieve the allocsize args, or None if the attribute does not exist.
- Optional<std::pair<unsigned, Optional<unsigned>>> getAllocSizeArgs() const;
+ std::optional<std::pair<unsigned, std::optional<unsigned>>> getAllocSizeArgs()
+ const;
/// Add integer attribute with raw value (packed/encoded if necessary).
AttrBuilder &addRawIntAttr(Attribute::AttrKind Kind, uint64_t Value);
@@ -1190,11 +1192,11 @@ class AttrBuilder {
/// This turns one (or two) ints into the form used internally in Attribute.
AttrBuilder &addAllocSizeAttr(unsigned ElemSizeArg,
- const Optional<unsigned> &NumElemsArg);
+ const std::optional<unsigned> &NumElemsArg);
/// This turns two ints into the form used internally in Attribute.
AttrBuilder &addVScaleRangeAttr(unsigned MinValue,
- Optional<unsigned> MaxValue);
+ std::optional<unsigned> MaxValue);
/// Add a type attribute with the given type.
AttrBuilder &addTypeAttr(Attribute::AttrKind Kind, Type *Ty);
diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp
index 77687abd87b9b..43d7368b39710 100644
--- a/llvm/lib/Analysis/InstructionSimplify.cpp
+++ b/llvm/lib/Analysis/InstructionSimplify.cpp
@@ -41,6 +41,7 @@
#include "llvm/IR/PatternMatch.h"
#include "llvm/Support/KnownBits.h"
#include <algorithm>
+#include <optional>
using namespace llvm;
using namespace llvm::PatternMatch;
@@ -6219,7 +6220,7 @@ static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) {
if (!Attr.isValid())
return nullptr;
unsigned VScaleMin = Attr.getVScaleRangeMin();
- Optional<unsigned> VScaleMax = Attr.getVScaleRangeMax();
+ std::optional<unsigned> VScaleMax = Attr.getVScaleRangeMax();
if (VScaleMax && VScaleMin == VScaleMax)
return ConstantInt::get(F->getReturnType(), VScaleMin);
return nullptr;
diff --git a/llvm/lib/Analysis/MemoryBuiltins.cpp b/llvm/lib/Analysis/MemoryBuiltins.cpp
index 1cba0571f1fcc..9deb96661f3e9 100644
--- a/llvm/lib/Analysis/MemoryBuiltins.cpp
+++ b/llvm/lib/Analysis/MemoryBuiltins.cpp
@@ -44,6 +44,7 @@
#include <cstdint>
#include <iterator>
#include <numeric>
+#include <optional>
#include <type_traits>
#include <utility>
@@ -251,7 +252,7 @@ static Optional<AllocFnsTy> getAllocationSize(const Value *V,
if (Attr == Attribute())
return None;
- std::pair<unsigned, Optional<unsigned>> Args = Attr.getAllocSizeArgs();
+ std::pair<unsigned, std::optional<unsigned>> Args = Attr.getAllocSizeArgs();
AllocFnsTy Result;
// Because allocsize only tells us how many bytes are allocated, we're not
diff --git a/llvm/lib/Analysis/TargetTransformInfo.cpp b/llvm/lib/Analysis/TargetTransformInfo.cpp
index c6f6bb499bc21..e8e8305db3bdf 100644
--- a/llvm/lib/Analysis/TargetTransformInfo.cpp
+++ b/llvm/lib/Analysis/TargetTransformInfo.cpp
@@ -650,11 +650,11 @@ unsigned TargetTransformInfo::getMinVectorRegisterBitWidth() const {
return TTIImpl->getMinVectorRegisterBitWidth();
}
-Optional<unsigned> TargetTransformInfo::getMaxVScale() const {
+std::optional<unsigned> TargetTransformInfo::getMaxVScale() const {
return TTIImpl->getMaxVScale();
}
-Optional<unsigned> TargetTransformInfo::getVScaleForTuning() const {
+std::optional<unsigned> TargetTransformInfo::getVScaleForTuning() const {
return TTIImpl->getVScaleForTuning();
}
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 28463bb074f2b..f29b0f8e634ef 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -1747,7 +1747,7 @@ static void computeKnownBitsFromOperator(const Operator *I,
break;
auto Attr = II->getFunction()->getFnAttribute(Attribute::VScaleRange);
- Optional<unsigned> VScaleMax = Attr.getVScaleRangeMax();
+ std::optional<unsigned> VScaleMax = Attr.getVScaleRangeMax();
if (!VScaleMax)
break;
diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp
index dde0672da8e48..4c80a199fc73b 100644
--- a/llvm/lib/AsmParser/LLParser.cpp
+++ b/llvm/lib/AsmParser/LLParser.cpp
@@ -50,6 +50,7 @@
#include <algorithm>
#include <cassert>
#include <cstring>
+#include <optional>
#include <vector>
using namespace llvm;
@@ -1427,7 +1428,7 @@ bool LLParser::parseEnumAttribute(Attribute::AttrKind Attr, AttrBuilder &B,
}
case Attribute::AllocSize: {
unsigned ElemSizeArg;
- Optional<unsigned> NumElemsArg;
+ std::optional<unsigned> NumElemsArg;
if (parseAllocSizeArguments(ElemSizeArg, NumElemsArg))
return true;
B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
@@ -1438,7 +1439,7 @@ bool LLParser::parseEnumAttribute(Attribute::AttrKind Attr, AttrBuilder &B,
if (parseVScaleRangeArguments(MinValue, MaxValue))
return true;
B.addVScaleRangeAttr(MinValue,
- MaxValue > 0 ? MaxValue : Optional<unsigned>());
+ MaxValue > 0 ? MaxValue : std::optional<unsigned>());
return false;
}
case Attribute::Dereferenceable: {
@@ -2371,7 +2372,7 @@ bool LLParser::parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
}
bool LLParser::parseAllocSizeArguments(unsigned &BaseSizeArg,
- Optional<unsigned> &HowManyArg) {
+ std::optional<unsigned> &HowManyArg) {
Lex.Lex();
auto StartParen = Lex.getLoc();
diff --git a/llvm/lib/IR/AttributeImpl.h b/llvm/lib/IR/AttributeImpl.h
index 86ddb683f9ee1..fd5bdf7415a43 100644
--- a/llvm/lib/IR/AttributeImpl.h
+++ b/llvm/lib/IR/AttributeImpl.h
@@ -24,6 +24,7 @@
#include <cassert>
#include <cstddef>
#include <cstdint>
+#include <optional>
#include <string>
#include <utility>
@@ -229,7 +230,7 @@ class AttributeSetNode final
static AttributeSetNode *getSorted(LLVMContext &C,
ArrayRef<Attribute> SortedAttrs);
- Optional<Attribute> findEnumAttribute(Attribute::AttrKind Kind) const;
+ std::optional<Attribute> findEnumAttribute(Attribute::AttrKind Kind) const;
public:
// AttributesSetNode is uniqued, these should not be available.
@@ -258,9 +259,10 @@ class AttributeSetNode final
MaybeAlign getStackAlignment() const;
uint64_t getDereferenceableBytes() const;
uint64_t getDereferenceableOrNullBytes() const;
- Optional<std::pair<unsigned, Optional<unsigned>>> getAllocSizeArgs() const;
+ std::optional<std::pair<unsigned, std::optional<unsigned>>> getAllocSizeArgs()
+ const;
unsigned getVScaleRangeMin() const;
- Optional<unsigned> getVScaleRangeMax() const;
+ std::optional<unsigned> getVScaleRangeMax() const;
UWTableKind getUWTableKind() const;
AllocFnKind getAllocKind() const;
MemoryEffects getMemoryEffects() const;
diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp
index 1a90b945eb2bf..e4dee3f4d9b44 100644
--- a/llvm/lib/IR/Attributes.cpp
+++ b/llvm/lib/IR/Attributes.cpp
@@ -17,7 +17,6 @@
#include "LLVMContextImpl.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/FoldingSet.h"
-#include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
@@ -36,6 +35,7 @@
#include <cstddef>
#include <cstdint>
#include <limits>
+#include <optional>
#include <string>
#include <tuple>
#include <utility>
@@ -55,7 +55,7 @@ using namespace llvm;
static const unsigned AllocSizeNumElemsNotPresent = -1;
static uint64_t packAllocSizeArgs(unsigned ElemSizeArg,
- const Optional<unsigned> &NumElemsArg) {
+ const std::optional<unsigned> &NumElemsArg) {
assert((!NumElemsArg || *NumElemsArg != AllocSizeNumElemsNotPresent) &&
"Attempting to pack a reserved value");
@@ -63,29 +63,29 @@ static uint64_t packAllocSizeArgs(unsigned ElemSizeArg,
NumElemsArg.value_or(AllocSizeNumElemsNotPresent);
}
-static std::pair<unsigned, Optional<unsigned>>
+static std::pair<unsigned, std::optional<unsigned>>
unpackAllocSizeArgs(uint64_t Num) {
unsigned NumElems = Num & std::numeric_limits<unsigned>::max();
unsigned ElemSizeArg = Num >> 32;
- Optional<unsigned> NumElemsArg;
+ std::optional<unsigned> NumElemsArg;
if (NumElems != AllocSizeNumElemsNotPresent)
NumElemsArg = NumElems;
return std::make_pair(ElemSizeArg, NumElemsArg);
}
static uint64_t packVScaleRangeArgs(unsigned MinValue,
- Optional<unsigned> MaxValue) {
+ std::optional<unsigned> MaxValue) {
return uint64_t(MinValue) << 32 | MaxValue.value_or(0);
}
-static std::pair<unsigned, Optional<unsigned>>
+static std::pair<unsigned, std::optional<unsigned>>
unpackVScaleRangeArgs(uint64_t Value) {
unsigned MaxValue = Value & std::numeric_limits<unsigned>::max();
unsigned MinValue = Value >> 32;
return std::make_pair(MinValue,
- MaxValue > 0 ? MaxValue : Optional<unsigned>());
+ MaxValue > 0 ? MaxValue : std::optional<unsigned>());
}
Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
@@ -218,7 +218,7 @@ Attribute Attribute::getWithMemoryEffects(LLVMContext &Context,
Attribute
Attribute::getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg,
- const Optional<unsigned> &NumElemsArg) {
+ const std::optional<unsigned> &NumElemsArg) {
assert(!(ElemSizeArg == 0 && NumElemsArg && *NumElemsArg == 0) &&
"Invalid allocsize arguments -- given allocsize(0, 0)");
return get(Context, AllocSize, packAllocSizeArgs(ElemSizeArg, NumElemsArg));
@@ -359,7 +359,8 @@ uint64_t Attribute::getDereferenceableOrNullBytes() const {
return pImpl->getValueAsInt();
}
-std::pair<unsigned, Optional<unsigned>> Attribute::getAllocSizeArgs() const {
+std::pair<unsigned, std::optional<unsigned>>
+Attribute::getAllocSizeArgs() const {
assert(hasAttribute(Attribute::AllocSize) &&
"Trying to get allocsize args from non-allocsize attribute");
return unpackAllocSizeArgs(pImpl->getValueAsInt());
@@ -371,7 +372,7 @@ unsigned Attribute::getVScaleRangeMin() const {
return unpackVScaleRangeArgs(pImpl->getValueAsInt()).first;
}
-Optional<unsigned> Attribute::getVScaleRangeMax() const {
+std::optional<unsigned> Attribute::getVScaleRangeMax() const {
assert(hasAttribute(Attribute::VScaleRange) &&
"Trying to get vscale args from non-vscale attribute");
return unpackVScaleRangeArgs(pImpl->getValueAsInt()).second;
@@ -452,7 +453,7 @@ std::string Attribute::getAsString(bool InAttrGrp) const {
if (hasAttribute(Attribute::AllocSize)) {
unsigned ElemSize;
- Optional<unsigned> NumElems;
+ std::optional<unsigned> NumElems;
std::tie(ElemSize, NumElems) = getAllocSizeArgs();
return (NumElems
@@ -463,7 +464,7 @@ std::string Attribute::getAsString(bool InAttrGrp) const {
if (hasAttribute(Attribute::VScaleRange)) {
unsigned MinValue = getVScaleRangeMin();
- Optional<unsigned> MaxValue = getVScaleRangeMax();
+ std::optional<unsigned> MaxValue = getVScaleRangeMax();
return ("vscale_range(" + Twine(MinValue) + "," +
Twine(MaxValue.value_or(0)) + ")")
.str();
@@ -812,19 +813,19 @@ Type *AttributeSet::getElementType() const {
return SetNode ? SetNode->getAttributeType(Attribute::ElementType) : nullptr;
}
-Optional<std::pair<unsigned, Optional<unsigned>>>
+std::optional<std::pair<unsigned, std::optional<unsigned>>>
AttributeSet::getAllocSizeArgs() const {
if (SetNode)
return SetNode->getAllocSizeArgs();
- return None;
+ return std::nullopt;
}
unsigned AttributeSet::getVScaleRangeMin() const {
return SetNode ? SetNode->getVScaleRangeMin() : 1;
}
-Optional<unsigned> AttributeSet::getVScaleRangeMax() const {
- return SetNode ? SetNode->getVScaleRangeMax() : None;
+std::optional<unsigned> AttributeSet::getVScaleRangeMax() const {
+ return SetNode ? SetNode->getVScaleRangeMax() : std::nullopt;
}
UWTableKind AttributeSet::getUWTableKind() const {
@@ -929,11 +930,11 @@ bool AttributeSetNode::hasAttribute(StringRef Kind) const {
return StringAttrs.count(Kind);
}
-Optional<Attribute>
+std::optional<Attribute>
AttributeSetNode::findEnumAttribute(Attribute::AttrKind Kind) const {
// Do a quick presence check.
if (!hasAttribute(Kind))
- return None;
+ return std::nullopt;
// Attributes in a set are sorted by enum value, followed by string
// attributes. Binary search the one we want.
@@ -986,11 +987,11 @@ uint64_t AttributeSetNode::getDereferenceableOrNullBytes() const {
return 0;
}
-Optional<std::pair<unsigned, Optional<unsigned>>>
+std::optional<std::pair<unsigned, std::optional<unsigned>>>
AttributeSetNode::getAllocSizeArgs() const {
if (auto A = findEnumAttribute(Attribute::AllocSize))
return A->getAllocSizeArgs();
- return None;
+ return std::nullopt;
}
unsigned AttributeSetNode::getVScaleRangeMin() const {
@@ -999,10 +1000,10 @@ unsigned AttributeSetNode::getVScaleRangeMin() const {
return 1;
}
-Optional<unsigned> AttributeSetNode::getVScaleRangeMax() const {
+std::optional<unsigned> AttributeSetNode::getVScaleRangeMax() const {
if (auto A = findEnumAttribute(Attribute::VScaleRange))
return A->getVScaleRangeMax();
- return None;
+ return std::nullopt;
}
UWTableKind AttributeSetNode::getUWTableKind() const {
@@ -1445,10 +1446,9 @@ AttributeList::addDereferenceableOrNullParamAttr(LLVMContext &C, unsigned Index,
return addParamAttributes(C, Index, B);
}
-AttributeList
-AttributeList::addAllocSizeParamAttr(LLVMContext &C, unsigned Index,
- unsigned ElemSizeArg,
- const Optional<unsigned> &NumElemsArg) {
+AttributeList AttributeList::addAllocSizeParamAttr(
+ LLVMContext &C, unsigned Index, unsigned ElemSizeArg,
+ const std::optional<unsigned> &NumElemsArg) {
AttrBuilder B(C);
B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
return addParamAttributes(C, Index, B);
@@ -1723,12 +1723,13 @@ AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
return *this;
}
-Optional<uint64_t> AttrBuilder::getRawIntAttr(Attribute::AttrKind Kind) const {
+std::optional<uint64_t>
+AttrBuilder::getRawIntAttr(Attribute::AttrKind Kind) const {
assert(Attribute::isIntAttrKind(Kind) && "Not an int attribute");
Attribute A = getAttribute(Kind);
if (A.isValid())
return A.getValueAsInt();
- return None;
+ return std::nullopt;
}
AttrBuilder &AttrBuilder::addRawIntAttr(Attribute::AttrKind Kind,
@@ -1736,12 +1737,12 @@ AttrBuilder &AttrBuilder::addRawIntAttr(Attribute::AttrKind Kind,
return addAttribute(Attribute::get(Ctx, Kind, Value));
}
-Optional<std::pair<unsigned, Optional<unsigned>>>
+std::optional<std::pair<unsigned, std::optional<unsigned>>>
AttrBuilder::getAllocSizeArgs() const {
Attribute A = getAttribute(Attribute::AllocSize);
if (A.isValid())
return A.getAllocSizeArgs();
- return None;
+ return std::nullopt;
}
AttrBuilder &AttrBuilder::addAlignmentAttr(MaybeAlign Align) {
@@ -1774,8 +1775,9 @@ AttrBuilder &AttrBuilder::addDereferenceableOrNullAttr(uint64_t Bytes) {
return addRawIntAttr(Attribute::DereferenceableOrNull, Bytes);
}
-AttrBuilder &AttrBuilder::addAllocSizeAttr(unsigned ElemSize,
- const Optional<unsigned> &NumElems) {
+AttrBuilder &
+AttrBuilder::addAllocSizeAttr(unsigned ElemSize,
+ const std::optional<unsigned> &NumElems) {
return addAllocSizeAttrFromRawRepr(packAllocSizeArgs(ElemSize, NumElems));
}
@@ -1786,7 +1788,7 @@ AttrBuilder &AttrBuilder::addAllocSizeAttrFromRawRepr(uint64_t RawArgs) {
}
AttrBuilder &AttrBuilder::addVScaleRangeAttr(unsigned MinValue,
- Optional<unsigned> MaxValue) {
+ std::optional<unsigned> MaxValue) {
return addVScaleRangeAttrFromRawRepr(packVScaleRangeArgs(MinValue, MaxValue));
}
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index 11842ef4a169e..610fc317b566e 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -2130,7 +2130,7 @@ void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
if (VScaleMin == 0)
CheckFailed("'vscale_range' minimum must be greater than 0", V);
- Optional<unsigned> VScaleMax = Attrs.getFnAttrs().getVScaleRangeMax();
+ std::optional<unsigned> VScaleMax = Attrs.getFnAttrs().getVScaleRangeMax();
if (VScaleMax && VScaleMin > VScaleMax)
CheckFailed("'vscale_range' minimum cannot be greater than maximum", V);
}
diff --git a/llvm/lib/Target/AArch64/AArch64TargetMachine.cpp b/llvm/lib/Target/AArch64/AArch64TargetMachine.cpp
index affdadfdde34e..997b662027f61 100644
--- a/llvm/lib/Target/AArch64/AArch64TargetMachine.cpp
+++ b/llvm/lib/Target/AArch64/AArch64TargetMachine.cpp
@@ -50,6 +50,7 @@
#include "llvm/Transforms/CFGuard.h"
#include "llvm/Transforms/Scalar.h"
#include <memory>
+#include <optional>
#include <string>
using namespace llvm;
@@ -397,7 +398,7 @@ AArch64TargetMachine::getSubtargetImpl(const Function &F) const {
unsigned MaxSVEVectorSize = 0;
Attribute VScaleRangeAttr = F.getFnAttribute(Attribute::VScaleRange);
if (VScaleRangeAttr.isValid()) {
- Optional<unsigned> VScaleMax = VScaleRangeAttr.getVScaleRangeMax();
+ std::optional<unsigned> VScaleMax = VScaleRangeAttr.getVScaleRangeMax();
MinSVEVectorSize = VScaleRangeAttr.getVScaleRangeMin() * 128;
MaxSVEVectorSize = VScaleMax ? *VScaleMax * 128 : 0;
} else {
diff --git a/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h b/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h
index e9a22862f3c38..04e26f1c98cbd 100644
--- a/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h
+++ b/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h
@@ -25,6 +25,7 @@
#include "llvm/IR/Function.h"
#include "llvm/IR/Intrinsics.h"
#include <cstdint>
+#include <optional>
namespace llvm {
@@ -126,7 +127,7 @@ class AArch64TTIImpl : public BasicTTIImplBase<AArch64TTIImpl> {
return ST->getMinVectorRegisterBitWidth();
}
- Optional<unsigned> getVScaleForTuning() const {
+ std::optional<unsigned> getVScaleForTuning() const {
return ST->getVScaleForTuning();
}
diff --git a/llvm/lib/Target/AArch64/SVEIntrinsicOpts.cpp b/llvm/lib/Target/AArch64/SVEIntrinsicOpts.cpp
index ccb34f367338a..c5a6cb7af405e 100644
--- a/llvm/lib/Target/AArch64/SVEIntrinsicOpts.cpp
+++ b/llvm/lib/Target/AArch64/SVEIntrinsicOpts.cpp
@@ -34,6 +34,7 @@
#include "llvm/IR/PatternMatch.h"
#include "llvm/InitializePasses.h"
#include "llvm/Support/Debug.h"
+#include <optional>
using namespace llvm;
using namespace llvm::PatternMatch;
@@ -284,7 +285,7 @@ bool SVEIntrinsicOpts::optimizePredicateStore(Instruction *I) {
return false;
unsigned MinVScale = Attr.getVScaleRangeMin();
- Optional<unsigned> MaxVScale = Attr.getVScaleRangeMax();
+ std::optional<unsigned> MaxVScale = Attr.getVScaleRangeMax();
// The transform needs to know the exact runtime length of scalable vectors
if (!MaxVScale || MinVScale != MaxVScale)
return false;
@@ -347,7 +348,7 @@ bool SVEIntrinsicOpts::optimizePredicateLoad(Instruction *I) {
return false;
unsigned MinVScale = Attr.getVScaleRangeMin();
- Optional<unsigned> MaxVScale = Attr.getVScaleRangeMax();
+ std::optional<unsigned> MaxVScale = Attr.getVScaleRangeMax();
// The transform needs to know the exact runtime length of scalable vectors
if (!MaxVScale || MinVScale != MaxVScale)
return false;
diff --git a/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.cpp b/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.cpp
index c2db9747113c4..ef39a93665cb2 100644
--- a/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.cpp
+++ b/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.cpp
@@ -13,6 +13,7 @@
#include "llvm/CodeGen/CostTable.h"
#include "llvm/CodeGen/TargetLowering.h"
#include <cmath>
+#include <optional>
using namespace llvm;
#define DEBUG_TYPE "riscvtti"
@@ -196,13 +197,13 @@ bool RISCVTTIImpl::shouldExpandReduction(const IntrinsicInst *II) const {
}
}
-Optional<unsigned> RISCVTTIImpl::getMaxVScale() const {
+std::optional<unsigned> RISCVTTIImpl::getMaxVScale() const {
if (ST->hasVInstructions())
return ST->getRealMaxVLen() / RISCV::RVVBitsPerBlock;
return BaseT::getMaxVScale();
}
-Optional<unsigned> RISCVTTIImpl::getVScaleForTuning() const {
+std::optional<unsigned> RISCVTTIImpl::getVScaleForTuning() const {
if (ST->hasVInstructions())
if (unsigned MinVLen = ST->getRealMinVLen();
MinVLen >= RISCV::RVVBitsPerBlock)
diff --git a/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h b/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h
index 36dd86992263d..d13d58a3c1cf7 100644
--- a/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h
+++ b/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h
@@ -22,6 +22,7 @@
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/CodeGen/BasicTTIImpl.h"
#include "llvm/IR/Function.h"
+#include <optional>
namespace llvm {
@@ -79,8 +80,8 @@ class RISCVTTIImpl : public BasicTTIImplBase<RISCVTTIImpl> {
return ST->hasVInstructions() ? PredicationStyle::Data
: PredicationStyle::None;
}
- Optional<unsigned> getMaxVScale() const;
- Optional<unsigned> getVScaleForTuning() const;
+ std::optional<unsigned> getMaxVScale() const;
+ std::optional<unsigned> getVScaleForTuning() const;
TypeSize getRegisterBitWidth(TargetTransformInfo::RegisterKind K) const;
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp
index d6f6dd5512699..43d359acabc80 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp
@@ -18,6 +18,8 @@
#include "llvm/IR/PatternMatch.h"
#include "llvm/Support/KnownBits.h"
#include "llvm/Transforms/InstCombine/InstCombiner.h"
+#include <optional>
+
using namespace llvm;
using namespace PatternMatch;
@@ -979,7 +981,7 @@ Instruction *InstCombinerImpl::visitTrunc(TruncInst &Trunc) {
Trunc.getFunction()->hasFnAttribute(Attribute::VScaleRange)) {
Attribute Attr =
Trunc.getFunction()->getFnAttribute(Attribute::VScaleRange);
- if (Optional<unsigned> MaxVScale = Attr.getVScaleRangeMax()) {
+ if (std::optional<unsigned> MaxVScale = Attr.getVScaleRangeMax()) {
if (Log2_32(*MaxVScale) < DestWidth) {
Value *VScale = Builder.CreateVScale(ConstantInt::get(DestTy, 1));
return replaceInstUsesWith(Trunc, VScale);
@@ -1348,7 +1350,7 @@ Instruction *InstCombinerImpl::visitZExt(ZExtInst &CI) {
if (CI.getFunction() &&
CI.getFunction()->hasFnAttribute(Attribute::VScaleRange)) {
Attribute Attr = CI.getFunction()->getFnAttribute(Attribute::VScaleRange);
- if (Optional<unsigned> MaxVScale = Attr.getVScaleRangeMax()) {
+ if (std::optional<unsigned> MaxVScale = Attr.getVScaleRangeMax()) {
unsigned TypeWidth = Src->getType()->getScalarSizeInBits();
if (Log2_32(*MaxVScale) < TypeWidth) {
Value *VScale = Builder.CreateVScale(ConstantInt::get(DestTy, 1));
@@ -1622,7 +1624,7 @@ Instruction *InstCombinerImpl::visitSExt(SExtInst &CI) {
if (CI.getFunction() &&
CI.getFunction()->hasFnAttribute(Attribute::VScaleRange)) {
Attribute Attr = CI.getFunction()->getFnAttribute(Attribute::VScaleRange);
- if (Optional<unsigned> MaxVScale = Attr.getVScaleRangeMax()) {
+ if (std::optional<unsigned> MaxVScale = Attr.getVScaleRangeMax()) {
if (Log2_32(*MaxVScale) < (SrcBitSize - 1)) {
Value *VScale = Builder.CreateVScale(ConstantInt::get(DestTy, 1));
return replaceInstUsesWith(CI, VScale);
diff --git a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp
index 5fb4ee1cac524..1c8874069c27a 100644
--- a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp
+++ b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp
@@ -24,6 +24,7 @@
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
#include "llvm/Support/TypeSize.h"
+#include <optional>
using namespace llvm;
@@ -226,7 +227,7 @@ static bool setAllocatedPointerParam(Function &F, unsigned ArgNo) {
}
static bool setAllocSize(Function &F, unsigned ElemSizeArg,
- Optional<unsigned> NumElemsArg) {
+ std::optional<unsigned> NumElemsArg) {
if (F.hasFnAttribute(Attribute::AllocSize))
return false;
F.addFnAttr(Attribute::getWithAllocSizeArgs(F.getContext(), ElemSizeArg,
@@ -441,7 +442,7 @@ bool llvm::inferNonMandatoryLibFuncAttrs(Function &F,
break;
case LibFunc_aligned_alloc:
Changed |= setAlignedAllocParam(F, 0);
- Changed |= setAllocSize(F, 1, None);
+ Changed |= setAllocSize(F, 1, std::nullopt);
Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Uninitialized | AllocFnKind::Aligned);
[[fallthrough]];
case LibFunc_valloc:
@@ -450,7 +451,7 @@ bool llvm::inferNonMandatoryLibFuncAttrs(Function &F,
Changed |= setAllocFamily(F, TheLibFunc == LibFunc_vec_malloc ? "vec_malloc"
: "malloc");
Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Uninitialized);
- Changed |= setAllocSize(F, 0, None);
+ Changed |= setAllocSize(F, 0, std::nullopt);
Changed |= setOnlyAccessesInaccessibleMemory(F);
Changed |= setRetAndArgsNoUndef(F);
Changed |= setDoesNotThrow(F);
@@ -516,7 +517,7 @@ bool llvm::inferNonMandatoryLibFuncAttrs(Function &F,
Changed |= setAllocFamily(F, "malloc");
Changed |= setAllocKind(F, AllocFnKind::Alloc | AllocFnKind::Aligned |
AllocFnKind::Uninitialized);
- Changed |= setAllocSize(F, 1, None);
+ Changed |= setAllocSize(F, 1, std::nullopt);
Changed |= setAlignedAllocParam(F, 0);
Changed |= setOnlyAccessesInaccessibleMemory(F);
Changed |= setRetNoUndef(F);
@@ -543,7 +544,7 @@ bool llvm::inferNonMandatoryLibFuncAttrs(Function &F,
F, TheLibFunc == LibFunc_vec_realloc ? "vec_malloc" : "malloc");
Changed |= setAllocKind(F, AllocFnKind::Realloc);
Changed |= setAllocatedPointerParam(F, 0);
- Changed |= setAllocSize(F, 1, None);
+ Changed |= setAllocSize(F, 1, std::nullopt);
Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
Changed |= setRetNoUndef(F);
Changed |= setDoesNotThrow(F);
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index 6eb851677c69c..5f4bb5453ab17 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -1581,7 +1581,7 @@ class LoopVectorizationCostModel {
/// Convenience function that returns the value of vscale_range iff
/// vscale_range.min == vscale_range.max or otherwise returns the value
/// returned by the corresponding TLI method.
- Optional<unsigned> getVScaleForTuning() const;
+ std::optional<unsigned> getVScaleForTuning() const;
private:
unsigned NumPredStores = 0;
@@ -4906,7 +4906,7 @@ LoopVectorizationCostModel::getMaxLegalScalableVF(unsigned MaxSafeElements) {
return MaxScalableVF;
// Limit MaxScalableVF by the maximum safe dependence distance.
- Optional<unsigned> MaxVScale = TTI.getMaxVScale();
+ std::optional<unsigned> MaxVScale = TTI.getMaxVScale();
if (!MaxVScale && TheFunction->hasFnAttribute(Attribute::VScaleRange))
MaxVScale =
TheFunction->getFnAttribute(Attribute::VScaleRange).getVScaleRangeMax();
@@ -5268,7 +5268,7 @@ ElementCount LoopVectorizationCostModel::getMaximizedVFForTarget(
return MaxVF;
}
-Optional<unsigned> LoopVectorizationCostModel::getVScaleForTuning() const {
+std::optional<unsigned> LoopVectorizationCostModel::getVScaleForTuning() const {
if (TheFunction->hasFnAttribute(Attribute::VScaleRange)) {
auto Attr = TheFunction->getFnAttribute(Attribute::VScaleRange);
auto Min = Attr.getVScaleRangeMin();
@@ -5304,7 +5304,7 @@ bool LoopVectorizationCostModel::isMoreProfitable(
// Improve estimate for the vector width if it is scalable.
unsigned EstimatedWidthA = A.Width.getKnownMinValue();
unsigned EstimatedWidthB = B.Width.getKnownMinValue();
- if (Optional<unsigned> VScale = getVScaleForTuning()) {
+ if (std::optional<unsigned> VScale = getVScaleForTuning()) {
if (A.Width.isScalable())
EstimatedWidthA *= VScale.value();
if (B.Width.isScalable())
@@ -5354,7 +5354,7 @@ VectorizationFactor LoopVectorizationCostModel::selectVectorizationFactor(
#ifndef NDEBUG
unsigned AssumedMinimumVscale = 1;
- if (Optional<unsigned> VScale = getVScaleForTuning())
+ if (std::optional<unsigned> VScale = getVScaleForTuning())
AssumedMinimumVscale = *VScale;
unsigned Width =
Candidate.Width.isScalable()
@@ -5577,7 +5577,7 @@ LoopVectorizationCostModel::selectEpilogueVectorizationFactor(
ElementCount EstimatedRuntimeVF = MainLoopVF;
if (MainLoopVF.isScalable()) {
EstimatedRuntimeVF = ElementCount::getFixed(MainLoopVF.getKnownMinValue());
- if (Optional<unsigned> VScale = getVScaleForTuning())
+ if (std::optional<unsigned> VScale = getVScaleForTuning())
EstimatedRuntimeVF *= *VScale;
}
@@ -10042,7 +10042,7 @@ static void checkMixedPrecision(Loop *L, OptimizationRemarkEmitter *ORE) {
static bool areRuntimeChecksProfitable(GeneratedRTChecks &Checks,
VectorizationFactor &VF,
- Optional<unsigned> VScale, Loop *L,
+ std::optional<unsigned> VScale, Loop *L,
ScalarEvolution &SE) {
InstructionCost CheckCost = Checks.getCost();
if (!CheckCost.isValid())
More information about the cfe-commits
mailing list