[Mlir-commits] [mlir] 1a36588 - [mlir] Use std::nullopt instead of None (NFC)
Kazu Hirata
llvmlistbot at llvm.org
Sat Dec 3 18:50:38 PST 2022
Author: Kazu Hirata
Date: 2022-12-03T18:50:27-08:00
New Revision: 1a36588ec64ae8576e531e6f0b49eadb90ab0b11
URL: https://github.com/llvm/llvm-project/commit/1a36588ec64ae8576e531e6f0b49eadb90ab0b11
DIFF: https://github.com/llvm/llvm-project/commit/1a36588ec64ae8576e531e6f0b49eadb90ab0b11.diff
LOG: [mlir] Use std::nullopt instead of None (NFC)
This patch mechanically replaces None with std::nullopt where the
compiler would warn if None were deprecated. The intent is to reduce
the amount of manual work required in migrating from Optional to
std::optional.
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:
mlir/include/mlir/Analysis/DataFlow/IntegerRangeAnalysis.h
mlir/include/mlir/AsmParser/AsmParserState.h
mlir/include/mlir/CAPI/Wrap.h
mlir/include/mlir/Conversion/MathToLibm/MathToLibm.h
mlir/include/mlir/Dialect/Affine/Analysis/AffineAnalysis.h
mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h
mlir/include/mlir/Dialect/Func/Transforms/DecomposeCallGraphTypes.h
mlir/include/mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h
mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h
mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h
mlir/include/mlir/Dialect/SparseTensor/Utils/Merger.h
mlir/include/mlir/Dialect/Tosa/Utils/CoversionUtils.h
mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h
mlir/include/mlir/Dialect/Utils/ReshapeOpsUtils.h
mlir/include/mlir/Dialect/Vector/IR/VectorOps.h
mlir/include/mlir/ExecutionEngine/ExecutionEngine.h
mlir/include/mlir/IR/BlockSupport.h
mlir/include/mlir/IR/Builders.h
mlir/include/mlir/IR/BuiltinAttributeInterfaces.h
mlir/include/mlir/IR/Diagnostics.h
mlir/include/mlir/IR/DialectImplementation.h
mlir/include/mlir/IR/FunctionInterfaces.h
mlir/include/mlir/IR/Matchers.h
mlir/include/mlir/IR/OpDefinition.h
mlir/include/mlir/IR/OpImplementation.h
mlir/include/mlir/IR/Operation.h
mlir/include/mlir/IR/OperationSupport.h
mlir/include/mlir/IR/PatternMatch.h
mlir/include/mlir/IR/Region.h
mlir/include/mlir/IR/SymbolTable.h
mlir/include/mlir/IR/TypeRange.h
mlir/include/mlir/IR/ValueRange.h
mlir/include/mlir/Interfaces/ControlFlowInterfaces.h
mlir/include/mlir/Pass/AnalysisManager.h
mlir/include/mlir/Pass/Pass.h
mlir/include/mlir/Pass/PassOptions.h
mlir/include/mlir/Rewrite/FrozenRewritePatternSet.h
mlir/include/mlir/Support/StorageUniquer.h
mlir/include/mlir/TableGen/Operator.h
mlir/include/mlir/TableGen/Pattern.h
mlir/include/mlir/Tools/PDLL/AST/Diagnostic.h
mlir/include/mlir/Tools/PDLL/AST/Nodes.h
mlir/include/mlir/Tools/PDLL/AST/Types.h
mlir/include/mlir/Tools/mlir-translate/Translation.h
mlir/include/mlir/Transforms/DialectConversion.h
mlir/include/mlir/Transforms/InliningUtils.h
mlir/include/mlir/Transforms/Passes.h
mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp
mlir/lib/Analysis/DataFlow/SparseAnalysis.cpp
mlir/lib/Analysis/Presburger/IntegerRelation.cpp
mlir/lib/Analysis/Presburger/PWMAFunction.cpp
mlir/lib/Analysis/Presburger/PresburgerRelation.cpp
mlir/lib/Analysis/Presburger/Utils.cpp
mlir/lib/AsmParser/AttributeParser.cpp
mlir/lib/AsmParser/Parser.cpp
mlir/lib/AsmParser/Parser.h
mlir/lib/AsmParser/Token.cpp
mlir/lib/AsmParser/TypeParser.cpp
mlir/lib/CAPI/IR/Pass.cpp
mlir/lib/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.cpp
mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp
mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp
mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp
mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp
mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp
mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp
mlir/lib/Conversion/MemRefToSPIRV/MapMemRefStorageClassPass.cpp
mlir/lib/Conversion/NVGPUToNVVM/NVGPUToNVVM.cpp
mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
mlir/lib/Conversion/PDLToPDLInterp/Predicate.h
mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp
mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp
mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp
mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp
mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp
mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp
mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp
mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp
mlir/lib/Dialect/AMDGPU/IR/AMDGPUDialect.cpp
mlir/lib/Dialect/Affine/Analysis/AffineAnalysis.cpp
mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp
mlir/lib/Dialect/Affine/Analysis/LoopAnalysis.cpp
mlir/lib/Dialect/Affine/Analysis/Utils.cpp
mlir/lib/Dialect/Affine/IR/AffineOps.cpp
mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp
mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp
mlir/lib/Dialect/Affine/Transforms/LoopUnroll.cpp
mlir/lib/Dialect/Affine/Transforms/LoopUnrollAndJam.cpp
mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp
mlir/lib/Dialect/Affine/Utils/Utils.cpp
mlir/lib/Dialect/Arith/IR/ArithOps.cpp
mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp
mlir/lib/Dialect/Async/IR/Async.cpp
mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp
mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp
mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp
mlir/lib/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.cpp
mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp
mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp
mlir/lib/Dialect/Bufferization/Transforms/OneShotAnalysis.cpp
mlir/lib/Dialect/Func/IR/FuncOps.cpp
mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp
mlir/lib/Dialect/GPU/Transforms/SerializeToBlob.cpp
mlir/lib/Dialect/GPU/Transforms/SerializeToHsaco.cpp
mlir/lib/Dialect/Index/IR/IndexOps.cpp
mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp
mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp
mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp
mlir/lib/Dialect/Linalg/Transforms/ConstantFold.cpp
mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp
mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp
mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp
mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp
mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp
mlir/lib/Dialect/Linalg/Utils/Utils.cpp
mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp
mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp
mlir/lib/Dialect/MemRef/Transforms/EmulateWideInt.cpp
mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
mlir/lib/Dialect/SCF/IR/SCF.cpp
mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp
mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp
mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp
mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp
mlir/lib/Dialect/SPIRV/IR/TargetAndABI.cpp
mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp
mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp
mlir/lib/Dialect/SPIRV/Transforms/UnifyAliasedResourcePass.cpp
mlir/lib/Dialect/Shape/IR/Shape.cpp
mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp
mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp
mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp
mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp
mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp
mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
mlir/lib/Dialect/Tensor/IR/TensorOps.cpp
mlir/lib/Dialect/Traits.cpp
mlir/lib/Dialect/Utils/IndexingUtils.cpp
mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp
mlir/lib/Dialect/Utils/StaticValueUtils.cpp
mlir/lib/Dialect/Vector/IR/VectorOps.cpp
mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp
mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp
mlir/lib/Dialect/Vector/Transforms/VectorUnroll.cpp
mlir/lib/ExecutionEngine/OptUtils.cpp
mlir/lib/IR/AffineMap.cpp
mlir/lib/IR/BuiltinAttributes.cpp
mlir/lib/IR/BuiltinTypes.cpp
mlir/lib/IR/Diagnostics.cpp
mlir/lib/IR/Dialect.cpp
mlir/lib/IR/ExtensibleDialect.cpp
mlir/lib/IR/MLIRContext.cpp
mlir/lib/IR/SymbolTable.cpp
mlir/lib/Interfaces/ControlFlowInterfaces.cpp
mlir/lib/Interfaces/InferIntRangeInterface.cpp
mlir/lib/Pass/Pass.cpp
mlir/lib/Pass/PassStatistics.cpp
mlir/lib/Reducer/Tester.cpp
mlir/lib/Support/FileUtilities.cpp
mlir/lib/Support/Timing.cpp
mlir/lib/TableGen/AttrOrTypeDef.cpp
mlir/lib/TableGen/Attribute.cpp
mlir/lib/TableGen/Builder.cpp
mlir/lib/TableGen/Constraint.cpp
mlir/lib/TableGen/Interfaces.cpp
mlir/lib/TableGen/Type.cpp
mlir/lib/Target/LLVMIR/DebugTranslation.cpp
mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp
mlir/lib/Target/LLVMIR/ModuleTranslation.cpp
mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
mlir/lib/Target/SPIRV/Deserialization/Deserializer.h
mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp
mlir/lib/Tools/PDLL/Parser/Parser.cpp
mlir/lib/Tools/lsp-server-support/SourceMgrUtils.cpp
mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp
mlir/lib/Tools/mlir-pdll-lsp-server/PDLLServer.cpp
mlir/lib/Tools/mlir-translate/Translation.cpp
mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp
mlir/lib/Transforms/Utils/DialectConversion.cpp
mlir/lib/Transforms/ViewOpGraph.cpp
mlir/test/lib/Analysis/DataFlow/TestDenseDataFlowAnalysis.cpp
mlir/test/lib/Dialect/Bufferization/TestTensorCopyInsertion.cpp
mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp
mlir/test/lib/Dialect/Test/TestAttributes.cpp
mlir/test/lib/Dialect/Test/TestDialect.cpp
mlir/test/lib/Dialect/Test/TestPatterns.cpp
mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp
mlir/test/lib/Interfaces/TilingInterface/TestTilingInterface.cpp
mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp
mlir/tools/mlir-tblgen/DialectGen.cpp
mlir/tools/mlir-tblgen/EnumsGen.cpp
mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
mlir/tools/mlir-tblgen/OpFormatGen.cpp
Removed:
################################################################################
diff --git a/mlir/include/mlir/Analysis/DataFlow/IntegerRangeAnalysis.h b/mlir/include/mlir/Analysis/DataFlow/IntegerRangeAnalysis.h
index c11d305c73be..70a579eaaa07 100644
--- a/mlir/include/mlir/Analysis/DataFlow/IntegerRangeAnalysis.h
+++ b/mlir/include/mlir/Analysis/DataFlow/IntegerRangeAnalysis.h
@@ -30,7 +30,7 @@ class IntegerValueRange {
static IntegerValueRange getMaxRange(Value value);
/// Create an integer value range lattice value.
- IntegerValueRange(Optional<ConstantIntRanges> value = None)
+ IntegerValueRange(Optional<ConstantIntRanges> value = std::nullopt)
: value(std::move(value)) {}
/// Whether the range is uninitialized. This happens when the state hasn't
diff --git a/mlir/include/mlir/AsmParser/AsmParserState.h b/mlir/include/mlir/AsmParser/AsmParserState.h
index 4538f74dfa4c..d2e9e5428aeb 100644
--- a/mlir/include/mlir/AsmParser/AsmParserState.h
+++ b/mlir/include/mlir/AsmParser/AsmParserState.h
@@ -143,7 +143,7 @@ class AsmParserState {
/// Finalize the most recently started operation definition.
void finalizeOperationDefinition(
Operation *op, SMRange nameLoc, SMLoc endLoc,
- ArrayRef<std::pair<unsigned, SMLoc>> resultGroups = llvm::None);
+ ArrayRef<std::pair<unsigned, SMLoc>> resultGroups = std::nullopt);
/// Start a definition for a region nested under the current operation.
void startRegionDefinition();
diff --git a/mlir/include/mlir/CAPI/Wrap.h b/mlir/include/mlir/CAPI/Wrap.h
index b8cc745d70c4..5b68f417a3df 100644
--- a/mlir/include/mlir/CAPI/Wrap.h
+++ b/mlir/include/mlir/CAPI/Wrap.h
@@ -44,7 +44,7 @@ static llvm::ArrayRef<CppTy> unwrapList(size_t size, CTy *first,
"incompatible C and C++ types");
if (size == 0)
- return llvm::None;
+ return std::nullopt;
assert(storage.empty() && "expected to populate storage");
storage.reserve(size);
diff --git a/mlir/include/mlir/Conversion/MathToLibm/MathToLibm.h b/mlir/include/mlir/Conversion/MathToLibm/MathToLibm.h
index 82b58bc6c683..caca1ceb8d6f 100644
--- a/mlir/include/mlir/Conversion/MathToLibm/MathToLibm.h
+++ b/mlir/include/mlir/Conversion/MathToLibm/MathToLibm.h
@@ -21,7 +21,7 @@ class OperationPass;
/// If log1pBenefit is present, use it instead of benefit for the Log1p op.
void populateMathToLibmConversionPatterns(
RewritePatternSet &patterns, PatternBenefit benefit,
- llvm::Optional<PatternBenefit> log1pBenefit = llvm::None);
+ llvm::Optional<PatternBenefit> log1pBenefit = std::nullopt);
/// Create a pass to convert Math operations to libm calls.
std::unique_ptr<OperationPass<ModuleOp>> createConvertMathToLibmPass();
diff --git a/mlir/include/mlir/Dialect/Affine/Analysis/AffineAnalysis.h b/mlir/include/mlir/Dialect/Affine/Analysis/AffineAnalysis.h
index fec0272f0d60..636a23dc2a9b 100644
--- a/mlir/include/mlir/Dialect/Affine/Analysis/AffineAnalysis.h
+++ b/mlir/include/mlir/Dialect/Affine/Analysis/AffineAnalysis.h
@@ -143,7 +143,7 @@ struct DependenceComponent {
Optional<int64_t> lb;
// The upper bound of the dependence distance (inclusive).
Optional<int64_t> ub;
- DependenceComponent() : lb(llvm::None), ub(llvm::None) {}
+ DependenceComponent() : lb(std::nullopt), ub(std::nullopt) {}
};
/// Checks whether two accesses to the same memref access the same element.
diff --git a/mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h b/mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h
index 0e78d4c4cc28..29c059fbd122 100644
--- a/mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h
+++ b/mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h
@@ -55,7 +55,7 @@ class FlatAffineValueConstraints : public presburger::IntegerPolyhedron {
assert(valArgs.empty() || valArgs.size() == getNumDimAndSymbolVars());
values.reserve(numReservedCols);
if (valArgs.empty())
- values.resize(getNumDimAndSymbolVars(), None);
+ values.resize(getNumDimAndSymbolVars(), std::nullopt);
else
values.append(valArgs.begin(), valArgs.end());
}
@@ -76,7 +76,7 @@ class FlatAffineValueConstraints : public presburger::IntegerPolyhedron {
: IntegerPolyhedron(fac) {
assert(valArgs.empty() || valArgs.size() == getNumDimAndSymbolVars());
if (valArgs.empty())
- values.resize(getNumDimAndSymbolVars(), None);
+ values.resize(getNumDimAndSymbolVars(), std::nullopt);
else
values.append(valArgs.begin(), valArgs.end());
}
diff --git a/mlir/include/mlir/Dialect/Func/Transforms/DecomposeCallGraphTypes.h b/mlir/include/mlir/Dialect/Func/Transforms/DecomposeCallGraphTypes.h
index 3f811d7e12d8..bcb60beab1f8 100644
--- a/mlir/include/mlir/Dialect/Func/Transforms/DecomposeCallGraphTypes.h
+++ b/mlir/include/mlir/Dialect/Func/Transforms/DecomposeCallGraphTypes.h
@@ -72,7 +72,7 @@ class ValueDecomposer {
SmallVectorImpl<Value> &newValues) -> Optional<LogicalResult> {
if (T derivedType = type.dyn_cast<T>())
return callback(builder, loc, derivedType, value, newValues);
- return llvm::None;
+ return std::nullopt;
};
}
diff --git a/mlir/include/mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h b/mlir/include/mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h
index b34973ce8859..a82d25a4c211 100644
--- a/mlir/include/mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h
+++ b/mlir/include/mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h
@@ -80,7 +80,7 @@ class LinalgDependenceGraph {
static Optional<AffineMap> getIndexingMap(OpView opView) {
auto owner = dyn_cast<LinalgOp>(getOwner(opView));
if (!owner)
- return llvm::None;
+ return std::nullopt;
if (OpOperand *operand = opView.dyn_cast<OpOperand *>())
return owner.getMatchingIndexingMap(operand);
return owner.getMatchingIndexingMap(owner.getDpsInitOperand(
@@ -91,14 +91,14 @@ class LinalgDependenceGraph {
static Optional<unsigned> getOperandNumber(OpView opView) {
if (OpOperand *operand = opView.dyn_cast<OpOperand *>())
return operand->getOperandNumber();
- return llvm::None;
+ return std::nullopt;
}
// Return the result number if the `opView` is an OpResult. Otherwise return
// llvm::None.
static Optional<unsigned> getResultNumber(OpView opView) {
if (OpResult result = opView.dyn_cast<Value>().cast<OpResult>())
return result.getResultNumber();
- return llvm::None;
+ return std::nullopt;
}
// Return the owner of the dependent OpView.
diff --git a/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h b/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h
index 29072c2443f6..7c48782f0492 100644
--- a/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h
+++ b/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h
@@ -248,7 +248,7 @@ using CopyCallbackFn =
struct LinalgPromotionOptions {
/// Indices of subViews to promote. If `None`, try to promote all operands.
- Optional<DenseSet<unsigned>> operandsToPromote = None;
+ Optional<DenseSet<unsigned>> operandsToPromote = std::nullopt;
LinalgPromotionOptions &setOperandsToPromote(ArrayRef<int64_t> operands) {
operandsToPromote = DenseSet<unsigned>();
operandsToPromote->insert(operands.begin(), operands.end());
@@ -259,7 +259,7 @@ struct LinalgPromotionOptions {
/// Otherwise the partial view will be used. The decision is defaulted to
/// `useFullTileBuffersDefault` when `useFullTileBuffers` is None and for
/// operands missing from `useFullTileBuffers`.
- Optional<llvm::SmallBitVector> useFullTileBuffers = None;
+ Optional<llvm::SmallBitVector> useFullTileBuffers = std::nullopt;
LinalgPromotionOptions &setUseFullTileBuffers(ArrayRef<bool> useFullTiles) {
unsigned size = useFullTiles.size();
llvm::SmallBitVector tmp(size, false);
@@ -276,7 +276,7 @@ struct LinalgPromotionOptions {
return *this;
}
/// Alignment of promoted buffer. If `None` do not specify alignment.
- Optional<unsigned> alignment = None;
+ Optional<unsigned> alignment = std::nullopt;
LinalgPromotionOptions &setAlignment(unsigned align) {
alignment = align;
return *this;
@@ -290,8 +290,8 @@ struct LinalgPromotionOptions {
/// Callback function to do the allocation of the promoted buffer. If None,
/// then the default allocation scheme of allocating a memref<?xi8> buffer
/// followed by a view operation is used.
- Optional<AllocBufferCallbackFn> allocationFn = None;
- Optional<DeallocBufferCallbackFn> deallocationFn = None;
+ Optional<AllocBufferCallbackFn> allocationFn = std::nullopt;
+ Optional<DeallocBufferCallbackFn> deallocationFn = std::nullopt;
LinalgPromotionOptions &
setAllocationDeallocationFns(AllocBufferCallbackFn const &allocFn,
DeallocBufferCallbackFn const &deallocFn) {
@@ -301,8 +301,8 @@ struct LinalgPromotionOptions {
}
/// Callback function to do the copy of data to and from the promoted
/// subview. If None then a memref.copy is used.
- Optional<CopyCallbackFn> copyInFn = None;
- Optional<CopyCallbackFn> copyOutFn = None;
+ Optional<CopyCallbackFn> copyInFn = std::nullopt;
+ Optional<CopyCallbackFn> copyOutFn = std::nullopt;
LinalgPromotionOptions &setCopyInOutFns(CopyCallbackFn const ©In,
CopyCallbackFn const ©Out) {
copyInFn = copyIn;
@@ -598,7 +598,7 @@ struct LinalgTilingAndFusionOptions {
SmallVector<int64_t> tileInterchange;
/// When specified, specifies distribution of generated tile loops to
/// processors.
- Optional<LinalgLoopDistributionOptions> tileDistribution = None;
+ Optional<LinalgLoopDistributionOptions> tileDistribution = std::nullopt;
LinalgTilingAndFusionOptions &
setDistributionOptions(LinalgLoopDistributionOptions distributionOptions) {
tileDistribution = std::move(distributionOptions);
@@ -651,7 +651,7 @@ struct LinalgTilingOptions {
/// When specified, specifies distribution of generated tile loops to
/// processors.
- Optional<LinalgLoopDistributionOptions> distribution = None;
+ Optional<LinalgLoopDistributionOptions> distribution = std::nullopt;
LinalgTilingOptions &
setDistributionOptions(LinalgLoopDistributionOptions distributionOptions) {
diff --git a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h
index 8d48bc332e4a..6218b62f075b 100644
--- a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h
+++ b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h
@@ -56,7 +56,7 @@ class SPIRVType : public Type {
/// the given `storage` class. This method does not guarantee the uniqueness
/// of extensions; the same extension may be appended multiple times.
void getExtensions(ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
/// The capability requirements for each type are following the
/// ((Capability::A OR Extension::B) AND (Capability::C OR Capability::D))
@@ -68,7 +68,7 @@ class SPIRVType : public Type {
/// uniqueness of capabilities; the same capability may be appended multiple
/// times.
void getCapabilities(CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
/// Returns the size in bytes for each type. If no size can be calculated,
/// returns `llvm::None`. Note that if the type has explicit layout, it is
@@ -89,9 +89,9 @@ class ScalarType : public SPIRVType {
static bool isValid(IntegerType);
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
Optional<int64_t> getSizeInBytes();
};
@@ -117,9 +117,9 @@ class CompositeType : public SPIRVType {
bool hasCompileTimeKnownNumElements() const;
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
Optional<int64_t> getSizeInBytes();
};
@@ -145,9 +145,9 @@ class ArrayType : public Type::TypeBase<ArrayType, CompositeType,
unsigned getArrayStride() const;
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
/// Returns the array size in bytes. Since array type may have an explicit
/// stride declaration (in bytes), we also include it in the calculation.
@@ -188,9 +188,9 @@ class ImageType
// TODO: Add support for Access qualifier
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
};
// SPIR-V pointer type
@@ -206,9 +206,9 @@ class PointerType : public Type::TypeBase<PointerType, SPIRVType,
StorageClass getStorageClass() const;
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
};
// SPIR-V run-time array type
@@ -230,9 +230,9 @@ class RuntimeArrayType
unsigned getArrayStride() const;
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
};
// SPIR-V sampled image type
@@ -253,9 +253,9 @@ class SampledImageType
Type getImageType() const;
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<spirv::StorageClass> storage = llvm::None);
+ Optional<spirv::StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<spirv::StorageClass> storage = llvm::None);
+ Optional<spirv::StorageClass> storage = std::nullopt);
};
/// SPIR-V struct type. Two kinds of struct types are supported:
@@ -389,9 +389,9 @@ class StructType
ArrayRef<MemberDecorationInfo> memberDecorations = {});
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
};
llvm::hash_code
@@ -416,9 +416,9 @@ class CooperativeMatrixNVType
unsigned getColumns() const;
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
};
// SPIR-V joint matrix type
@@ -443,9 +443,9 @@ class JointMatrixINTELType
MatrixLayout getMatrixLayout() const;
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
};
// SPIR-V matrix type
@@ -480,9 +480,9 @@ class MatrixType : public Type::TypeBase<MatrixType, CompositeType,
Type getElementType() const;
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
- Optional<StorageClass> storage = llvm::None);
+ Optional<StorageClass> storage = std::nullopt);
};
} // namespace spirv
diff --git a/mlir/include/mlir/Dialect/SparseTensor/Utils/Merger.h b/mlir/include/mlir/Dialect/SparseTensor/Utils/Merger.h
index 60829fe99951..73d1c8f1bd13 100644
--- a/mlir/include/mlir/Dialect/SparseTensor/Utils/Merger.h
+++ b/mlir/include/mlir/Dialect/SparseTensor/Utils/Merger.h
@@ -174,9 +174,9 @@ class Merger {
dimTypes(numTensors,
std::vector<DimLevelType>(numLoops, DimLevelType::Undef)),
loopIdxToDim(numTensors,
- std::vector<Optional<unsigned>>(numLoops, llvm::None)),
+ std::vector<Optional<unsigned>>(numLoops, std::nullopt)),
dimToLoopIdx(numTensors,
- std::vector<Optional<unsigned>>(numLoops, llvm::None)) {}
+ std::vector<Optional<unsigned>>(numLoops, std::nullopt)) {}
/// Adds a tensor expression. Returns its index.
unsigned addExp(Kind k, unsigned e0, unsigned e1 = -1u, Value v = Value(),
diff --git a/mlir/include/mlir/Dialect/Tosa/Utils/CoversionUtils.h b/mlir/include/mlir/Dialect/Tosa/Utils/CoversionUtils.h
index 6b2104facf5e..13ead1cde4d4 100644
--- a/mlir/include/mlir/Dialect/Tosa/Utils/CoversionUtils.h
+++ b/mlir/include/mlir/Dialect/Tosa/Utils/CoversionUtils.h
@@ -68,7 +68,7 @@ Optional<SmallVector<Value>> checkHasDynamicBatchDims(PatternRewriter &rewriter,
if (llvm::any_of(dynTy.getShape().drop_front(), ShapedType::isDynamic)) {
(void)rewriter.notifyMatchFailure(
op, "input can only be dynamic for batch size");
- return llvm::None;
+ return std::nullopt;
}
}
diff --git a/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h b/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h
index b56a5dd36e77..bbcfabe754aa 100644
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h
@@ -149,7 +149,7 @@ class [[nodiscard]] DiagnosedSilenceableFailure {
/// Attaches a note to the last diagnostic.
/// Expects this object to be a silenceable failure.
- Diagnostic &attachNote(Optional<Location> loc = llvm::None) {
+ Diagnostic &attachNote(Optional<Location> loc = std::nullopt) {
assert(isSilenceableFailure() &&
"can only attach notes to silenceable failures");
return diagnostics.back().attachNote(loc);
@@ -212,7 +212,7 @@ class DiagnosedDefiniteFailure {
}
/// Attaches a note to the error.
- Diagnostic &attachNote(Optional<Location> loc = llvm::None) {
+ Diagnostic &attachNote(Optional<Location> loc = std::nullopt) {
return diag.attachNote(loc);
}
diff --git a/mlir/include/mlir/Dialect/Utils/ReshapeOpsUtils.h b/mlir/include/mlir/Dialect/Utils/ReshapeOpsUtils.h
index 760a5aab1448..bc5bbc74d8f3 100644
--- a/mlir/include/mlir/Dialect/Utils/ReshapeOpsUtils.h
+++ b/mlir/include/mlir/Dialect/Utils/ReshapeOpsUtils.h
@@ -360,14 +360,14 @@ struct ComposeExpandOfCollapseOp : public OpRewritePattern<ExpandOpTy> {
if (srcSubShape == resultSubShape)
composedReassociation.push_back(srcIndices);
else
- return llvm::None;
+ return std::nullopt;
}
// Find reassociation to collapse `srcSubShape` into `resultSubShape`.
auto subShapeReassociation =
getReassociationIndicesForCollapse(srcSubShape, resultSubShape);
if (!subShapeReassociation)
- return llvm::None;
+ return std::nullopt;
// Remap the subshape indices back to the original srcShape.
for (auto &subshape_indices : *subShapeReassociation) {
diff --git a/mlir/include/mlir/Dialect/Vector/IR/VectorOps.h b/mlir/include/mlir/Dialect/Vector/IR/VectorOps.h
index 7440d79fb002..d67d64731fe7 100644
--- a/mlir/include/mlir/Dialect/Vector/IR/VectorOps.h
+++ b/mlir/include/mlir/Dialect/Vector/IR/VectorOps.h
@@ -118,7 +118,7 @@ void populateBubbleVectorBitCastOpPatterns(RewritePatternSet &patterns,
/// VectorToSCF, which reduces the rank of vector transfer ops.
void populateVectorTransferLoweringPatterns(
RewritePatternSet &patterns,
- llvm::Optional<unsigned> maxTransferRank = llvm::None,
+ llvm::Optional<unsigned> maxTransferRank = std::nullopt,
PatternBenefit benefit = 1);
/// These patterns materialize masks for various vector ops such as transfers.
diff --git a/mlir/include/mlir/ExecutionEngine/ExecutionEngine.h b/mlir/include/mlir/ExecutionEngine/ExecutionEngine.h
index d987eef6795c..faaba1b018f6 100644
--- a/mlir/include/mlir/ExecutionEngine/ExecutionEngine.h
+++ b/mlir/include/mlir/ExecutionEngine/ExecutionEngine.h
@@ -67,7 +67,7 @@ struct ExecutionEngineOptions {
/// `jitCodeGenOptLevel`, when provided, is used as the optimization level for
/// target code generation.
- Optional<llvm::CodeGenOpt::Level> jitCodeGenOptLevel = llvm::None;
+ Optional<llvm::CodeGenOpt::Level> jitCodeGenOptLevel = std::nullopt;
/// If `sharedLibPaths` are provided, the underlying JIT-compilation will
/// open and link the shared libraries for symbol resolution.
@@ -123,7 +123,7 @@ class ExecutionEngine {
/// Invokes the function with the given name passing it the list of opaque
/// pointers to the actual arguments.
llvm::Error invokePacked(StringRef name,
- MutableArrayRef<void *> args = llvm::None);
+ MutableArrayRef<void *> args = std::nullopt);
/// Trait that defines how a given type is passed to the JIT code. This
/// defaults to passing the address but can be specialized.
diff --git a/mlir/include/mlir/IR/BlockSupport.h b/mlir/include/mlir/IR/BlockSupport.h
index 00401bd2a021..ff508891ac2f 100644
--- a/mlir/include/mlir/IR/BlockSupport.h
+++ b/mlir/include/mlir/IR/BlockSupport.h
@@ -106,7 +106,7 @@ class BlockRange final
Block *, Block *, Block *> {
public:
using RangeBaseT::RangeBaseT;
- BlockRange(ArrayRef<Block *> blocks = llvm::None);
+ BlockRange(ArrayRef<Block *> blocks = std::nullopt);
BlockRange(SuccessorRange successors);
template <typename Arg, typename = std::enable_if_t<std::is_constructible<
ArrayRef<Block *>, Arg>::value>>
diff --git a/mlir/include/mlir/IR/Builders.h b/mlir/include/mlir/IR/Builders.h
index f2a547ef4f75..f22293cab221 100644
--- a/mlir/include/mlir/IR/Builders.h
+++ b/mlir/include/mlir/IR/Builders.h
@@ -408,15 +408,15 @@ class OpBuilder : public Builder {
/// 'parent'. `locs` contains the locations of the inserted arguments, and
/// should match the size of `argTypes`.
Block *createBlock(Region *parent, Region::iterator insertPt = {},
- TypeRange argTypes = llvm::None,
- ArrayRef<Location> locs = llvm::None);
+ TypeRange argTypes = std::nullopt,
+ ArrayRef<Location> locs = std::nullopt);
/// Add new block with 'argTypes' arguments and set the insertion point to the
/// end of it. The block is placed before 'insertBefore'. `locs` contains the
/// locations of the inserted arguments, and should match the size of
/// `argTypes`.
- Block *createBlock(Block *insertBefore, TypeRange argTypes = llvm::None,
- ArrayRef<Location> locs = llvm::None);
+ Block *createBlock(Block *insertBefore, TypeRange argTypes = std::nullopt,
+ ArrayRef<Location> locs = std::nullopt);
//===--------------------------------------------------------------------===//
// Operation Creation
diff --git a/mlir/include/mlir/IR/BuiltinAttributeInterfaces.h b/mlir/include/mlir/IR/BuiltinAttributeInterfaces.h
index bd0d46867049..906414ef959a 100644
--- a/mlir/include/mlir/IR/BuiltinAttributeInterfaces.h
+++ b/mlir/include/mlir/IR/BuiltinAttributeInterfaces.h
@@ -312,7 +312,7 @@ auto ElementsAttr::try_value_begin() const
FailureOr<detail::ElementsAttrIndexer> indexer =
getValuesImpl(TypeID::get<T>());
if (failed(indexer))
- return llvm::None;
+ return std::nullopt;
return iterator<T>(std::move(*indexer), 0);
}
} // namespace mlir.
diff --git a/mlir/include/mlir/IR/Diagnostics.h b/mlir/include/mlir/IR/Diagnostics.h
index 58abb0c94ca2..af3bafa0028e 100644
--- a/mlir/include/mlir/IR/Diagnostics.h
+++ b/mlir/include/mlir/IR/Diagnostics.h
@@ -244,7 +244,7 @@ class Diagnostic {
/// Attaches a note to this diagnostic. A new location may be optionally
/// provided, if not, then the location defaults to the one specified for this
/// diagnostic. Notes may not be attached to other notes.
- Diagnostic &attachNote(Optional<Location> noteLoc = llvm::None);
+ Diagnostic &attachNote(Optional<Location> noteLoc = std::nullopt);
using note_iterator = llvm::pointee_iterator<NoteVector::iterator>;
using const_note_iterator =
@@ -342,7 +342,7 @@ class InFlightDiagnostic {
}
/// Attaches a note to this diagnostic.
- Diagnostic &attachNote(Optional<Location> noteLoc = llvm::None) {
+ Diagnostic &attachNote(Optional<Location> noteLoc = std::nullopt) {
assert(isActive() && "diagnostic not active");
return impl->attachNote(noteLoc);
}
diff --git a/mlir/include/mlir/IR/DialectImplementation.h b/mlir/include/mlir/IR/DialectImplementation.h
index ab5d6dcbb597..7e4899618066 100644
--- a/mlir/include/mlir/IR/DialectImplementation.h
+++ b/mlir/include/mlir/IR/DialectImplementation.h
@@ -118,7 +118,7 @@ struct FieldParser<
return {Optional<IntT>(value)};
return failure();
}
- return {llvm::None};
+ return {std::nullopt};
}
};
diff --git a/mlir/include/mlir/IR/FunctionInterfaces.h b/mlir/include/mlir/IR/FunctionInterfaces.h
index 69a54390fcf5..23fd884d97f1 100644
--- a/mlir/include/mlir/IR/FunctionInterfaces.h
+++ b/mlir/include/mlir/IR/FunctionInterfaces.h
@@ -62,13 +62,13 @@ void setAllResultAttrDicts(Operation *op, ArrayRef<Attribute> attrs);
/// Return all of the attributes for the argument at 'index'.
inline ArrayRef<NamedAttribute> getArgAttrs(Operation *op, unsigned index) {
auto argDict = getArgAttrDict(op, index);
- return argDict ? argDict.getValue() : llvm::None;
+ return argDict ? argDict.getValue() : std::nullopt;
}
/// Return all of the attributes for the result at 'index'.
inline ArrayRef<NamedAttribute> getResultAttrs(Operation *op, unsigned index) {
auto resultDict = getResultAttrDict(op, index);
- return resultDict ? resultDict.getValue() : llvm::None;
+ return resultDict ? resultDict.getValue() : std::nullopt;
}
/// Insert the specified arguments and update the function type attribute.
diff --git a/mlir/include/mlir/IR/Matchers.h b/mlir/include/mlir/IR/Matchers.h
index b2edcabf8785..78e5099358cb 100644
--- a/mlir/include/mlir/IR/Matchers.h
+++ b/mlir/include/mlir/IR/Matchers.h
@@ -77,7 +77,7 @@ struct constant_op_binder {
// Fold the constant to an attribute.
SmallVector<OpFoldResult, 1> foldedOp;
- LogicalResult result = op->fold(/*operands=*/llvm::None, foldedOp);
+ LogicalResult result = op->fold(/*operands=*/std::nullopt, foldedOp);
(void)result;
assert(succeeded(result) && "expected ConstantLike op to be foldable");
diff --git a/mlir/include/mlir/IR/OpDefinition.h b/mlir/include/mlir/IR/OpDefinition.h
index 864affd9a6af..72950670c8f9 100644
--- a/mlir/include/mlir/IR/OpDefinition.h
+++ b/mlir/include/mlir/IR/OpDefinition.h
@@ -41,7 +41,7 @@ class OptionalParseResult {
OptionalParseResult(ParseResult result) : impl(result) {}
OptionalParseResult(const InFlightDiagnostic &)
: OptionalParseResult(failure()) {}
- OptionalParseResult(std::nullopt_t) : impl(llvm::None) {}
+ OptionalParseResult(std::nullopt_t) : impl(std::nullopt) {}
/// Returns true if we contain a valid ParseResult value.
bool has_value() const { return impl.has_value(); }
@@ -94,7 +94,7 @@ class OpState {
MLIRContext *getContext() { return getOperation()->getContext(); }
/// Print the operation to the given stream.
- void print(raw_ostream &os, OpPrintingFlags flags = llvm::None) {
+ void print(raw_ostream &os, OpPrintingFlags flags = std::nullopt) {
state->print(os, flags);
}
void print(raw_ostream &os, AsmState &asmState) {
diff --git a/mlir/include/mlir/IR/OpImplementation.h b/mlir/include/mlir/IR/OpImplementation.h
index e517794dd1bd..913d65e68d04 100644
--- a/mlir/include/mlir/IR/OpImplementation.h
+++ b/mlir/include/mlir/IR/OpImplementation.h
@@ -1334,12 +1334,12 @@ class OpAsmParser : public AsmParser {
/// skip parsing that component.
virtual ParseResult parseGenericOperationAfterOpName(
OperationState &result,
- Optional<ArrayRef<UnresolvedOperand>> parsedOperandType = llvm::None,
- Optional<ArrayRef<Block *>> parsedSuccessors = llvm::None,
+ Optional<ArrayRef<UnresolvedOperand>> parsedOperandType = std::nullopt,
+ Optional<ArrayRef<Block *>> parsedSuccessors = std::nullopt,
Optional<MutableArrayRef<std::unique_ptr<Region>>> parsedRegions =
- llvm::None,
- Optional<ArrayRef<NamedAttribute>> parsedAttributes = llvm::None,
- Optional<FunctionType> parsedFnType = llvm::None) = 0;
+ std::nullopt,
+ Optional<ArrayRef<NamedAttribute>> parsedAttributes = std::nullopt,
+ Optional<FunctionType> parsedFnType = std::nullopt) = 0;
/// Parse a single SSA value operand name along with a result number if
/// `allowResultNumber` is true.
diff --git a/mlir/include/mlir/IR/Operation.h b/mlir/include/mlir/IR/Operation.h
index 2b87dca6578e..6ac6c0b0ba65 100644
--- a/mlir/include/mlir/IR/Operation.h
+++ b/mlir/include/mlir/IR/Operation.h
@@ -240,7 +240,7 @@ class alignas(8) Operation final
/// take O(N) where N is the number of operations within the parent block.
bool isBeforeInBlock(Operation *other);
- void print(raw_ostream &os, const OpPrintingFlags &flags = llvm::None);
+ void print(raw_ostream &os, const OpPrintingFlags &flags = std::nullopt);
void print(raw_ostream &os, AsmState &state);
void dump();
diff --git a/mlir/include/mlir/IR/OperationSupport.h b/mlir/include/mlir/IR/OperationSupport.h
index c64dbdb68efe..576a4ecc6f49 100644
--- a/mlir/include/mlir/IR/OperationSupport.h
+++ b/mlir/include/mlir/IR/OperationSupport.h
@@ -88,7 +88,7 @@ class OperationName {
/// may not be populated.
struct Impl {
Impl(StringAttr name)
- : name(name), dialect(nullptr), interfaceMap(llvm::None) {}
+ : name(name), dialect(nullptr), interfaceMap(std::nullopt) {}
/// The name of the operation.
StringAttr name;
diff --git a/mlir/include/mlir/IR/PatternMatch.h b/mlir/include/mlir/IR/PatternMatch.h
index 7b05a2d61e90..e59ec8d73b7a 100644
--- a/mlir/include/mlir/IR/PatternMatch.h
+++ b/mlir/include/mlir/IR/PatternMatch.h
@@ -92,7 +92,7 @@ class Pattern {
Optional<OperationName> getRootKind() const {
if (rootKind == RootKind::OperationName)
return OperationName::getFromOpaquePointer(rootValue);
- return llvm::None;
+ return std::nullopt;
}
/// Return the interface ID used to match the root operation of this pattern.
@@ -101,7 +101,7 @@ class Pattern {
Optional<TypeID> getRootInterfaceID() const {
if (rootKind == RootKind::InterfaceID)
return TypeID::getFromOpaquePointer(rootValue);
- return llvm::None;
+ return std::nullopt;
}
/// Return the trait ID used to match the root operation of this pattern.
@@ -110,7 +110,7 @@ class Pattern {
Optional<TypeID> getRootTraitID() const {
if (rootKind == RootKind::TraitID)
return TypeID::getFromOpaquePointer(rootValue);
- return llvm::None;
+ return std::nullopt;
}
/// Return the benefit (the inverse of "cost") of matching this pattern. The
@@ -465,12 +465,12 @@ class RewriterBase : public OpBuilder, public OpBuilder::Listener {
/// 'argValues' is used to replace the block arguments of 'source' after
/// merging.
virtual void mergeBlocks(Block *source, Block *dest,
- ValueRange argValues = llvm::None);
+ ValueRange argValues = std::nullopt);
// Merge the operations of block 'source' before the operation 'op'. Source
// block should not have existing predecessors or successors.
void mergeBlockBefore(Block *source, Operation *op,
- ValueRange argValues = llvm::None);
+ ValueRange argValues = std::nullopt);
/// Split the operations starting at "before" (inclusive) out of the given
/// block into a new block, and return it.
@@ -1587,7 +1587,8 @@ class RewritePatternSet {
RewritePatternSet &add(ConstructorArg &&arg, ConstructorArgs &&...args) {
// The following expands a call to emplace_back for each of the pattern
// types 'Ts'.
- (addImpl<Ts>(/*debugLabels=*/llvm::None, std::forward<ConstructorArg>(arg),
+ (addImpl<Ts>(/*debugLabels=*/std::nullopt,
+ std::forward<ConstructorArg>(arg),
std::forward<ConstructorArgs>(args)...),
...);
return *this;
@@ -1666,7 +1667,7 @@ class RewritePatternSet {
RewritePatternSet &insert(ConstructorArg &&arg, ConstructorArgs &&...args) {
// The following expands a call to emplace_back for each of the pattern
// types 'Ts'.
- (addImpl<Ts>(/*debugLabels=*/llvm::None, arg, args...), ...);
+ (addImpl<Ts>(/*debugLabels=*/std::nullopt, arg, args...), ...);
return *this;
}
diff --git a/mlir/include/mlir/IR/Region.h b/mlir/include/mlir/IR/Region.h
index 25080fab64b2..f5168138056a 100644
--- a/mlir/include/mlir/IR/Region.h
+++ b/mlir/include/mlir/IR/Region.h
@@ -338,7 +338,7 @@ class RegionRange
public:
using RangeBaseT::RangeBaseT;
- RegionRange(MutableArrayRef<Region> regions = llvm::None);
+ RegionRange(MutableArrayRef<Region> regions = std::nullopt);
template <typename Arg, typename = std::enable_if_t<std::is_constructible<
ArrayRef<std::unique_ptr<Region>>, Arg>::value>>
diff --git a/mlir/include/mlir/IR/SymbolTable.h b/mlir/include/mlir/IR/SymbolTable.h
index a24693575f03..7e7d31cc1bdd 100644
--- a/mlir/include/mlir/IR/SymbolTable.h
+++ b/mlir/include/mlir/IR/SymbolTable.h
@@ -301,7 +301,7 @@ class SymbolUserMap {
/// Return the users of the provided symbol operation.
ArrayRef<Operation *> getUsers(Operation *symbol) const {
auto it = symbolToUsers.find(symbol);
- return it != symbolToUsers.end() ? it->second.getArrayRef() : llvm::None;
+ return it != symbolToUsers.end() ? it->second.getArrayRef() : std::nullopt;
}
/// Return true if the given symbol has no uses.
diff --git a/mlir/include/mlir/IR/TypeRange.h b/mlir/include/mlir/IR/TypeRange.h
index 7f65707e9872..b8215a80cb6f 100644
--- a/mlir/include/mlir/IR/TypeRange.h
+++ b/mlir/include/mlir/IR/TypeRange.h
@@ -36,7 +36,7 @@ class TypeRange : public llvm::detail::indexed_accessor_range_base<
Type, Type, Type> {
public:
using RangeBaseT::RangeBaseT;
- TypeRange(ArrayRef<Type> types = llvm::None);
+ TypeRange(ArrayRef<Type> types = std::nullopt);
explicit TypeRange(OperandRange values);
explicit TypeRange(ResultRange values);
explicit TypeRange(ValueRange values);
diff --git a/mlir/include/mlir/IR/ValueRange.h b/mlir/include/mlir/IR/ValueRange.h
index 081c0d2210de..b09301e2b79b 100644
--- a/mlir/include/mlir/IR/ValueRange.h
+++ b/mlir/include/mlir/IR/ValueRange.h
@@ -122,13 +122,13 @@ class MutableOperandRange {
/// and range length. `operandSegments` is an optional set of operand segments
/// to be updated when mutating the operand list.
MutableOperandRange(Operation *owner, unsigned start, unsigned length,
- ArrayRef<OperandSegment> operandSegments = llvm::None);
+ ArrayRef<OperandSegment> operandSegments = std::nullopt);
MutableOperandRange(Operation *owner);
/// Slice this range into a sub range, with the additional operand segment.
MutableOperandRange
slice(unsigned subStart, unsigned subLen,
- Optional<OperandSegment> segment = llvm::None) const;
+ Optional<OperandSegment> segment = std::nullopt) const;
/// Append the given values to the range.
void append(ValueRange values);
@@ -369,7 +369,7 @@ class ValueRange final
: ValueRange(ResultRange(values)) {}
ValueRange(ArrayRef<BlockArgument> values)
: ValueRange(ArrayRef<Value>(values.data(), values.size())) {}
- ValueRange(ArrayRef<Value> values = llvm::None);
+ ValueRange(ArrayRef<Value> values = std::nullopt);
ValueRange(OperandRange values);
ValueRange(ResultRange values);
diff --git a/mlir/include/mlir/Interfaces/ControlFlowInterfaces.h b/mlir/include/mlir/Interfaces/ControlFlowInterfaces.h
index 88c94a83aeb3..416fcc354cdb 100644
--- a/mlir/include/mlir/Interfaces/ControlFlowInterfaces.h
+++ b/mlir/include/mlir/Interfaces/ControlFlowInterfaces.h
@@ -202,7 +202,7 @@ class InvocationBounds {
/// Returns the unknown invocation bounds, i.e., there is no information on
/// how many times a region may be invoked.
- static InvocationBounds getUnknown() { return {0, llvm::None}; }
+ static InvocationBounds getUnknown() { return {0, std::nullopt}; }
private:
/// The minimum number of times the successor region will be invoked.
diff --git a/mlir/include/mlir/Pass/AnalysisManager.h b/mlir/include/mlir/Pass/AnalysisManager.h
index 41ecd8a30680..04fc88a6480c 100644
--- a/mlir/include/mlir/Pass/AnalysisManager.h
+++ b/mlir/include/mlir/Pass/AnalysisManager.h
@@ -171,7 +171,7 @@ class AnalysisMap {
Optional<std::reference_wrapper<AnalysisT>> getCachedAnalysis() const {
auto res = analyses.find(TypeID::get<AnalysisT>());
if (res == analyses.end())
- return llvm::None;
+ return std::nullopt;
return {static_cast<AnalysisModel<AnalysisT> &>(*res->second).analysis};
}
@@ -309,7 +309,7 @@ class AnalysisManager {
return parentAM->analyses.getCachedAnalysis<AnalysisT>();
curParent = parentAM;
}
- return None;
+ return std::nullopt;
}
/// Query for the given analysis for the current operation.
@@ -352,7 +352,7 @@ class AnalysisManager {
assert(op->getParentOp() == impl->getOperation());
auto it = impl->childAnalyses.find(op);
if (it == impl->childAnalyses.end())
- return llvm::None;
+ return std::nullopt;
return it->second->analyses.getCachedAnalysis<AnalysisT>();
}
diff --git a/mlir/include/mlir/Pass/Pass.h b/mlir/include/mlir/Pass/Pass.h
index 45dc8188cba0..5953e9d02493 100644
--- a/mlir/include/mlir/Pass/Pass.h
+++ b/mlir/include/mlir/Pass/Pass.h
@@ -159,7 +159,7 @@ class Pass {
}
protected:
- explicit Pass(TypeID passID, Optional<StringRef> opName = llvm::None)
+ explicit Pass(TypeID passID, Optional<StringRef> opName = std::nullopt)
: passID(passID), opName(opName) {}
Pass(const Pass &other) : Pass(other.passID, other.opName) {}
diff --git a/mlir/include/mlir/Pass/PassOptions.h b/mlir/include/mlir/Pass/PassOptions.h
index 67c785c3633c..d32c3de42751 100644
--- a/mlir/include/mlir/Pass/PassOptions.h
+++ b/mlir/include/mlir/Pass/PassOptions.h
@@ -122,7 +122,7 @@ class PassOptions : protected llvm::cl::SubCommand {
for (auto &it : this->Values)
if (it.V.compare(value))
return it.Name;
- return llvm::None;
+ return std::nullopt;
}
};
diff --git a/mlir/include/mlir/Rewrite/FrozenRewritePatternSet.h b/mlir/include/mlir/Rewrite/FrozenRewritePatternSet.h
index 7627fd0145eb..4c6e3cd9ce6f 100644
--- a/mlir/include/mlir/Rewrite/FrozenRewritePatternSet.h
+++ b/mlir/include/mlir/Rewrite/FrozenRewritePatternSet.h
@@ -49,8 +49,8 @@ class FrozenRewritePatternSet {
/// their type name.
FrozenRewritePatternSet(
RewritePatternSet &&patterns,
- ArrayRef<std::string> disabledPatternLabels = llvm::None,
- ArrayRef<std::string> enabledPatternLabels = llvm::None);
+ ArrayRef<std::string> disabledPatternLabels = std::nullopt,
+ ArrayRef<std::string> enabledPatternLabels = std::nullopt);
/// Return the op specific native patterns held by this list.
const OpSpecificNativePatternListT &getOpSpecificNativePatterns() const {
diff --git a/mlir/include/mlir/Support/StorageUniquer.h b/mlir/include/mlir/Support/StorageUniquer.h
index 0ef645393b20..13359bf91f40 100644
--- a/mlir/include/mlir/Support/StorageUniquer.h
+++ b/mlir/include/mlir/Support/StorageUniquer.h
@@ -97,7 +97,7 @@ class StorageUniquer {
template <typename T>
ArrayRef<T> copyInto(ArrayRef<T> elements) {
if (elements.empty())
- return llvm::None;
+ return std::nullopt;
auto result = allocator.Allocate<T>(elements.size());
std::uninitialized_copy(elements.begin(), elements.end(), result);
return ArrayRef<T>(result, elements.size());
@@ -178,7 +178,7 @@ class StorageUniquer {
}
template <typename Storage>
void registerSingletonStorageType(TypeID id) {
- registerSingletonStorageType<Storage>(id, llvm::None);
+ registerSingletonStorageType<Storage>(id, std::nullopt);
}
/// Utility override when the storage type represents the type id.
template <typename Storage>
diff --git a/mlir/include/mlir/TableGen/Operator.h b/mlir/include/mlir/TableGen/Operator.h
index 5adb8e3fbd35..4515dc3bf4ba 100644
--- a/mlir/include/mlir/TableGen/Operator.h
+++ b/mlir/include/mlir/TableGen/Operator.h
@@ -259,9 +259,9 @@ class Operator {
// Pair representing either a index to an argument or a type constraint. Only
// one of these entries should have the non-default value.
struct ArgOrType {
- explicit ArgOrType(int index) : index(index), constraint(None) {}
+ explicit ArgOrType(int index) : index(index), constraint(std::nullopt) {}
explicit ArgOrType(TypeConstraint constraint)
- : index(None), constraint(constraint) {}
+ : index(std::nullopt), constraint(constraint) {}
bool isArg() const {
assert(constraint.has_value() ^ index.has_value());
return index.has_value();
diff --git a/mlir/include/mlir/TableGen/Pattern.h b/mlir/include/mlir/TableGen/Pattern.h
index 656cfcb0f5c9..bdd01ed8a367 100644
--- a/mlir/include/mlir/TableGen/Pattern.h
+++ b/mlir/include/mlir/TableGen/Pattern.h
@@ -291,17 +291,17 @@ class SymbolInfoMap {
return SymbolInfo(op, Kind::Attr, DagAndConstant(nullptr, index));
}
static SymbolInfo getAttr() {
- return SymbolInfo(nullptr, Kind::Attr, llvm::None);
+ return SymbolInfo(nullptr, Kind::Attr, std::nullopt);
}
static SymbolInfo getOperand(DagNode node, const Operator *op, int index) {
return SymbolInfo(op, Kind::Operand,
DagAndConstant(node.getAsOpaquePointer(), index));
}
static SymbolInfo getResult(const Operator *op) {
- return SymbolInfo(op, Kind::Result, llvm::None);
+ return SymbolInfo(op, Kind::Result, std::nullopt);
}
static SymbolInfo getValue() {
- return SymbolInfo(nullptr, Kind::Value, llvm::None);
+ return SymbolInfo(nullptr, Kind::Value, std::nullopt);
}
static SymbolInfo getMultipleValues(int numValues) {
return SymbolInfo(nullptr, Kind::MultipleValues,
diff --git a/mlir/include/mlir/Tools/PDLL/AST/Diagnostic.h b/mlir/include/mlir/Tools/PDLL/AST/Diagnostic.h
index bb365faea690..c68c62129941 100644
--- a/mlir/include/mlir/Tools/PDLL/AST/Diagnostic.h
+++ b/mlir/include/mlir/Tools/PDLL/AST/Diagnostic.h
@@ -44,7 +44,7 @@ class Diagnostic {
/// Attach a note to this diagnostic.
Diagnostic &attachNote(const Twine &msg,
- Optional<SMRange> noteLoc = llvm::None) {
+ Optional<SMRange> noteLoc = std::nullopt) {
assert(getSeverity() != Severity::DK_Note &&
"cannot attach a Note to a Note");
notes.emplace_back(
diff --git a/mlir/include/mlir/Tools/PDLL/AST/Nodes.h b/mlir/include/mlir/Tools/PDLL/AST/Nodes.h
index 2281115ddddd..9f958c59421d 100644
--- a/mlir/include/mlir/Tools/PDLL/AST/Nodes.h
+++ b/mlir/include/mlir/Tools/PDLL/AST/Nodes.h
@@ -886,8 +886,8 @@ class UserConstraintDecl final
ArrayRef<VariableDecl *> results,
const CompoundStmt *body,
Type resultType) {
- return createImpl(ctx, name, inputs, /*nativeInputTypes=*/llvm::None,
- results, /*codeBlock=*/llvm::None, body, resultType);
+ return createImpl(ctx, name, inputs, /*nativeInputTypes=*/std::nullopt,
+ results, /*codeBlock=*/std::nullopt, body, resultType);
}
/// Return the name of the constraint.
@@ -1008,7 +1008,7 @@ class OpNameDecl : public Node::NodeBase<OpNameDecl, Decl> {
/// Return the name of this operation, or none if the name is unknown.
Optional<StringRef> getName() const {
const Name *name = Decl::getName();
- return name ? Optional<StringRef>(name->getName()) : llvm::None;
+ return name ? Optional<StringRef>(name->getName()) : std::nullopt;
}
private:
@@ -1093,7 +1093,7 @@ class UserRewriteDecl final
ArrayRef<VariableDecl *> results,
const CompoundStmt *body,
Type resultType) {
- return createImpl(ctx, name, inputs, results, /*codeBlock=*/llvm::None,
+ return createImpl(ctx, name, inputs, results, /*codeBlock=*/std::nullopt,
body, resultType);
}
diff --git a/mlir/include/mlir/Tools/PDLL/AST/Types.h b/mlir/include/mlir/Tools/PDLL/AST/Types.h
index 894e1fbb0da0..d51f3290e638 100644
--- a/mlir/include/mlir/Tools/PDLL/AST/Types.h
+++ b/mlir/include/mlir/Tools/PDLL/AST/Types.h
@@ -161,7 +161,7 @@ class OperationType : public Type::TypeBase<detail::OperationTypeStorage> {
/// Return an instance of the Operation type with an optional operation name.
/// If no name is provided, this type may refer to any operation.
static OperationType get(Context &context,
- Optional<StringRef> name = llvm::None,
+ Optional<StringRef> name = std::nullopt,
const ods::Operation *odsOp = nullptr);
/// Return the name of this operation type, or None if it doesn't have on.
@@ -247,7 +247,7 @@ class TupleType : public Type::TypeBase<detail::TupleTypeStorage> {
static TupleType get(Context &context, ArrayRef<Type> elementTypes,
ArrayRef<StringRef> elementNames);
static TupleType get(Context &context,
- ArrayRef<Type> elementTypes = llvm::None);
+ ArrayRef<Type> elementTypes = std::nullopt);
/// Return the element types of this tuple.
ArrayRef<Type> getElementTypes() const;
diff --git a/mlir/include/mlir/Tools/mlir-translate/Translation.h b/mlir/include/mlir/Tools/mlir-translate/Translation.h
index 80c4e37f47ca..0fe6fdc89d88 100644
--- a/mlir/include/mlir/Tools/mlir-translate/Translation.h
+++ b/mlir/include/mlir/Tools/mlir-translate/Translation.h
@@ -100,11 +100,11 @@ struct TranslateToMLIRRegistration {
TranslateToMLIRRegistration(
llvm::StringRef name, llvm::StringRef description,
const TranslateSourceMgrToMLIRFunction &function,
- Optional<llvm::Align> inputAlignment = llvm::None);
+ Optional<llvm::Align> inputAlignment = std::nullopt);
TranslateToMLIRRegistration(
llvm::StringRef name, llvm::StringRef description,
const TranslateStringRefToMLIRFunction &function,
- Optional<llvm::Align> inputAlignment = llvm::None);
+ Optional<llvm::Align> inputAlignment = std::nullopt);
};
struct TranslateFromMLIRRegistration {
diff --git a/mlir/include/mlir/Transforms/DialectConversion.h b/mlir/include/mlir/Transforms/DialectConversion.h
index 59809492d836..55665b56f2fe 100644
--- a/mlir/include/mlir/Transforms/DialectConversion.h
+++ b/mlir/include/mlir/Transforms/DialectConversion.h
@@ -284,7 +284,7 @@ class TypeConverter {
ArrayRef<Type> callStack) -> Optional<LogicalResult> {
T derivedType = type.dyn_cast<T>();
if (!derivedType)
- return llvm::None;
+ return std::nullopt;
return callback(derivedType, results, callStack);
};
}
@@ -306,7 +306,7 @@ class TypeConverter {
Location loc) -> Optional<Value> {
if (T derivedType = resultType.dyn_cast<T>())
return callback(builder, derivedType, inputs, loc);
- return llvm::None;
+ return std::nullopt;
};
}
diff --git a/mlir/include/mlir/Transforms/InliningUtils.h b/mlir/include/mlir/Transforms/InliningUtils.h
index 880de15f1a4b..99891016e8d0 100644
--- a/mlir/include/mlir/Transforms/InliningUtils.h
+++ b/mlir/include/mlir/Transforms/InliningUtils.h
@@ -208,14 +208,14 @@ LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
Operation *inlinePoint, BlockAndValueMapping &mapper,
ValueRange resultsToReplace,
TypeRange regionResultTypes,
- Optional<Location> inlineLoc = llvm::None,
+ Optional<Location> inlineLoc = std::nullopt,
bool shouldCloneInlinedRegion = true);
LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
Block *inlineBlock, Block::iterator inlinePoint,
BlockAndValueMapping &mapper,
ValueRange resultsToReplace,
TypeRange regionResultTypes,
- Optional<Location> inlineLoc = llvm::None,
+ Optional<Location> inlineLoc = std::nullopt,
bool shouldCloneInlinedRegion = true);
/// This function is an overload of the above 'inlineRegion' that allows for
@@ -224,13 +224,13 @@ LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
Operation *inlinePoint, ValueRange inlinedOperands,
ValueRange resultsToReplace,
- Optional<Location> inlineLoc = llvm::None,
+ Optional<Location> inlineLoc = std::nullopt,
bool shouldCloneInlinedRegion = true);
LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
Block *inlineBlock, Block::iterator inlinePoint,
ValueRange inlinedOperands,
ValueRange resultsToReplace,
- Optional<Location> inlineLoc = llvm::None,
+ Optional<Location> inlineLoc = std::nullopt,
bool shouldCloneInlinedRegion = true);
/// This function inlines a given region, 'src', of a callable operation,
diff --git a/mlir/include/mlir/Transforms/Passes.h b/mlir/include/mlir/Transforms/Passes.h
index 9f3daaa8cf4f..9d800c37db3b 100644
--- a/mlir/include/mlir/Transforms/Passes.h
+++ b/mlir/include/mlir/Transforms/Passes.h
@@ -55,8 +55,8 @@ std::unique_ptr<Pass> createCanonicalizerPass();
/// set to their type name.
std::unique_ptr<Pass>
createCanonicalizerPass(const GreedyRewriteConfig &config,
- ArrayRef<std::string> disabledPatterns = llvm::None,
- ArrayRef<std::string> enabledPatterns = llvm::None);
+ ArrayRef<std::string> disabledPatterns = std::nullopt,
+ ArrayRef<std::string> enabledPatterns = std::nullopt);
/// Creates a pass to perform control-flow sinking.
std::unique_ptr<Pass> createControlFlowSinkPass();
diff --git a/mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp b/mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp
index b529b075fa34..caefd1c77962 100644
--- a/mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp
+++ b/mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp
@@ -70,7 +70,7 @@ static void collectUnderlyingAddressValues(RegionBranchOpInterface branch,
}
return inputIndex - firstInputIndex;
}
- return llvm::None;
+ return std::nullopt;
};
// Check branches from the parent operation.
@@ -80,7 +80,7 @@ static void collectUnderlyingAddressValues(RegionBranchOpInterface branch,
regionIndex = region->getRegionNumber();
}
if (Optional<unsigned> operandIndex =
- getOperandIndexIfPred(/*predIndex=*/llvm::None)) {
+ getOperandIndexIfPred(/*predIndex=*/std::nullopt)) {
collectUnderlyingAddressValues(
branch.getSuccessorEntryOperands(regionIndex)[*operandIndex], maxDepth,
visited, output);
diff --git a/mlir/lib/Analysis/DataFlow/SparseAnalysis.cpp b/mlir/lib/Analysis/DataFlow/SparseAnalysis.cpp
index 6bddb84f2dde..1ea60b45700c 100644
--- a/mlir/lib/Analysis/DataFlow/SparseAnalysis.cpp
+++ b/mlir/lib/Analysis/DataFlow/SparseAnalysis.cpp
@@ -95,7 +95,8 @@ void AbstractSparseDataFlowAnalysis::visitOperation(Operation *op) {
// The results of a region branch operation are determined by control-flow.
if (auto branch = dyn_cast<RegionBranchOpInterface>(op)) {
return visitRegionSuccessors({branch}, branch,
- /*successorIndex=*/llvm::None, resultLattices);
+ /*successorIndex=*/std::nullopt,
+ resultLattices);
}
// The results of a call operation are determined by the callgraph.
diff --git a/mlir/lib/Analysis/Presburger/IntegerRelation.cpp b/mlir/lib/Analysis/Presburger/IntegerRelation.cpp
index 237061f7683b..9186f920fdc6 100644
--- a/mlir/lib/Analysis/Presburger/IntegerRelation.cpp
+++ b/mlir/lib/Analysis/Presburger/IntegerRelation.cpp
@@ -1405,7 +1405,7 @@ Optional<MPInt> IntegerRelation::getConstantBoundOnDimSize(
// representation of the local vars.
if (!std::all_of(eq.begin() + getNumDimAndSymbolVars(), eq.end() - 1,
[](const MPInt &coeff) { return coeff == 0; }))
- return None;
+ return std::nullopt;
// This variable can only take a single value.
if (lb) {
@@ -1442,7 +1442,7 @@ Optional<MPInt> IntegerRelation::getConstantBoundOnDimSize(
}
if (r == e)
// If it doesn't, there isn't a bound on it.
- return None;
+ return std::nullopt;
// Positions of constraints that are lower/upper bounds on the variable.
SmallVector<unsigned, 4> lbIndices, ubIndices;
@@ -1477,7 +1477,7 @@ Optional<MPInt> IntegerRelation::getConstantBoundOnDimSize(
atIneq(lbPos, pos));
// This bound is non-negative by definition.
diff = std::max<MPInt>(
diff , MPInt(0));
- if (minDiff == None ||
diff < minDiff) {
+ if (minDiff == std::nullopt ||
diff < minDiff) {
minDiff =
diff ;
minLbPosition = lbPos;
minUbPosition = ubPos;
@@ -1536,7 +1536,7 @@ IntegerRelation::computeConstantLowerOrUpperBound(unsigned pos) {
}
if (r == e)
// If it doesn't, there isn't a bound on it.
- return None;
+ return std::nullopt;
Optional<MPInt> minOrMaxConst;
@@ -1563,10 +1563,10 @@ IntegerRelation::computeConstantLowerOrUpperBound(unsigned pos) {
isLower ? ceilDiv(-atIneq(r, getNumCols() - 1), atIneq(r, 0))
: floorDiv(atIneq(r, getNumCols() - 1), -atIneq(r, 0));
if (isLower) {
- if (minOrMaxConst == None || boundConst > minOrMaxConst)
+ if (minOrMaxConst == std::nullopt || boundConst > minOrMaxConst)
minOrMaxConst = boundConst;
} else {
- if (minOrMaxConst == None || boundConst < minOrMaxConst)
+ if (minOrMaxConst == std::nullopt || boundConst < minOrMaxConst)
minOrMaxConst = boundConst;
}
}
@@ -1589,7 +1589,7 @@ Optional<MPInt> IntegerRelation::getConstantBound(BoundType type,
Optional<MPInt> ub =
IntegerRelation(*this)
.computeConstantLowerOrUpperBound</*isLower=*/false>(pos);
- return (lb && ub && *lb == *ub) ? Optional<MPInt>(*ub) : None;
+ return (lb && ub && *lb == *ub) ? Optional<MPInt>(*ub) : std::nullopt;
}
// A simple (naive and conservative) check for hyper-rectangularity.
diff --git a/mlir/lib/Analysis/Presburger/PWMAFunction.cpp b/mlir/lib/Analysis/Presburger/PWMAFunction.cpp
index 7dc1a804111b..fe494fc798e5 100644
--- a/mlir/lib/Analysis/Presburger/PWMAFunction.cpp
+++ b/mlir/lib/Analysis/Presburger/PWMAFunction.cpp
@@ -430,5 +430,5 @@ PWMAFunction::valueAt(ArrayRef<MPInt> point) const {
for (const Piece &piece : pieces)
if (piece.domain.containsPoint(point))
return piece.output.valueAt(point);
- return None;
+ return std::nullopt;
}
diff --git a/mlir/lib/Analysis/Presburger/PresburgerRelation.cpp b/mlir/lib/Analysis/Presburger/PresburgerRelation.cpp
index df086012c8d6..09710bd33b6f 100644
--- a/mlir/lib/Analysis/Presburger/PresburgerRelation.cpp
+++ b/mlir/lib/Analysis/Presburger/PresburgerRelation.cpp
@@ -369,7 +369,7 @@ static PresburgerRelation getSetDifference(IntegerRelation b,
unsigned simplexSnapshot = simplex.getSnapshot();
IntegerRelation::CountsSnapshot bCounts = b.getCounts();
frames.push_back(Frame{simplexSnapshot, bCounts, sI, ineqsToProcess,
- /*lastIneqProcessed=*/llvm::None});
+ /*lastIneqProcessed=*/std::nullopt});
// We have completed the initial setup for this level.
// Fallthrough to the main recursive part below.
}
diff --git a/mlir/lib/Analysis/Presburger/Utils.cpp b/mlir/lib/Analysis/Presburger/Utils.cpp
index 5da3e7a0c81f..eef4ae5616e3 100644
--- a/mlir/lib/Analysis/Presburger/Utils.cpp
+++ b/mlir/lib/Analysis/Presburger/Utils.cpp
@@ -381,7 +381,7 @@ SmallVector<Optional<MPInt>, 4>
DivisionRepr::divValuesAt(ArrayRef<MPInt> point) const {
assert(point.size() == getNumNonDivs() && "Incorrect point size");
- SmallVector<Optional<MPInt>, 4> divValues(getNumDivs(), None);
+ SmallVector<Optional<MPInt>, 4> divValues(getNumDivs(), std::nullopt);
bool changed = true;
while (changed) {
changed = false;
diff --git a/mlir/lib/AsmParser/AttributeParser.cpp b/mlir/lib/AsmParser/AttributeParser.cpp
index 418dc7b71781..cec129ac66b7 100644
--- a/mlir/lib/AsmParser/AttributeParser.cpp
+++ b/mlir/lib/AsmParser/AttributeParser.cpp
@@ -357,7 +357,7 @@ static Optional<APInt> buildAttributeAPInt(Type type, bool isNegative,
APInt result;
bool isHex = spelling.size() > 1 && spelling[1] == 'x';
if (spelling.getAsInteger(isHex ? 0 : 10, result))
- return llvm::None;
+ return std::nullopt;
// Extend or truncate the bitwidth to the right size.
unsigned width = type.isIndex() ? IndexType::kInternalStorageBitWidth
@@ -369,7 +369,7 @@ static Optional<APInt> buildAttributeAPInt(Type type, bool isNegative,
// The parser can return an unnecessarily wide result with leading zeros.
// This isn't a problem, but truncating off bits is bad.
if (result.countLeadingZeros() < result.getBitWidth() - width)
- return llvm::None;
+ return std::nullopt;
result = result.trunc(width);
}
@@ -378,18 +378,18 @@ static Optional<APInt> buildAttributeAPInt(Type type, bool isNegative,
// 0 bit integers cannot be negative and manipulation of their sign bit will
// assert, so short-cut validation here.
if (isNegative)
- return llvm::None;
+ return std::nullopt;
} else if (isNegative) {
// The value is negative, we have an overflow if the sign bit is not set
// in the negated apInt.
result.negate();
if (!result.isSignBitSet())
- return llvm::None;
+ return std::nullopt;
} else if ((type.isSignedInteger() || type.isIndex()) &&
result.isSignBitSet()) {
// The value is a positive signed integer or index,
// we have an overflow if the sign bit is set.
- return llvm::None;
+ return std::nullopt;
}
return result;
@@ -1175,7 +1175,7 @@ Attribute Parser::parseStridedLayoutAttr() {
SMLoc loc = getToken().getLoc();
auto emitWrongTokenError = [&] {
emitError(loc, "expected a 64-bit signed integer or '?'");
- return llvm::None;
+ return std::nullopt;
};
bool negative = consumeIf(Token::minus);
diff --git a/mlir/lib/AsmParser/Parser.cpp b/mlir/lib/AsmParser/Parser.cpp
index 9b6d66582f83..75298ec5329d 100644
--- a/mlir/lib/AsmParser/Parser.cpp
+++ b/mlir/lib/AsmParser/Parser.cpp
@@ -250,7 +250,7 @@ OptionalParseResult Parser::parseOptionalInteger(APInt &result) {
Token curToken = getToken();
if (curToken.isNot(Token::integer, Token::minus))
- return llvm::None;
+ return std::nullopt;
bool negative = consumeIf(Token::minus);
Token curTok = getToken();
@@ -533,12 +533,12 @@ class OperationParser : public Parser {
/// skip parsing that component.
ParseResult parseGenericOperationAfterOpName(
OperationState &result,
- Optional<ArrayRef<UnresolvedOperand>> parsedOperandUseInfo = llvm::None,
- Optional<ArrayRef<Block *>> parsedSuccessors = llvm::None,
+ Optional<ArrayRef<UnresolvedOperand>> parsedOperandUseInfo = std::nullopt,
+ Optional<ArrayRef<Block *>> parsedSuccessors = std::nullopt,
Optional<MutableArrayRef<std::unique_ptr<Region>>> parsedRegions =
- llvm::None,
- Optional<ArrayRef<NamedAttribute>> parsedAttributes = llvm::None,
- Optional<FunctionType> parsedFnType = llvm::None);
+ std::nullopt,
+ Optional<ArrayRef<NamedAttribute>> parsedAttributes = std::nullopt,
+ Optional<FunctionType> parsedFnType = std::nullopt);
/// Parse an operation instance that is in the generic form and insert it at
/// the provided insertion point.
@@ -1073,7 +1073,7 @@ Value OperationParser::createForwardRefPlaceholder(SMLoc loc, Type type) {
auto name = OperationName("builtin.unrealized_conversion_cast", getContext());
auto *op = Operation::create(
getEncodedSourceLocation(loc), name, type, /*operands=*/{},
- /*attributes=*/llvm::None, /*successors=*/{}, /*numRegions=*/0);
+ /*attributes=*/std::nullopt, /*successors=*/{}, /*numRegions=*/0);
forwardRefPlaceholders[op->getResult(0)] = loc;
return op->getResult(0);
}
@@ -1524,7 +1524,7 @@ class CustomOpAsmParser : public AsmParserImpl<OpAsmParser> {
bool allowResultNumber = true) override {
if (parser.getToken().isOrIsCodeCompletionFor(Token::percent_identifier))
return parseOperand(result, allowResultNumber);
- return llvm::None;
+ return std::nullopt;
}
/// Parse zero or more SSA comma-separated operand references with a specified
@@ -1657,7 +1657,7 @@ class CustomOpAsmParser : public AsmParserImpl<OpAsmParser> {
bool allowAttrs) override {
if (parser.getToken().is(Token::percent_identifier))
return parseArgument(result, allowType, allowAttrs);
- return llvm::None;
+ return std::nullopt;
}
ParseResult parseArgumentList(SmallVectorImpl<Argument> &result,
@@ -1697,7 +1697,7 @@ class CustomOpAsmParser : public AsmParserImpl<OpAsmParser> {
ArrayRef<Argument> arguments,
bool enableNameShadowing) override {
if (parser.getToken().isNot(Token::l_brace))
- return llvm::None;
+ return std::nullopt;
return parseRegion(region, arguments, enableNameShadowing);
}
@@ -1709,7 +1709,7 @@ class CustomOpAsmParser : public AsmParserImpl<OpAsmParser> {
ArrayRef<Argument> arguments,
bool enableNameShadowing = false) override {
if (parser.getToken().isNot(Token::l_brace))
- return llvm::None;
+ return std::nullopt;
std::unique_ptr<Region> newRegion = std::make_unique<Region>();
if (parseRegion(*newRegion, arguments, enableNameShadowing))
return failure();
@@ -1730,7 +1730,7 @@ class CustomOpAsmParser : public AsmParserImpl<OpAsmParser> {
/// Parse an optional operation successor and its operand list.
OptionalParseResult parseOptionalSuccessor(Block *&dest) override {
if (!parser.getToken().isOrIsCodeCompletionFor(Token::caret_identifier))
- return llvm::None;
+ return std::nullopt;
return parseSuccessor(dest);
}
@@ -1759,7 +1759,7 @@ class CustomOpAsmParser : public AsmParserImpl<OpAsmParser> {
SmallVectorImpl<Argument> &lhs,
SmallVectorImpl<UnresolvedOperand> &rhs) override {
if (failed(parseOptionalLParen()))
- return llvm::None;
+ return std::nullopt;
auto parseElt = [&]() -> ParseResult {
if (parseArgument(lhs.emplace_back()) || parseEqual() ||
@@ -2391,7 +2391,7 @@ class ParsedResourceEntry : public AsmParsedResourceEntry {
// TODO: We could avoid an additional alloc+copy here if we pre-allocated
// the buffer to use during hex processing.
Optional<std::string> blobData =
- value.is(Token::string) ? value.getHexStringValue() : llvm::None;
+ value.is(Token::string) ? value.getHexStringValue() : std::nullopt;
if (!blobData)
return p.emitError(value.getLoc(),
"expected hex string blob for key '" + key + "'");
diff --git a/mlir/lib/AsmParser/Parser.h b/mlir/lib/AsmParser/Parser.h
index d52b05d72b7e..633faf358c95 100644
--- a/mlir/lib/AsmParser/Parser.h
+++ b/mlir/lib/AsmParser/Parser.h
@@ -236,7 +236,7 @@ class Parser {
AttributeT &attr,
Type type = {}) {
if (getToken().isNot(kind))
- return llvm::None;
+ return std::nullopt;
if (Attribute parsedAttr = parseAttribute(type)) {
attr = parsedAttr.cast<AttributeT>();
diff --git a/mlir/lib/AsmParser/Token.cpp b/mlir/lib/AsmParser/Token.cpp
index 7a8d2975d2f4..4f465ff38405 100644
--- a/mlir/lib/AsmParser/Token.cpp
+++ b/mlir/lib/AsmParser/Token.cpp
@@ -30,7 +30,7 @@ Optional<unsigned> Token::getUnsignedIntegerValue() const {
unsigned result = 0;
if (spelling.getAsInteger(isHex ? 0 : 10, result))
- return None;
+ return std::nullopt;
return result;
}
@@ -41,7 +41,7 @@ Optional<uint64_t> Token::getUInt64IntegerValue(StringRef spelling) {
uint64_t result = 0;
if (spelling.getAsInteger(isHex ? 0 : 10, result))
- return None;
+ return std::nullopt;
return result;
}
@@ -50,7 +50,7 @@ Optional<uint64_t> Token::getUInt64IntegerValue(StringRef spelling) {
Optional<double> Token::getFloatingPointValue() const {
double result = 0;
if (spelling.getAsDouble(result))
- return None;
+ return std::nullopt;
return result;
}
@@ -60,14 +60,14 @@ Optional<unsigned> Token::getIntTypeBitwidth() const {
unsigned bitwidthStart = (spelling[0] == 'i' ? 1 : 2);
unsigned result = 0;
if (spelling.drop_front(bitwidthStart).getAsInteger(10, result))
- return None;
+ return std::nullopt;
return result;
}
Optional<bool> Token::getIntTypeSignedness() const {
assert(getKind() == inttype);
if (spelling[0] == 'i')
- return llvm::None;
+ return std::nullopt;
if (spelling[0] == 's')
return true;
assert(spelling[0] == 'u');
@@ -138,7 +138,7 @@ Optional<std::string> Token::getHexStringValue() const {
std::string hex;
if (!bytes.consume_front("0x") || (bytes.size() & 1) ||
!llvm::tryGetFromHex(bytes, hex))
- return llvm::None;
+ return std::nullopt;
return hex;
}
@@ -161,7 +161,7 @@ Optional<unsigned> Token::getHashIdentifierNumber() const {
assert(getKind() == hash_identifier);
unsigned result = 0;
if (spelling.drop_front().getAsInteger(10, result))
- return None;
+ return std::nullopt;
return result;
}
diff --git a/mlir/lib/AsmParser/TypeParser.cpp b/mlir/lib/AsmParser/TypeParser.cpp
index 8ab9ef5f5993..259572247dcc 100644
--- a/mlir/lib/AsmParser/TypeParser.cpp
+++ b/mlir/lib/AsmParser/TypeParser.cpp
@@ -44,7 +44,7 @@ OptionalParseResult Parser::parseOptionalType(Type &type) {
return failure(!(type = parseType()));
default:
- return llvm::None;
+ return std::nullopt;
}
}
diff --git a/mlir/lib/CAPI/IR/Pass.cpp b/mlir/lib/CAPI/IR/Pass.cpp
index 4afc668592bd..6f81cd8084ef 100644
--- a/mlir/lib/CAPI/IR/Pass.cpp
+++ b/mlir/lib/CAPI/IR/Pass.cpp
@@ -178,7 +178,7 @@ MlirPass mlirCreateExternalPass(MlirTypeID passID, MlirStringRef name,
void *userData) {
return wrap(static_cast<mlir::Pass *>(new mlir::ExternalPass(
unwrap(passID), unwrap(name), unwrap(argument), unwrap(description),
- opName.length > 0 ? Optional<StringRef>(unwrap(opName)) : None,
+ opName.length > 0 ? Optional<StringRef>(unwrap(opName)) : std::nullopt,
{dependentDialects, static_cast<size_t>(nDependentDialects)}, callbacks,
userData)));
}
diff --git a/mlir/lib/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.cpp b/mlir/lib/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.cpp
index 85064a4e9495..8154c6bd0647 100644
--- a/mlir/lib/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.cpp
+++ b/mlir/lib/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.cpp
@@ -402,7 +402,7 @@ static Optional<StringRef> mfmaOpToIntrinsic(MFMAOp mfma, Chipset chipset) {
if (m == 4 && n == 4 && k == 4 && b == 4)
return ROCDL::mfma_f64_4x4x4f64::getOperationName();
}
- return None;
+ return std::nullopt;
}
namespace {
diff --git a/mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp b/mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp
index 97fc875cb7de..f2d6b9d2928e 100644
--- a/mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp
+++ b/mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp
@@ -304,7 +304,7 @@ class AsyncRuntimeTypeConverter : public TypeConverter {
if (type.isa<CoroHandleType>())
return AsyncAPI::opaquePointerType(type.getContext());
- return llvm::None;
+ return std::nullopt;
}
};
} // namespace
diff --git a/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp b/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp
index e7d7873ab5cd..2c84e0b25c55 100644
--- a/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp
+++ b/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp
@@ -66,7 +66,7 @@ struct AssertOpLowering : public ConvertOpToLLVMPattern<cf::AssertOp> {
// Generate IR to call `abort`.
Block *failureBlock = rewriter.createBlock(opBlock->getParent());
- rewriter.create<LLVM::CallOp>(loc, abortFunc, llvm::None);
+ rewriter.create<LLVM::CallOp>(loc, abortFunc, std::nullopt);
rewriter.create<LLVM::UnreachableOp>(loc);
// Generate assertion test.
diff --git a/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp b/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp
index 6c3e8ab4c3b3..e4d98f699178 100644
--- a/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp
+++ b/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp
@@ -183,7 +183,7 @@ struct LowerGpuOpsToNVVMOpsPass
converter.addConversion([&](MemRefType type) -> Optional<Type> {
if (type.getMemorySpaceAsInt() !=
gpu::GPUDialect::getPrivateAddressSpace())
- return llvm::None;
+ return std::nullopt;
return converter.convertType(MemRefType::Builder(type).setMemorySpace(
IntegerAttr::get(IntegerType::get(m.getContext(), 64), 0)));
});
diff --git a/mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp b/mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp
index 311f272fc380..119b1d3dea91 100644
--- a/mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp
+++ b/mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp
@@ -224,7 +224,7 @@ lowerAsEntryFunction(gpu::GPUFuncOp funcOp, TypeConverter &typeConverter,
auto newFuncOp = rewriter.create<spirv::FuncOp>(
funcOp.getLoc(), funcOp.getName(),
rewriter.getFunctionType(signatureConverter.getConvertedTypes(),
- llvm::None));
+ std::nullopt));
for (const auto &namedAttr : funcOp->getAttrs()) {
if (namedAttr.getName() == FunctionOpInterface::getTypeAttrName() ||
namedAttr.getName() == SymbolTable::getSymbolAttrName())
@@ -329,7 +329,7 @@ LogicalResult GPUModuleConversion::matchAndRewrite(
// Add a keyword to the module name to avoid symbolic conflict.
std::string spvModuleName = (kSPIRVModule + moduleOp.getName()).str();
auto spvModule = rewriter.create<spirv::ModuleOp>(
- moduleOp.getLoc(), addressingModel, *memoryModel, llvm::None,
+ moduleOp.getLoc(), addressingModel, *memoryModel, std::nullopt,
StringRef(spvModuleName));
// Move the region from the module op into the SPIR-V module.
diff --git a/mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp b/mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp
index 9842947948d7..2d7fb3ed90f1 100644
--- a/mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp
+++ b/mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp
@@ -43,7 +43,7 @@ LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
// order and those should take priority.
addConversion([](Type type) {
return LLVM::isCompatibleType(type) ? llvm::Optional<Type>(type)
- : llvm::None;
+ : std::nullopt;
});
// LLVM container types may (recursively) contain other types that must be
@@ -53,7 +53,7 @@ LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
return type;
if (auto pointee = convertType(type.getElementType()))
return LLVM::LLVMPointerType::get(pointee, type.getAddressSpace());
- return llvm::None;
+ return std::nullopt;
});
addConversion([&](LLVM::LLVMStructType type, SmallVectorImpl<Type> &results,
ArrayRef<Type> callStack) -> llvm::Optional<LogicalResult> {
@@ -82,7 +82,7 @@ LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
SmallVector<Type> convertedElemTypes;
convertedElemTypes.reserve(type.getBody().size());
if (failed(convertTypes(type.getBody(), convertedElemTypes)))
- return llvm::None;
+ return std::nullopt;
if (failed(convertedType.setBody(convertedElemTypes, type.isPacked())))
return failure();
@@ -93,7 +93,7 @@ LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
SmallVector<Type> convertedSubtypes;
convertedSubtypes.reserve(type.getBody().size());
if (failed(convertTypes(type.getBody(), convertedSubtypes)))
- return llvm::None;
+ return std::nullopt;
results.push_back(LLVM::LLVMStructType::getLiteral(
type.getContext(), convertedSubtypes, type.isPacked()));
@@ -102,17 +102,17 @@ LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
addConversion([&](LLVM::LLVMArrayType type) -> llvm::Optional<Type> {
if (auto element = convertType(type.getElementType()))
return LLVM::LLVMArrayType::get(element, type.getNumElements());
- return llvm::None;
+ return std::nullopt;
});
addConversion([&](LLVM::LLVMFunctionType type) -> llvm::Optional<Type> {
Type convertedResType = convertType(type.getReturnType());
if (!convertedResType)
- return llvm::None;
+ return std::nullopt;
SmallVector<Type> convertedArgTypes;
convertedArgTypes.reserve(type.getNumParams());
if (failed(convertTypes(type.getParams(), convertedArgTypes)))
- return llvm::None;
+ return std::nullopt;
return LLVM::LLVMFunctionType::get(convertedResType, convertedArgTypes,
type.isVarArg());
@@ -125,7 +125,7 @@ LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
[&](OpBuilder &builder, UnrankedMemRefType resultType, ValueRange inputs,
Location loc) -> Optional<Value> {
if (inputs.size() == 1)
- return llvm::None;
+ return std::nullopt;
return UnrankedMemRefDescriptor::pack(builder, loc, *this, resultType,
inputs);
});
@@ -135,7 +135,7 @@ LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
// TODO: bare ptr conversion could be handled here but we would need a way
// to distinguish between FuncOp and other regions.
if (inputs.size() == 1)
- return llvm::None;
+ return std::nullopt;
return MemRefDescriptor::pack(builder, loc, *this, resultType, inputs);
});
// Add generic source and target materializations to handle cases where
@@ -144,7 +144,7 @@ LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
ValueRange inputs,
Location loc) -> Optional<Value> {
if (inputs.size() != 1)
- return llvm::None;
+ return std::nullopt;
return builder.create<UnrealizedConversionCastOp>(loc, resultType, inputs)
.getResult(0);
@@ -153,7 +153,7 @@ LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
ValueRange inputs,
Location loc) -> Optional<Value> {
if (inputs.size() != 1)
- return llvm::None;
+ return std::nullopt;
return builder.create<UnrealizedConversionCastOp>(loc, resultType, inputs)
.getResult(0);
diff --git a/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp b/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp
index e9f8bdb3eec8..c3710ea6c219 100644
--- a/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp
+++ b/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp
@@ -451,7 +451,7 @@ struct DimOpLowering : public ConvertOpToLLVMPattern<memref::DimOp> {
.getValue()
.getSExtValue();
- return llvm::None;
+ return std::nullopt;
}
Value extractSizeOfRankedMemRef(Type operandType, memref::DimOp dimOp,
@@ -1278,7 +1278,7 @@ struct MemRefReshapeOpLowering
UnrankedMemRefDescriptor::computeSizes(rewriter, loc, *getTypeConverter(),
targetDesc, sizes);
Value underlyingDescPtr = rewriter.create<LLVM::AllocaOp>(
- loc, getVoidPtrType(), sizes.front(), llvm::None);
+ loc, getVoidPtrType(), sizes.front(), std::nullopt);
targetDesc.setMemRefDescPtr(rewriter, loc, underlyingDescPtr);
// Extract pointers and offset from the source memref.
@@ -1362,8 +1362,8 @@ struct MemRefReshapeOpLowering
// Hook up the cond exit to the remainder.
rewriter.setInsertionPointToEnd(condBlock);
- rewriter.create<LLVM::CondBrOp>(loc, pred, bodyBlock, llvm::None, remainder,
- llvm::None);
+ rewriter.create<LLVM::CondBrOp>(loc, pred, bodyBlock, std::nullopt,
+ remainder, std::nullopt);
// Reset position to beginning of new remainder block.
rewriter.setInsertionPointToStart(remainder);
@@ -1599,7 +1599,8 @@ static void fillInStridesForCollapsedMemDescriptor(
initBlock->getParent(), Region::iterator(continueBlock), {});
}
rewriter.create<LLVM::CondBrOp>(loc, predNeOne, continueBlock,
- srcStride, nextEntryBlock, llvm::None);
+ srcStride, nextEntryBlock,
+ std::nullopt);
curEntryBlock = nextEntryBlock;
}
}
@@ -1897,7 +1898,7 @@ matchSimpleAtomicOp(memref::AtomicRMWOp atomicOp) {
case arith::AtomicRMWKind::andi:
return LLVM::AtomicBinOp::_and;
default:
- return llvm::None;
+ return std::nullopt;
}
llvm_unreachable("Invalid AtomicRMWKind");
}
diff --git a/mlir/lib/Conversion/MemRefToSPIRV/MapMemRefStorageClassPass.cpp b/mlir/lib/Conversion/MemRefToSPIRV/MapMemRefStorageClassPass.cpp
index 31276c691866..2a95199055f7 100644
--- a/mlir/lib/Conversion/MemRefToSPIRV/MapMemRefStorageClassPass.cpp
+++ b/mlir/lib/Conversion/MemRefToSPIRV/MapMemRefStorageClassPass.cpp
@@ -66,7 +66,7 @@ spirv::mapMemorySpaceToVulkanStorageClass(Attribute memorySpaceAttr) {
// Downstream callers should plug in more specialized ones.
auto intAttr = memorySpaceAttr.dyn_cast<IntegerAttr>();
if (!intAttr)
- return llvm::None;
+ return std::nullopt;
unsigned memorySpace = intAttr.getInt();
#define STORAGE_SPACE_MAP_FN(storage, space) \
@@ -78,7 +78,7 @@ spirv::mapMemorySpaceToVulkanStorageClass(Attribute memorySpaceAttr) {
default:
break;
}
- return llvm::None;
+ return std::nullopt;
#undef STORAGE_SPACE_MAP_FN
}
@@ -94,7 +94,7 @@ spirv::mapVulkanStorageClassToMemorySpace(spirv::StorageClass storageClass) {
default:
break;
}
- return llvm::None;
+ return std::nullopt;
#undef STORAGE_SPACE_MAP_FN
}
@@ -120,7 +120,7 @@ spirv::mapMemorySpaceToOpenCLStorageClass(Attribute memorySpaceAttr) {
// Downstream callers should plug in more specialized ones.
auto intAttr = memorySpaceAttr.dyn_cast<IntegerAttr>();
if (!intAttr)
- return llvm::None;
+ return std::nullopt;
unsigned memorySpace = intAttr.getInt();
#define STORAGE_SPACE_MAP_FN(storage, space) \
@@ -132,7 +132,7 @@ spirv::mapMemorySpaceToOpenCLStorageClass(Attribute memorySpaceAttr) {
default:
break;
}
- return llvm::None;
+ return std::nullopt;
#undef STORAGE_SPACE_MAP_FN
}
@@ -148,7 +148,7 @@ spirv::mapOpenCLStorageClassToMemorySpace(spirv::StorageClass storageClass) {
default:
break;
}
- return llvm::None;
+ return std::nullopt;
#undef STORAGE_SPACE_MAP_FN
}
@@ -172,7 +172,7 @@ spirv::MemorySpaceToStorageClassConverter::MemorySpaceToStorageClassConverter(
LLVM_DEBUG(llvm::dbgs()
<< "cannot convert " << memRefType
<< " due to being unable to find memory space in map\n");
- return llvm::None;
+ return std::nullopt;
}
auto storageAttr =
diff --git a/mlir/lib/Conversion/NVGPUToNVVM/NVGPUToNVVM.cpp b/mlir/lib/Conversion/NVGPUToNVVM/NVGPUToNVVM.cpp
index 415b87559a6e..1347b0cf3b8a 100644
--- a/mlir/lib/Conversion/NVGPUToNVVM/NVGPUToNVVM.cpp
+++ b/mlir/lib/Conversion/NVGPUToNVVM/NVGPUToNVVM.cpp
@@ -305,7 +305,7 @@ struct MmaSyncOptoNVVM : public ConvertOpToLLVMPattern<nvgpu::MmaSyncOp> {
"could not infer the PTX type for the accumulator/result");
// TODO: add an attribute to the op to customize this behavior.
- Optional<NVVM::MMAIntOverflow> overflow(llvm::None);
+ Optional<NVVM::MMAIntOverflow> overflow(std::nullopt);
if (aType.getElementType().isa<IntegerType>())
overflow = NVVM::MMAIntOverflow::satfinite;
@@ -322,7 +322,7 @@ struct MmaSyncOptoNVVM : public ConvertOpToLLVMPattern<nvgpu::MmaSyncOp> {
Value intrinsicResult = rewriter.create<NVVM::MmaOp>(
op.getLoc(), intrinsicResTy, matA, matB, matC,
/*shape=*/gemmShape,
- /*b1Op=*/llvm::None,
+ /*b1Op=*/std::nullopt,
/*intOverflow=*/overflow,
/*multiplicandPtxTypes=*/
std::array<NVVM::MMATypes, 2>{*ptxTypeA, *ptxTypeB},
@@ -517,7 +517,7 @@ struct NVGPUMmaSparseSyncLowering
return failure();
// TODO: add an attribute to the op to customize this behavior.
- Optional<NVVM::MMAIntOverflow> overflow(llvm::None);
+ Optional<NVVM::MMAIntOverflow> overflow(std::nullopt);
if (aType.getElementType().isa<IntegerType>())
overflow = NVVM::MMAIntOverflow::satfinite;
diff --git a/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp b/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
index fdc95ab7a820..75a01409bddc 100644
--- a/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
+++ b/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
@@ -614,7 +614,7 @@ SymbolRefAttr PatternLowering::generateRewriter(
builder.setInsertionPointToEnd(rewriterModule.getBody());
auto rewriterFunc = builder.create<pdl_interp::FuncOp>(
pattern.getLoc(), "pdl_generated_rewriter",
- builder.getFunctionType(llvm::None, llvm::None));
+ builder.getFunctionType(std::nullopt, std::nullopt));
rewriterSymbolTable.insert(rewriterFunc);
// Generate the rewriter function body.
@@ -681,7 +681,7 @@ SymbolRefAttr PatternLowering::generateRewriter(
// Update the signature of the rewrite function.
rewriterFunc.setType(builder.getFunctionType(
llvm::to_vector<8>(rewriterFunc.front().getArgumentTypes()),
- /*results=*/llvm::None));
+ /*results=*/std::nullopt));
builder.create<pdl_interp::FinalizeOp>(rewriter.getLoc());
return SymbolRefAttr::get(
@@ -968,8 +968,8 @@ void PDLToPDLInterpPass::runOnOperation() {
auto matcherFunc = builder.create<pdl_interp::FuncOp>(
module.getLoc(), pdl_interp::PDLInterpDialect::getMatcherFunctionName(),
builder.getFunctionType(builder.getType<pdl::OperationType>(),
- /*results=*/llvm::None),
- /*attrs=*/llvm::None);
+ /*results=*/std::nullopt),
+ /*attrs=*/std::nullopt);
// Create a nested module to hold the functions invoked for rewriting the IR
// after a successful match.
diff --git a/mlir/lib/Conversion/PDLToPDLInterp/Predicate.h b/mlir/lib/Conversion/PDLToPDLInterp/Predicate.h
index 81a11529b97c..af6a45601047 100644
--- a/mlir/lib/Conversion/PDLToPDLInterp/Predicate.h
+++ b/mlir/lib/Conversion/PDLToPDLInterp/Predicate.h
@@ -600,7 +600,7 @@ class PredicateBuilder {
return OperandGroupPosition::get(uniquer, p, group, isVariadic);
}
Position *getAllOperands(OperationPosition *p) {
- return getOperandGroup(p, /*group=*/llvm::None, /*isVariadic=*/true);
+ return getOperandGroup(p, /*group=*/std::nullopt, /*isVariadic=*/true);
}
/// Returns a result position for a result of the given operation.
@@ -614,7 +614,7 @@ class PredicateBuilder {
return ResultGroupPosition::get(uniquer, p, group, isVariadic);
}
Position *getAllResults(OperationPosition *p) {
- return getResultGroup(p, /*group=*/llvm::None, /*isVariadic=*/true);
+ return getResultGroup(p, /*group=*/std::nullopt, /*isVariadic=*/true);
}
/// Returns a type position for the given entity.
diff --git a/mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp b/mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp
index 422182e97024..683b18e1d192 100644
--- a/mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp
+++ b/mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp
@@ -110,7 +110,7 @@ static void getTreePredicates(std::vector<PositionalPredicate> &predList,
Value val, PredicateBuilder &builder,
DenseMap<Value, Position *> &inputs,
OperationPosition *pos,
- Optional<unsigned> ignoreOperand = llvm::None) {
+ Optional<unsigned> ignoreOperand = std::nullopt) {
assert(val.getType().isa<pdl::OperationType>() && "expected operation");
pdl::OperationOp op = cast<pdl::OperationOp>(val.getDefiningOp());
OperationPosition *opPos = cast<OperationPosition>(pos);
@@ -458,7 +458,7 @@ static void buildCostGraph(ArrayRef<Value> roots, RootOrderingGraph &graph,
// For those, the index is empty.
if (operands.size() == 1 &&
operands[0].getType().isa<pdl::RangeType>()) {
- toVisit.emplace(operands[0], entry.value, llvm::None,
+ toVisit.emplace(operands[0], entry.value, std::nullopt,
entry.depth + 1);
return;
}
diff --git a/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp b/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp
index b0c150f05b4d..e06da8030539 100644
--- a/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp
+++ b/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp
@@ -192,7 +192,7 @@ AffineLoopToGpuConverter::collectBounds(AffineForOp forOp, unsigned numLoops) {
Value lowerBound = getOrEmitLowerBound(currentLoop, builder);
Value upperBound = getOrEmitUpperBound(currentLoop, builder);
if (!lowerBound || !upperBound) {
- return llvm::None;
+ return std::nullopt;
}
Value range = builder.create<arith::SubIOp>(currentLoop.getLoc(),
@@ -248,7 +248,7 @@ void AffineLoopToGpuConverter::createLaunch(AffineForOp rootForOp,
Location terminatorLoc = terminator.getLoc();
terminator.erase();
builder.setInsertionPointToEnd(innermostForOp.getBody());
- builder.create<gpu::TerminatorOp>(terminatorLoc, llvm::None);
+ builder.create<gpu::TerminatorOp>(terminatorLoc, std::nullopt);
launchOp.getBody().front().getOperations().splice(
launchOp.getBody().front().begin(),
innermostForOp.getBody()->getOperations());
diff --git a/mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp b/mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp
index 75d0b8edca15..c91d2a200df8 100644
--- a/mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp
+++ b/mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp
@@ -412,7 +412,7 @@ WhileOpConversion::matchAndRewrite(scf::WhileOp whileOp, OpAdaptor adaptor,
rewriter.setInsertionPointToEnd(&beforeBlock);
rewriter.replaceOpWithNewOp<spirv::BranchConditionalOp>(
- cond, conditionVal, &afterBlock, condArgs, &mergeBlock, llvm::None);
+ cond, conditionVal, &afterBlock, condArgs, &mergeBlock, std::nullopt);
// Convert the scf.yield op to a branch back to the header block.
rewriter.setInsertionPointToEnd(&afterBlock);
diff --git a/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp b/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp
index f2e93124c729..d2993836bc97 100644
--- a/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp
+++ b/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp
@@ -188,7 +188,7 @@ static Optional<Type>
convertStructTypeWithOffset(spirv::StructType type,
LLVMTypeConverter &converter) {
if (type != VulkanLayoutUtils::decorateType(type))
- return llvm::None;
+ return std::nullopt;
auto elementsVector = llvm::to_vector<8>(
llvm::map_range(type.getElementTypes(), [&](Type elementType) {
@@ -253,7 +253,7 @@ static Optional<Type> convertArrayType(spirv::ArrayType type,
Type elementType = type.getElementType();
auto sizeInBytes = elementType.cast<spirv::SPIRVType>().getSizeInBytes();
if (stride != 0 && (!sizeInBytes || *sizeInBytes != stride))
- return llvm::None;
+ return std::nullopt;
auto llvmElementType = converter.convertType(elementType);
unsigned numElements = type.getNumElements();
@@ -274,7 +274,7 @@ static Type convertPointerType(spirv::PointerType type,
static Optional<Type> convertRuntimeArrayType(spirv::RuntimeArrayType type,
TypeConverter &converter) {
if (type.getArrayStride() != 0)
- return llvm::None;
+ return std::nullopt;
auto elementType = converter.convertType(type.getElementType());
return LLVM::LLVMArrayType::get(elementType, 0);
}
@@ -286,7 +286,7 @@ static Optional<Type> convertStructType(spirv::StructType type,
SmallVector<spirv::StructType::MemberDecorationInfo, 4> memberDecorations;
type.getMemberDecorations(memberDecorations);
if (!memberDecorations.empty())
- return llvm::None;
+ return std::nullopt;
if (type.hasOffset())
return convertStructTypeWithOffset(type, converter);
return convertStructTypePacked(type, converter);
@@ -812,7 +812,7 @@ class FunctionCallPattern
ConversionPatternRewriter &rewriter) const override {
if (callOp.getNumResults() == 0) {
rewriter.replaceOpWithNewOp<LLVM::CallOp>(
- callOp, llvm::None, adaptor.getOperands(), callOp->getAttrs());
+ callOp, std::nullopt, adaptor.getOperands(), callOp->getAttrs());
return success();
}
diff --git a/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp b/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp
index fc07216c894a..839dfb4d0d03 100644
--- a/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp
+++ b/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp
@@ -244,7 +244,7 @@ createLinalgBodyCalculationForElementwiseOp(Operation *op, ValueRange args,
rewriter.create<arith::ShRSIOp>(loc, resultTypes, args[0], subtract)
->getResults();
auto truncated =
- rewriter.create<arith::TruncIOp>(loc, i1Ty, shifted, mlir::None);
+ rewriter.create<arith::TruncIOp>(loc, i1Ty, shifted, std::nullopt);
auto isInputOdd =
rewriter.create<arith::AndIOp>(loc, i1Ty, truncated, i1one);
@@ -428,20 +428,21 @@ createLinalgBodyCalculationForElementwiseOp(Operation *op, ValueRange args,
return args.front();
if (srcTy.isa<FloatType>() && dstTy.isa<FloatType>() && bitExtend)
- return rewriter.create<arith::ExtFOp>(loc, resultTypes, args, mlir::None);
+ return rewriter.create<arith::ExtFOp>(loc, resultTypes, args,
+ std::nullopt);
if (srcTy.isa<FloatType>() && dstTy.isa<FloatType>() && !bitExtend)
return rewriter.create<arith::TruncFOp>(loc, resultTypes, args,
- mlir::None);
+ std::nullopt);
// 1-bit integers need to be treated as signless.
if (srcTy.isInteger(1) && arith::UIToFPOp::areCastCompatible(srcTy, dstTy))
return rewriter.create<arith::UIToFPOp>(loc, resultTypes, args,
- mlir::None);
+ std::nullopt);
if (srcTy.isInteger(1) && dstTy.isa<IntegerType>() && bitExtend)
return rewriter.create<arith::ExtUIOp>(loc, resultTypes, args,
- mlir::None);
+ std::nullopt);
// Unsigned integers need an unrealized cast so that they can be passed
// to UIToFP.
@@ -459,7 +460,7 @@ createLinalgBodyCalculationForElementwiseOp(Operation *op, ValueRange args,
// All other si-to-fp conversions should be handled by SIToFP.
if (arith::SIToFPOp::areCastCompatible(srcTy, dstTy))
return rewriter.create<arith::SIToFPOp>(loc, resultTypes, args,
- mlir::None);
+ std::nullopt);
// Casting to boolean, floats need to only be checked as not-equal to zero.
if (srcTy.isa<FloatType>() && dstTy.isInteger(1)) {
@@ -508,7 +509,7 @@ createLinalgBodyCalculationForElementwiseOp(Operation *op, ValueRange args,
if (srcTy.isa<IntegerType>() && dstTy.isa<IntegerType>() && bitExtend)
return rewriter.create<arith::ExtSIOp>(loc, resultTypes, args,
- mlir::None);
+ std::nullopt);
if (srcTy.isa<IntegerType>() && dstTy.isa<IntegerType>() && !bitExtend) {
auto intMin = rewriter.create<arith::ConstantIntOp>(
diff --git a/mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp b/mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp
index 2734b5f1660b..416a193ffc93 100644
--- a/mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp
+++ b/mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp
@@ -119,10 +119,10 @@ getMemrefConstantHorizontalStride(ShapedType type) {
SmallVector<int64_t, 2> strides;
if (failed(getStridesAndOffset(memrefType, strides, offset)) ||
strides.back() != 1)
- return llvm::None;
+ return std::nullopt;
int64_t stride = strides[strides.size() - 2];
if (stride == ShapedType::kDynamic)
- return llvm::None;
+ return std::nullopt;
return stride;
}
@@ -197,7 +197,7 @@ convertElementwiseOpToMMA(Operation *op) {
return gpu::MMAElementwiseOp::MINF;
if (isa<arith::DivFOp>(op))
return gpu::MMAElementwiseOp::DIVF;
- return llvm::None;
+ return std::nullopt;
}
/// Return true if the op is supported as elementwise op on MMAMatrix type.
diff --git a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp
index ca5cdb7265fe..f0166015425b 100644
--- a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp
+++ b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp
@@ -948,9 +948,9 @@ computeContiguousStrides(MemRefType memRefType) {
int64_t offset;
SmallVector<int64_t, 4> strides;
if (failed(getStridesAndOffset(memRefType, strides, offset)))
- return None;
+ return std::nullopt;
if (!strides.empty() && strides.back() != 1)
- return None;
+ return std::nullopt;
// If no layout or identity layout, this is contiguous by definition.
if (memRefType.getLayout().isIdentity())
return strides;
@@ -964,9 +964,9 @@ computeContiguousStrides(MemRefType memRefType) {
if (ShapedType::isDynamic(sizes[index + 1]) ||
ShapedType::isDynamic(strides[index]) ||
ShapedType::isDynamic(strides[index + 1]))
- return None;
+ return std::nullopt;
if (strides[index] != strides[index + 1] * sizes[index + 1])
- return None;
+ return std::nullopt;
}
return strides;
}
diff --git a/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp b/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp
index 889c976bd2db..b441105a60be 100644
--- a/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp
+++ b/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp
@@ -63,7 +63,7 @@ static Optional<int64_t> unpackedDim(OpTy xferOp) {
}
assert(xferOp.isBroadcastDim(0) &&
"Expected AffineDimExpr or AffineConstantExpr");
- return None;
+ return std::nullopt;
}
/// Compute the permutation map for the new (N-1)-D vector transfer op. This
@@ -1114,7 +1114,7 @@ get1dMemrefIndices(OpBuilder &b, OpTy xferOp, Value iv,
assert(xferOp.isBroadcastDim(0) &&
"Expected AffineDimExpr or AffineConstantExpr");
- return None;
+ return std::nullopt;
}
/// Codegen strategy for TransferOp1dConversion, depending on the
diff --git a/mlir/lib/Dialect/AMDGPU/IR/AMDGPUDialect.cpp b/mlir/lib/Dialect/AMDGPU/IR/AMDGPUDialect.cpp
index 1e5ba7ade861..c681f2dc5687 100644
--- a/mlir/lib/Dialect/AMDGPU/IR/AMDGPUDialect.cpp
+++ b/mlir/lib/Dialect/AMDGPU/IR/AMDGPUDialect.cpp
@@ -70,10 +70,10 @@ LogicalResult RawBufferAtomicFaddOp::verify() {
static Optional<uint32_t> getConstantUint32(Value v) {
APInt cst;
if (!v.getType().isInteger(32))
- return None;
+ return std::nullopt;
if (matchPattern(v, m_ConstantInt(&cst)))
return cst.getZExtValue();
- return None;
+ return std::nullopt;
}
template <typename OpType>
diff --git a/mlir/lib/Dialect/Affine/Analysis/AffineAnalysis.cpp b/mlir/lib/Dialect/Affine/Analysis/AffineAnalysis.cpp
index 5af6a6afa9f7..0fddcd72dff4 100644
--- a/mlir/lib/Dialect/Affine/Analysis/AffineAnalysis.cpp
+++ b/mlir/lib/Dialect/Affine/Analysis/AffineAnalysis.cpp
@@ -67,7 +67,7 @@ static Value getSupportedReduction(AffineForOp forOp, unsigned pos,
.Default([](Operation *) -> Optional<arith::AtomicRMWKind> {
// TODO: AtomicRMW supports other kinds of reductions this is
// currently not detecting, add those when the need arises.
- return llvm::None;
+ return std::nullopt;
});
if (!maybeKind)
return nullptr;
diff --git a/mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp b/mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp
index c14c9601ee78..5c284c1b08e2 100644
--- a/mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp
+++ b/mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp
@@ -157,7 +157,7 @@ FlatAffineValueConstraints::FlatAffineValueConstraints(IntegerSet set)
/*numLocals=*/0)) {
// Resize values.
- values.resize(getNumDimAndSymbolVars(), None);
+ values.resize(getNumDimAndSymbolVars(), std::nullopt);
// Flatten expressions and add them to the constraint system.
std::vector<SmallVector<int64_t, 8>> flatExprs;
@@ -294,7 +294,7 @@ unsigned FlatAffineValueConstraints::insertVar(VarKind kind, unsigned pos,
unsigned absolutePos = IntegerPolyhedron::insertVar(kind, pos, num);
if (kind != VarKind::Local) {
- values.insert(values.begin() + absolutePos, num, None);
+ values.insert(values.begin() + absolutePos, num, std::nullopt);
assert(values.size() == getNumDimAndSymbolVars());
}
@@ -312,7 +312,7 @@ unsigned FlatAffineValueConstraints::insertVar(VarKind kind, unsigned pos,
// If a Value is provided, insert it; otherwise use None.
for (unsigned i = 0; i < num; ++i)
values.insert(values.begin() + absolutePos + i,
- vals[i] ? Optional<Value>(vals[i]) : None);
+ vals[i] ? Optional<Value>(vals[i]) : std::nullopt);
assert(values.size() == getNumDimAndSymbolVars());
return absolutePos;
@@ -1351,9 +1351,9 @@ void FlatAffineValueConstraints::swapVar(unsigned posA, unsigned posB) {
// Treat value of a local variable as None.
if (getVarKindAt(posA) == VarKind::Local)
- values[posB] = None;
+ values[posB] = std::nullopt;
else if (getVarKindAt(posB) == VarKind::Local)
- values[posA] = None;
+ values[posA] = std::nullopt;
else
std::swap(values[posA], values[posB]);
}
@@ -1392,7 +1392,7 @@ void FlatAffineValueConstraints::clearAndCopyFrom(
} else {
*static_cast<IntegerRelation *>(this) = other;
values.clear();
- values.resize(getNumDimAndSymbolVars(), None);
+ values.resize(getNumDimAndSymbolVars(), std::nullopt);
}
}
diff --git a/mlir/lib/Dialect/Affine/Analysis/LoopAnalysis.cpp b/mlir/lib/Dialect/Affine/Analysis/LoopAnalysis.cpp
index db89d93040fa..daf593de03f4 100644
--- a/mlir/lib/Dialect/Affine/Analysis/LoopAnalysis.cpp
+++ b/mlir/lib/Dialect/Affine/Analysis/LoopAnalysis.cpp
@@ -87,7 +87,7 @@ Optional<uint64_t> mlir::getConstantTripCount(AffineForOp forOp) {
getTripCountMapAndOperands(forOp, &map, &operands);
if (!map)
- return None;
+ return std::nullopt;
// Take the min if all trip counts are constant.
Optional<uint64_t> tripCount;
@@ -99,7 +99,7 @@ Optional<uint64_t> mlir::getConstantTripCount(AffineForOp forOp) {
else
tripCount = constExpr.getValue();
} else
- return None;
+ return std::nullopt;
}
return tripCount;
}
diff --git a/mlir/lib/Dialect/Affine/Analysis/Utils.cpp b/mlir/lib/Dialect/Affine/Analysis/Utils.cpp
index 84b9f5f1f30d..b9325b3717a0 100644
--- a/mlir/lib/Dialect/Affine/Analysis/Utils.cpp
+++ b/mlir/lib/Dialect/Affine/Analysis/Utils.cpp
@@ -164,19 +164,19 @@ Optional<bool> ComputationSliceState::isSliceMaximalFastCheck() const {
// Make sure we skip those cases by checking that the lb result is not
// just a constant.
lbMap.getResult(0).isa<AffineConstantExpr>())
- return llvm::None;
+ return std::nullopt;
// Limited support: we expect the lb result to be just a loop dimension for
// now.
AffineDimExpr result = lbMap.getResult(0).dyn_cast<AffineDimExpr>();
if (!result)
- return llvm::None;
+ return std::nullopt;
// Retrieve dst loop bounds.
AffineForOp dstLoop =
getForInductionVarOwner(lbOperands[i][result.getPosition()]);
if (!dstLoop)
- return llvm::None;
+ return std::nullopt;
AffineMap dstLbMap = dstLoop.getLowerBoundMap();
AffineMap dstUbMap = dstLoop.getUpperBoundMap();
@@ -190,7 +190,7 @@ Optional<bool> ComputationSliceState::isSliceMaximalFastCheck() const {
// constant component per bound for now.
if (srcLbMap.getNumResults() != 1 || srcUbMap.getNumResults() != 1 ||
dstLbMap.getNumResults() != 1 || dstUbMap.getNumResults() != 1)
- return llvm::None;
+ return std::nullopt;
AffineExpr srcLbResult = srcLbMap.getResult(0);
AffineExpr dstLbResult = dstLbMap.getResult(0);
@@ -200,7 +200,7 @@ Optional<bool> ComputationSliceState::isSliceMaximalFastCheck() const {
!srcUbResult.isa<AffineConstantExpr>() ||
!dstLbResult.isa<AffineConstantExpr>() ||
!dstUbResult.isa<AffineConstantExpr>())
- return llvm::None;
+ return std::nullopt;
// Check if src and dst loop bounds are the same. If not, we can guarantee
// that the slice is not maximal.
@@ -235,20 +235,20 @@ Optional<bool> ComputationSliceState::isSliceValid() {
// TODO: Store the source's domain to avoid computation at each depth.
if (failed(getSourceAsConstraints(srcConstraints))) {
LLVM_DEBUG(llvm::dbgs() << "Unable to compute source's domain\n");
- return llvm::None;
+ return std::nullopt;
}
// As the set
diff erence utility currently cannot handle symbols in its
// operands, validity of the slice cannot be determined.
if (srcConstraints.getNumSymbolVars() > 0) {
LLVM_DEBUG(llvm::dbgs() << "Cannot handle symbols in source domain\n");
- return llvm::None;
+ return std::nullopt;
}
// TODO: Handle local vars in the source domains while using the 'projectOut'
// utility below. Currently, aligning is not done assuming that there will be
// no local vars in the source domain.
if (srcConstraints.getNumLocalVars() != 0) {
LLVM_DEBUG(llvm::dbgs() << "Cannot handle locals in source domain\n");
- return llvm::None;
+ return std::nullopt;
}
// Create constraints for the slice loop nest that would be created if the
@@ -256,7 +256,7 @@ Optional<bool> ComputationSliceState::isSliceValid() {
FlatAffineValueConstraints sliceConstraints;
if (failed(getAsConstraints(&sliceConstraints))) {
LLVM_DEBUG(llvm::dbgs() << "Unable to compute slice's domain\n");
- return llvm::None;
+ return std::nullopt;
}
// Projecting out every dimension other than the 'ivs' to express slice's
@@ -300,7 +300,7 @@ Optional<bool> ComputationSliceState::isMaximal() const {
AffineForOp loop = getForInductionVarOwner(iv);
assert(loop && "Expected affine for");
if (failed(srcConstraints.addAffineForOpDomain(loop)))
- return llvm::None;
+ return std::nullopt;
}
// Create constraints for the slice using the dst loop nest information. We
@@ -320,12 +320,12 @@ Optional<bool> ComputationSliceState::isMaximal() const {
/*numLocals=*/0, consumerIVs);
if (failed(sliceConstraints.addDomainFromSliceMaps(lbs, ubs, lbOperands[0])))
- return llvm::None;
+ return std::nullopt;
if (srcConstraints.getNumDimVars() != sliceConstraints.getNumDimVars())
// Constraint dims are
diff erent. The integer set
diff erence can't be
// computed so we don't know if the slice is maximal.
- return llvm::None;
+ return std::nullopt;
// Compute the
diff erence between the src loop nest and the slice integer
// sets.
@@ -381,7 +381,7 @@ Optional<int64_t> MemRefRegion::getConstantBoundingSizeAndShape(
// memref's dim size if the latter has a constant size along this dim.
auto dimSize = memRefType.getDimSize(d);
if (dimSize == ShapedType::kDynamic)
- return None;
+ return std::nullopt;
diff Constant = dimSize;
// Lower bound becomes 0.
lb.resize(cstWithShapeBounds.getNumSymbolVars() + 1, 0);
@@ -629,7 +629,7 @@ Optional<int64_t> MemRefRegion::getRegionSize() {
Optional<int64_t> numElements = getConstantBoundingSizeAndShape();
if (!numElements) {
LLVM_DEBUG(llvm::dbgs() << "Dynamic shapes not yet supported\n");
- return None;
+ return std::nullopt;
}
return getMemRefEltSizeInBytes(memRefType) * *numElements;
}
@@ -640,10 +640,10 @@ Optional<int64_t> MemRefRegion::getRegionSize() {
// TODO: improve/complete this when we have target data.
Optional<uint64_t> mlir::getMemRefSizeInBytes(MemRefType memRefType) {
if (!memRefType.hasStaticShape())
- return None;
+ return std::nullopt;
auto elementType = memRefType.getElementType();
if (!elementType.isIntOrFloat() && !elementType.isa<VectorType>())
- return None;
+ return std::nullopt;
uint64_t sizeInBytes = getMemRefEltSizeInBytes(memRefType);
for (unsigned i = 0, e = memRefType.getRank(); i < e; i++) {
@@ -979,7 +979,7 @@ static Optional<uint64_t> getConstDifference(AffineMap lbMap, AffineMap ubMap) {
lbMap.getNumSymbols());
auto cExpr = loopSpanExpr.dyn_cast<AffineConstantExpr>();
if (!cExpr)
- return None;
+ return std::nullopt;
return cExpr.getValue();
}
@@ -1312,13 +1312,13 @@ static Optional<int64_t> getMemoryFootprintBytes(Block &block,
return WalkResult::advance();
});
if (result.wasInterrupted())
- return None;
+ return std::nullopt;
int64_t totalSizeInBytes = 0;
for (const auto ®ion : regions) {
Optional<int64_t> size = region.second->getRegionSize();
if (!size.has_value())
- return None;
+ return std::nullopt;
totalSizeInBytes += size.value();
}
return totalSizeInBytes;
diff --git a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp
index eb48549fd734..d7d21c8df6bd 100644
--- a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp
+++ b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp
@@ -2007,7 +2007,7 @@ namespace {
static Optional<uint64_t> getTrivialConstantTripCount(AffineForOp forOp) {
int64_t step = forOp.getStep();
if (!forOp.hasConstantBounds() || step <= 0)
- return None;
+ return std::nullopt;
int64_t lb = forOp.getConstantLowerBound();
int64_t ub = forOp.getConstantUpperBound();
return ub - lb <= 0 ? 0 : (ub - lb + step - 1) / step;
@@ -2263,7 +2263,7 @@ Optional<Value> AffineForOp::getSingleInductionVar() {
Optional<OpFoldResult> AffineForOp::getSingleLowerBound() {
if (!hasConstantLowerBound())
- return llvm::None;
+ return std::nullopt;
OpBuilder b(getContext());
return OpFoldResult(b.getI64IntegerAttr(getConstantLowerBound()));
}
@@ -2275,7 +2275,7 @@ Optional<OpFoldResult> AffineForOp::getSingleStep() {
Optional<OpFoldResult> AffineForOp::getSingleUpperBound() {
if (!hasConstantUpperBound())
- return llvm::None;
+ return std::nullopt;
OpBuilder b(getContext());
return OpFoldResult(b.getI64IntegerAttr(getConstantUpperBound()));
}
@@ -2365,8 +2365,8 @@ static AffineForOp
buildAffineLoopFromConstants(OpBuilder &builder, Location loc, int64_t lb,
int64_t ub, int64_t step,
AffineForOp::BodyBuilderFn bodyBuilderFn) {
- return builder.create<AffineForOp>(loc, lb, ub, step, /*iterArgs=*/llvm::None,
- bodyBuilderFn);
+ return builder.create<AffineForOp>(loc, lb, ub, step,
+ /*iterArgs=*/std::nullopt, bodyBuilderFn);
}
/// Creates an affine loop from the bounds that may or may not be constants.
@@ -2381,7 +2381,7 @@ buildAffineLoopFromValues(OpBuilder &builder, Location loc, Value lb, Value ub,
ubConst.value(), step, bodyBuilderFn);
return builder.create<AffineForOp>(loc, lb, builder.getDimIdentityMap(), ub,
builder.getDimIdentityMap(), step,
- /*iterArgs=*/llvm::None, bodyBuilderFn);
+ /*iterArgs=*/std::nullopt, bodyBuilderFn);
}
void mlir::buildAffineLoopNest(
@@ -3551,7 +3551,7 @@ AffineValueMap AffineParallelOp::getUpperBoundsValueMap() {
Optional<SmallVector<int64_t, 8>> AffineParallelOp::getConstantRanges() {
if (hasMinMaxBounds())
- return llvm::None;
+ return std::nullopt;
// Try to convert all the ranges to constant expressions.
SmallVector<int64_t, 8> out;
@@ -3563,7 +3563,7 @@ Optional<SmallVector<int64_t, 8>> AffineParallelOp::getConstantRanges() {
auto expr = rangesValueMap.getResult(i);
auto cst = expr.dyn_cast<AffineConstantExpr>();
if (!cst)
- return llvm::None;
+ return std::nullopt;
out.push_back(cst.getValue());
}
return out;
diff --git a/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp b/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp
index 027ebc3483bc..6efef00eb2d8 100644
--- a/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp
+++ b/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp
@@ -141,7 +141,7 @@ void AffineDataCopyGeneration::runOnBlock(Block *block,
if ((forOp = dyn_cast<AffineForOp>(&*it)) && copyNests.count(forOp) == 0) {
// Perform the copying up unti this 'for' op first.
(void)affineDataCopyGenerate(/*begin=*/curBegin, /*end=*/it, copyOptions,
- /*filterMemRef=*/llvm::None, copyNests);
+ /*filterMemRef=*/std::nullopt, copyNests);
// Returns true if the footprint is known to exceed capacity.
auto exceedsCapacity = [&](AffineForOp forOp) {
@@ -176,7 +176,7 @@ void AffineDataCopyGeneration::runOnBlock(Block *block,
// loop's footprint fits.
(void)affineDataCopyGenerate(/*begin=*/it, /*end=*/std::next(it),
copyOptions,
- /*filterMemRef=*/llvm::None, copyNests);
+ /*filterMemRef=*/std::nullopt, copyNests);
}
// Get to the next load or store op after 'forOp'.
curBegin = std::find_if(std::next(it), block->end(), [&](Operation &op) {
@@ -200,7 +200,7 @@ void AffineDataCopyGeneration::runOnBlock(Block *block,
// Exclude the affine.yield - hence, the std::prev.
(void)affineDataCopyGenerate(/*begin=*/curBegin,
/*end=*/std::prev(block->end()), copyOptions,
- /*filterMemRef=*/llvm::None, copyNests);
+ /*filterMemRef=*/std::nullopt, copyNests);
}
}
diff --git a/mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp b/mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp
index edffbe5e815b..491dd0775718 100644
--- a/mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp
+++ b/mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp
@@ -442,7 +442,7 @@ struct MemRefDependenceGraph {
for (Block::iterator it = std::next(Block::iterator(srcNodeInst));
it != Block::iterator(dstNodeInst); ++it) {
Operation *op = &(*it);
- if (srcDepInsts.count(op) > 0 && firstSrcDepPos == None)
+ if (srcDepInsts.count(op) > 0 && firstSrcDepPos == std::nullopt)
firstSrcDepPos = pos;
if (dstDepInsts.count(op) > 0)
lastDstDepPos = pos;
diff --git a/mlir/lib/Dialect/Affine/Transforms/LoopUnroll.cpp b/mlir/lib/Dialect/Affine/Transforms/LoopUnroll.cpp
index 55a04ca2f0a5..a948b4c2e119 100644
--- a/mlir/lib/Dialect/Affine/Transforms/LoopUnroll.cpp
+++ b/mlir/lib/Dialect/Affine/Transforms/LoopUnroll.cpp
@@ -51,8 +51,8 @@ struct LoopUnroll : public impl::AffineLoopUnrollBase<LoopUnroll> {
= default;
explicit LoopUnroll(
- Optional<unsigned> unrollFactor = None, bool unrollUpToFactor = false,
- bool unrollFull = false,
+ Optional<unsigned> unrollFactor = std::nullopt,
+ bool unrollUpToFactor = false, bool unrollFull = false,
const std::function<unsigned(AffineForOp)> &getUnrollFactor = nullptr)
: getUnrollFactor(getUnrollFactor) {
if (unrollFactor)
@@ -145,6 +145,6 @@ std::unique_ptr<OperationPass<func::FuncOp>> mlir::createLoopUnrollPass(
int unrollFactor, bool unrollUpToFactor, bool unrollFull,
const std::function<unsigned(AffineForOp)> &getUnrollFactor) {
return std::make_unique<LoopUnroll>(
- unrollFactor == -1 ? None : Optional<unsigned>(unrollFactor),
+ unrollFactor == -1 ? std::nullopt : Optional<unsigned>(unrollFactor),
unrollUpToFactor, unrollFull, getUnrollFactor);
}
diff --git a/mlir/lib/Dialect/Affine/Transforms/LoopUnrollAndJam.cpp b/mlir/lib/Dialect/Affine/Transforms/LoopUnrollAndJam.cpp
index be43651c38e7..cad62c4a55ca 100644
--- a/mlir/lib/Dialect/Affine/Transforms/LoopUnrollAndJam.cpp
+++ b/mlir/lib/Dialect/Affine/Transforms/LoopUnrollAndJam.cpp
@@ -61,7 +61,7 @@ namespace {
/// outer loop in a Function.
struct LoopUnrollAndJam
: public impl::AffineLoopUnrollAndJamBase<LoopUnrollAndJam> {
- explicit LoopUnrollAndJam(Optional<unsigned> unrollJamFactor = None) {
+ explicit LoopUnrollAndJam(Optional<unsigned> unrollJamFactor = std::nullopt) {
if (unrollJamFactor)
this->unrollJamFactor = *unrollJamFactor;
}
@@ -73,7 +73,8 @@ struct LoopUnrollAndJam
std::unique_ptr<OperationPass<func::FuncOp>>
mlir::createLoopUnrollAndJamPass(int unrollJamFactor) {
return std::make_unique<LoopUnrollAndJam>(
- unrollJamFactor == -1 ? None : Optional<unsigned>(unrollJamFactor));
+ unrollJamFactor == -1 ? std::nullopt
+ : Optional<unsigned>(unrollJamFactor));
}
void LoopUnrollAndJam::runOnOperation() {
diff --git a/mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp b/mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp
index c8f465331baa..2bdbb8bb9f4b 100644
--- a/mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp
+++ b/mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp
@@ -599,7 +599,7 @@ makePattern(const DenseSet<Operation *> ¶llelLoops, int vectorRank,
For(isVectorizableLoopPtrFactory(parallelLoops, d1),
For(isVectorizableLoopPtrFactory(parallelLoops, d2))));
default: {
- return llvm::None;
+ return std::nullopt;
}
}
}
diff --git a/mlir/lib/Dialect/Affine/Utils/Utils.cpp b/mlir/lib/Dialect/Affine/Utils/Utils.cpp
index 6bdebddeee2a..739588fd02ef 100644
--- a/mlir/lib/Dialect/Affine/Utils/Utils.cpp
+++ b/mlir/lib/Dialect/Affine/Utils/Utils.cpp
@@ -235,7 +235,7 @@ Optional<SmallVector<Value, 8>> mlir::expandAffineMap(OpBuilder &builder,
}));
if (llvm::all_of(expanded, [](Value v) { return v; }))
return expanded;
- return None;
+ return std::nullopt;
}
/// Promotes the `then` or the `else` block of `ifOp` (depending on whether
diff --git a/mlir/lib/Dialect/Arith/IR/ArithOps.cpp b/mlir/lib/Dialect/Arith/IR/ArithOps.cpp
index 9730e5834cef..00e23961208d 100644
--- a/mlir/lib/Dialect/Arith/IR/ArithOps.cpp
+++ b/mlir/lib/Dialect/Arith/IR/ArithOps.cpp
@@ -225,7 +225,7 @@ void arith::AddIOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
Optional<SmallVector<int64_t, 4>> arith::AddUICarryOp::getShapeForUnroll() {
if (auto vt = getType(0).dyn_cast<VectorType>())
return llvm::to_vector<4>(vt.getShape());
- return None;
+ return std::nullopt;
}
// Returns the carry bit, assuming that `sum` is the result of addition of
@@ -1509,7 +1509,7 @@ static Optional<int64_t> getIntegerWidth(Type t) {
if (auto vectorIntType = t.dyn_cast<VectorType>()) {
return vectorIntType.getElementType().cast<IntegerType>().getWidth();
}
- return llvm::None;
+ return std::nullopt;
}
OpFoldResult arith::CmpIOp::fold(ArrayRef<Attribute> operands) {
diff --git a/mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp b/mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp
index ad42001996ec..28134cf11932 100644
--- a/mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp
+++ b/mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp
@@ -1064,7 +1064,7 @@ arith::WideIntEmulationConverter::WideIntEmulationConverter(
if (width == 2 * maxIntWidth)
return VectorType::get(2, IntegerType::get(ty.getContext(), maxIntWidth));
- return None;
+ return std::nullopt;
});
// Vector case.
@@ -1085,7 +1085,7 @@ arith::WideIntEmulationConverter::WideIntEmulationConverter(
IntegerType::get(ty.getContext(), maxIntWidth));
}
- return None;
+ return std::nullopt;
});
// Function case.
@@ -1094,11 +1094,11 @@ arith::WideIntEmulationConverter::WideIntEmulationConverter(
// (i2N, i2N) -> i2N --> (vector<2xiN>, vector<2xiN>) -> vector<2xiN>
SmallVector<Type> inputs;
if (failed(convertTypes(ty.getInputs(), inputs)))
- return None;
+ return std::nullopt;
SmallVector<Type> results;
if (failed(convertTypes(ty.getResults(), results)))
- return None;
+ return std::nullopt;
return FunctionType::get(ty.getContext(), inputs, results);
});
diff --git a/mlir/lib/Dialect/Async/IR/Async.cpp b/mlir/lib/Dialect/Async/IR/Async.cpp
index 5ee227521618..e0772b4dd90b 100644
--- a/mlir/lib/Dialect/Async/IR/Async.cpp
+++ b/mlir/lib/Dialect/Async/IR/Async.cpp
@@ -342,7 +342,7 @@ void FuncOp::build(OpBuilder &builder, OperationState &state, StringRef name,
return;
assert(type.getNumInputs() == argAttrs.size());
function_interface_impl::addArgAndResultAttrs(builder, state, argAttrs,
- /*resultAttrs=*/llvm::None);
+ /*resultAttrs=*/std::nullopt);
}
ParseResult FuncOp::parse(OpAsmParser &parser, OperationState &result) {
diff --git a/mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp b/mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp
index e7859488b6b4..3701a8b48f92 100644
--- a/mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp
+++ b/mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp
@@ -223,7 +223,7 @@ static CoroMachinery setupCoroMachinery(func::FuncOp func) {
machinery.returnValues = retValues;
machinery.coroHandle = coroHdlOp.getHandle();
machinery.entry = entryBlock;
- machinery.setError = None; // created lazily only if needed
+ machinery.setError = std::nullopt; // created lazily only if needed
machinery.cleanup = cleanupBlock;
machinery.suspend = suspendBlock;
return machinery;
diff --git a/mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp b/mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp
index 609236b10d46..9a4d12c2b32b 100644
--- a/mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp
+++ b/mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp
@@ -371,7 +371,8 @@ class BufferDeallocation : public BufferPlacementTransformationBase {
// parent operation. In this case, we have to introduce an additional clone
// for buffer that is passed to the argument.
SmallVector<RegionSuccessor, 2> successorRegions;
- regionInterface.getSuccessorRegions(/*index=*/llvm::None, successorRegions);
+ regionInterface.getSuccessorRegions(/*index=*/std::nullopt,
+ successorRegions);
auto *it =
llvm::find_if(successorRegions, [&](RegionSuccessor &successorRegion) {
return successorRegion.getSuccessor() == argRegion;
diff --git a/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp b/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp
index e4ae23e9bcde..1c0f52b5585e 100644
--- a/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp
+++ b/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp
@@ -131,7 +131,7 @@ bool BufferPlacementTransformationBase::isLoop(Operation *op) {
// Start with all entry regions and test whether they induce a loop.
SmallVector<RegionSuccessor, 2> successorRegions;
- regionInterface.getSuccessorRegions(/*index=*/llvm::None, successorRegions);
+ regionInterface.getSuccessorRegions(/*index=*/std::nullopt, successorRegions);
for (RegionSuccessor ®ionEntry : successorRegions) {
if (recurse(regionEntry.getSuccessor()))
return true;
diff --git a/mlir/lib/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.cpp b/mlir/lib/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.cpp
index c75e0fa9e0aa..3b520f01e954 100644
--- a/mlir/lib/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.cpp
+++ b/mlir/lib/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.cpp
@@ -82,7 +82,8 @@ void BufferViewFlowAnalysis::build(Operation *op) {
op->walk([&](RegionBranchOpInterface regionInterface) {
// Extract all entry regions and wire all initial entry successor inputs.
SmallVector<RegionSuccessor, 2> entrySuccessors;
- regionInterface.getSuccessorRegions(/*index=*/llvm::None, entrySuccessors);
+ regionInterface.getSuccessorRegions(/*index=*/std::nullopt,
+ entrySuccessors);
for (RegionSuccessor &entrySuccessor : entrySuccessors) {
// Wire the entry region's successor arguments with the initial
// successor inputs.
diff --git a/mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp b/mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp
index 6546d55e6b35..0c8c6faf93c8 100644
--- a/mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp
+++ b/mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp
@@ -210,7 +210,7 @@ struct OneShotBufferizePass
opt.functionBoundaryTypeConversion =
parseLayoutMapOption(functionBoundaryTypeConversion);
if (mustInferMemorySpace)
- opt.defaultMemorySpace = None;
+ opt.defaultMemorySpace = std::nullopt;
opt.printConflicts = printConflicts;
opt.testAnalysisOnly = testAnalysisOnly;
opt.bufferizeFunctionBoundaries = bufferizeFunctionBoundaries;
diff --git a/mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp b/mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp
index 0f5dd5ceebc3..efc2398c4a64 100644
--- a/mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp
+++ b/mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp
@@ -132,12 +132,12 @@ static Optional<int64_t> getEquivalentFuncArgIdx(FuncOp funcOp,
auto funcOpIt = state.equivalentFuncArgs.find(funcOp);
if (funcOpIt == state.equivalentFuncArgs.end())
// No equivalence info stores for funcOp.
- return None;
+ return std::nullopt;
auto retValIt = funcOpIt->getSecond().find(returnValIdx);
if (retValIt == funcOpIt->getSecond().end())
// Return value has no equivalent bbArg.
- return None;
+ return std::nullopt;
return retValIt->getSecond();
}
@@ -273,7 +273,7 @@ struct CallOpInterface
SmallVector<Value> replacementValues(numResults, Value());
// For non-tensor results: A mapping from return val indices of the old
// CallOp to return val indices of the bufferized CallOp.
- SmallVector<Optional<unsigned>> retValMapping(numResults, None);
+ SmallVector<Optional<unsigned>> retValMapping(numResults, std::nullopt);
// Operands of the bufferized CallOp.
SmallVector<Value> newOperands(numOperands, Value());
diff --git a/mlir/lib/Dialect/Bufferization/Transforms/OneShotAnalysis.cpp b/mlir/lib/Dialect/Bufferization/Transforms/OneShotAnalysis.cpp
index 4292f94186bc..bf745e24cef4 100644
--- a/mlir/lib/Dialect/Bufferization/Transforms/OneShotAnalysis.cpp
+++ b/mlir/lib/Dialect/Bufferization/Transforms/OneShotAnalysis.cpp
@@ -480,7 +480,7 @@ bool canUseOpDominance(const DenseSet<OpOperand *> &usesRead,
const DenseSet<OpOperand *> &usesWrite,
const AnalysisState &state) {
const BufferizationOptions &options = state.getOptions();
- Optional<Region *> commonEnclosingRegion = None;
+ Optional<Region *> commonEnclosingRegion = std::nullopt;
// In case of a write, take the region in which the write takes place.
for (OpOperand *uWrite : usesWrite) {
diff --git a/mlir/lib/Dialect/Func/IR/FuncOps.cpp b/mlir/lib/Dialect/Func/IR/FuncOps.cpp
index a3ffa854d204..961cf2eb36e3 100644
--- a/mlir/lib/Dialect/Func/IR/FuncOps.cpp
+++ b/mlir/lib/Dialect/Func/IR/FuncOps.cpp
@@ -253,7 +253,7 @@ void FuncOp::build(OpBuilder &builder, OperationState &state, StringRef name,
return;
assert(type.getNumInputs() == argAttrs.size());
function_interface_impl::addArgAndResultAttrs(builder, state, argAttrs,
- /*resultAttrs=*/llvm::None);
+ /*resultAttrs=*/std::nullopt);
}
ParseResult FuncOp::parse(OpAsmParser &parser, OperationState &result) {
diff --git a/mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp b/mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp
index e035a26a84c0..baf18dc4d329 100644
--- a/mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp
+++ b/mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp
@@ -92,12 +92,12 @@ checkGpuLimits(TransformOpInterface transformOp, Optional<int64_t> gridDimX,
static DiagnosedSilenceableFailure
createGpuLaunch(RewriterBase &rewriter, Location loc,
TransformOpInterface transformOp, LaunchOp &launchOp,
- Optional<int64_t> gridDimX = llvm::None,
- Optional<int64_t> gridDimY = llvm::None,
- Optional<int64_t> gridDimZ = llvm::None,
- Optional<int64_t> blockDimX = llvm::None,
- Optional<int64_t> blockDimY = llvm::None,
- Optional<int64_t> blockDimZ = llvm::None) {
+ Optional<int64_t> gridDimX = std::nullopt,
+ Optional<int64_t> gridDimY = std::nullopt,
+ Optional<int64_t> gridDimZ = std::nullopt,
+ Optional<int64_t> blockDimX = std::nullopt,
+ Optional<int64_t> blockDimY = std::nullopt,
+ Optional<int64_t> blockDimZ = std::nullopt) {
DiagnosedSilenceableFailure diag =
checkGpuLimits(transformOp, gridDimX, gridDimY, gridDimZ, blockDimX,
blockDimY, blockDimZ);
@@ -126,12 +126,12 @@ createGpuLaunch(RewriterBase &rewriter, Location loc,
static DiagnosedSilenceableFailure
alterGpuLaunch(TrivialPatternRewriter &rewriter, LaunchOp gpuLaunch,
TransformOpInterface transformOp,
- Optional<int64_t> gridDimX = llvm::None,
- Optional<int64_t> gridDimY = llvm::None,
- Optional<int64_t> gridDimZ = llvm::None,
- Optional<int64_t> blockDimX = llvm::None,
- Optional<int64_t> blockDimY = llvm::None,
- Optional<int64_t> blockDimZ = llvm::None) {
+ Optional<int64_t> gridDimX = std::nullopt,
+ Optional<int64_t> gridDimY = std::nullopt,
+ Optional<int64_t> gridDimZ = std::nullopt,
+ Optional<int64_t> blockDimX = std::nullopt,
+ Optional<int64_t> blockDimY = std::nullopt,
+ Optional<int64_t> blockDimZ = std::nullopt) {
DiagnosedSilenceableFailure diag =
checkGpuLimits(transformOp, gridDimX, gridDimY, gridDimZ, blockDimX,
blockDimY, blockDimZ);
@@ -535,7 +535,7 @@ DiagnosedSilenceableFailure transform::MapNestedForeachToThreads::applyToOne(
blockDim.resize(/*size=*/3, /*value=*/1);
DiagnosedSilenceableFailure diag =
- checkGpuLimits(transformOp, llvm::None, llvm::None, llvm::None,
+ checkGpuLimits(transformOp, std::nullopt, std::nullopt, std::nullopt,
blockDim[0], blockDim[1], blockDim[2]);
if (diag.isSilenceableFailure()) {
results.assign({target});
@@ -557,9 +557,9 @@ DiagnosedSilenceableFailure transform::MapNestedForeachToThreads::applyToOne(
threadMappingAttributes);
if (diag.succeeded()) {
- diag =
- alterGpuLaunch(rewriter, gpuLaunch, transformOp, llvm::None, llvm::None,
- llvm::None, blockDim[0], blockDim[1], blockDim[2]);
+ diag = alterGpuLaunch(rewriter, gpuLaunch, transformOp, std::nullopt,
+ std::nullopt, std::nullopt, blockDim[0], blockDim[1],
+ blockDim[2]);
}
results.assign({gpuLaunch});
diff --git a/mlir/lib/Dialect/GPU/Transforms/SerializeToBlob.cpp b/mlir/lib/Dialect/GPU/Transforms/SerializeToBlob.cpp
index 29f244884ac1..fd745bdad500 100644
--- a/mlir/lib/Dialect/GPU/Transforms/SerializeToBlob.cpp
+++ b/mlir/lib/Dialect/GPU/Transforms/SerializeToBlob.cpp
@@ -41,7 +41,7 @@ gpu::SerializeToBlobPass::translateToISA(llvm::Module &llvmModule,
llvmModule.setDataLayout(targetMachine.createDataLayout());
if (failed(optimizeLlvm(llvmModule, targetMachine)))
- return llvm::None;
+ return std::nullopt;
std::string targetISA;
llvm::raw_string_ostream stream(targetISA);
@@ -52,7 +52,7 @@ gpu::SerializeToBlobPass::translateToISA(llvm::Module &llvmModule,
if (targetMachine.addPassesToEmitFile(codegenPasses, pstream, nullptr,
llvm::CGFT_AssemblyFile))
- return llvm::None;
+ return std::nullopt;
codegenPasses.run(llvmModule);
}
diff --git a/mlir/lib/Dialect/GPU/Transforms/SerializeToHsaco.cpp b/mlir/lib/Dialect/GPU/Transforms/SerializeToHsaco.cpp
index eb33071dc1ae..860d5d7d6080 100644
--- a/mlir/lib/Dialect/GPU/Transforms/SerializeToHsaco.cpp
+++ b/mlir/lib/Dialect/GPU/Transforms/SerializeToHsaco.cpp
@@ -155,7 +155,7 @@ SerializeToHsacoPass::loadLibraries(SmallVectorImpl<char> &path,
if (!llvm::sys::fs::is_directory(path)) {
getOperation().emitRemark() << "Bitcode path: " << path
<< " does not exist or is not a directory\n";
- return llvm::None;
+ return std::nullopt;
}
for (const StringRef file : libraries) {
@@ -168,7 +168,7 @@ SerializeToHsacoPass::loadLibraries(SmallVectorImpl<char> &path,
if (!library) {
getOperation().emitError() << "Failed to load library " << file
<< " from " << path << error.getMessage();
- return llvm::None;
+ return std::nullopt;
}
// Some ROCM builds don't strip this like they should
if (auto *openclVersion = library->getNamedMetadata("opencl.ocl.version"))
diff --git a/mlir/lib/Dialect/Index/IR/IndexOps.cpp b/mlir/lib/Dialect/Index/IR/IndexOps.cpp
index 95148ca82967..3604127fbe74 100644
--- a/mlir/lib/Dialect/Index/IR/IndexOps.cpp
+++ b/mlir/lib/Dialect/Index/IR/IndexOps.cpp
@@ -147,7 +147,7 @@ OpFoldResult DivSOp::fold(ArrayRef<Attribute> operands) {
operands, [](const APInt &lhs, const APInt &rhs) -> Optional<APInt> {
// Don't fold division by zero.
if (rhs.isZero())
- return None;
+ return std::nullopt;
return lhs.sdiv(rhs);
});
}
@@ -161,7 +161,7 @@ OpFoldResult DivUOp::fold(ArrayRef<Attribute> operands) {
operands, [](const APInt &lhs, const APInt &rhs) -> Optional<APInt> {
// Don't fold division by zero.
if (rhs.isZero())
- return None;
+ return std::nullopt;
return lhs.udiv(rhs);
});
}
@@ -175,7 +175,7 @@ OpFoldResult DivUOp::fold(ArrayRef<Attribute> operands) {
static Optional<APInt> calculateCeilDivS(const APInt &n, const APInt &m) {
// Don't fold division by zero.
if (m.isZero())
- return None;
+ return std::nullopt;
// Short-circuit the zero case.
if (n.isZero())
return n;
@@ -207,7 +207,7 @@ OpFoldResult CeilDivUOp::fold(ArrayRef<Attribute> operands) {
operands, [](const APInt &n, const APInt &m) -> Optional<APInt> {
// Don't fold division by zero.
if (m.isZero())
- return None;
+ return std::nullopt;
// Short-circuit the zero case.
if (n.isZero())
return n;
@@ -225,7 +225,7 @@ OpFoldResult CeilDivUOp::fold(ArrayRef<Attribute> operands) {
static Optional<APInt> calculateFloorDivS(const APInt &n, const APInt &m) {
// Don't fold division by zero.
if (m.isZero())
- return None;
+ return std::nullopt;
// Short-circuit the zero case.
if (n.isZero())
return n;
diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
index f9264d5d6015..33b6bcb52276 100644
--- a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
+++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
@@ -776,7 +776,7 @@ static Optional<Type> getLoadStoreElementType(OpAsmParser &parser, Type type,
auto llvmTy = type.dyn_cast<LLVM::LLVMPointerType>();
if (!llvmTy) {
parser.emitError(trailingTypeLoc, "expected LLVM pointer type");
- return llvm::None;
+ return std::nullopt;
}
return llvmTy.getElementType();
}
@@ -2007,7 +2007,7 @@ void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
assert(type.cast<LLVMFunctionType>().getNumParams() == argAttrs.size() &&
"expected as many argument attribute lists as arguments");
function_interface_impl::addArgAndResultAttrs(builder, result, argAttrs,
- /*resultAttrs=*/llvm::None);
+ /*resultAttrs=*/std::nullopt);
}
// Builds an LLVM function type from the given lists of input and output types.
diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp
index 133fc6036931..462102a4f733 100644
--- a/mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp
+++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp
@@ -271,7 +271,7 @@ Optional<unsigned> mlir::LLVM::extractPointerSpecValue(Attribute attr,
auto spec = attr.cast<DenseIntElementsAttr>();
auto idx = static_cast<unsigned>(pos);
if (idx >= spec.size())
- return None;
+ return std::nullopt;
return spec.getValues<unsigned>()[idx];
}
@@ -305,7 +305,7 @@ getPointerDataLayoutEntry(DataLayoutEntryListRef params, LLVMPointerType type,
: kDefaultPointerAlignment;
}
- return llvm::None;
+ return std::nullopt;
}
unsigned
@@ -538,7 +538,7 @@ getStructDataLayoutEntry(DataLayoutEntryListRef params, LLVMStructType type,
return entry.isTypeEntry();
});
if (currentEntry == params.end())
- return llvm::None;
+ return std::nullopt;
auto attr = currentEntry->getValue().cast<DenseIntElementsAttr>();
if (pos == StructDLEntryPos::Preferred &&
diff --git a/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp
index f80ad4067546..62d5be553691 100644
--- a/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp
+++ b/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp
@@ -92,16 +92,16 @@ Optional<mlir::NVVM::MMATypes> MmaOp::inferOperandMMAType(Type operandElType,
if (operandElType.isa<IntegerType>()) {
if (isAccumulator)
return NVVM::MMATypes::s32;
- return llvm::None;
+ return std::nullopt;
}
if (auto structType = operandElType.dyn_cast<LLVM::LLVMStructType>()) {
if (structType.getBody().empty())
- return llvm::None;
+ return std::nullopt;
return inferOperandMMAType(structType.getBody()[0], isAccumulator);
}
- return llvm::None;
+ return std::nullopt;
}
static bool isInt4PtxType(MMATypes type) {
diff --git a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp
index 98734baed1ad..b46349874bd4 100644
--- a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp
+++ b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp
@@ -1226,7 +1226,7 @@ transform::TileReductionUsingForeachThreadOp::applyToOne(
FailureOr<linalg::ForeachThreadReductionTilingResult> result =
linalg::tileReductionUsingForeachThread(
rewriter, cast<PartialReductionOpInterface>(target.getOperation()),
- numThreadResults, /*mapping=*/llvm::None);
+ numThreadResults, /*mapping=*/std::nullopt);
if (failed(result)) {
results.assign(3, nullptr);
diff --git a/mlir/lib/Dialect/Linalg/Transforms/ConstantFold.cpp b/mlir/lib/Dialect/Linalg/Transforms/ConstantFold.cpp
index a127bd2dc652..b7c24b1967da 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/ConstantFold.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/ConstantFold.cpp
@@ -291,8 +291,8 @@ struct FoldConstantTranspose : public FoldConstantBase<FoldConstantTranspose> {
// No computation; just return the orginal value.
return [](const APIntOrFloatArray &inputs) {
if (inputs.apFloats.empty())
- return APIntOrFloat{inputs.apInts.front(), llvm::None};
- return APIntOrFloat{llvm::None, inputs.apFloats.front()};
+ return APIntOrFloat{inputs.apInts.front(), std::nullopt};
+ return APIntOrFloat{std::nullopt, inputs.apFloats.front()};
};
}
diff --git a/mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp b/mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp
index b0e45d1c107b..f0cd9ca13977 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp
@@ -386,7 +386,7 @@ replaceUnitExtents(GenericOp genericOp, OpOperand *opOperand,
Type actualType = opOperand->get().getType();
if (auto memref = actualType.dyn_cast<MemRefType>()) {
if (!memref.getLayout().isIdentity())
- return llvm::None;
+ return std::nullopt;
}
int64_t dim = 0;
diff --git a/mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp b/mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp
index f391b2cc01c9..43d01205dfad 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp
@@ -734,10 +734,10 @@ fuseWithReshapeByExpansion(GenericOp genericOp, Operation *reshapeOp,
isExpanding ? expandingReshapeOp.getReassociationMaps()
: collapsingReshapeOp.getReassociationMaps(),
expandedType.getShape(), collapsedType.getShape(), rewriter)))
- return llvm::None;
+ return std::nullopt;
if (failed(isGenericOpExpandable(genericOp, expansionInfo, rewriter)))
- return llvm::None;
+ return std::nullopt;
SmallVector<AffineMap, 4> expandedOpIndexingMaps = llvm::to_vector<4>(
llvm::map_range(genericOp.getIndexingMapsArray(), [&](AffineMap m) {
@@ -772,7 +772,7 @@ fuseWithReshapeByExpansion(GenericOp genericOp, Operation *reshapeOp,
opOperandType.getShape(), expandedOperandType.getShape(),
reassociation,
/*isExpandingReshape=*/true)))
- return llvm::None;
+ return std::nullopt;
expandedOpOperands.push_back(rewriter.create<tensor::ExpandShapeOp>(
genericOp.getLoc(), expandedOperandType, opOperand->get(),
reassociation));
@@ -799,7 +799,7 @@ fuseWithReshapeByExpansion(GenericOp genericOp, Operation *reshapeOp,
opOperandType.getShape(), expandedOutputType.getShape(),
reassociation,
/*isExpandingReshape=*/true)))
- return llvm::None;
+ return std::nullopt;
outputs.push_back(rewriter.create<tensor::ExpandShapeOp>(
genericOp.getLoc(), expandedOutputType, opOperand->get(),
reassociation));
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp b/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp
index 5b623a9413b8..5c8b72d80d21 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp
@@ -44,7 +44,7 @@ using llvm::MapVector;
static Value allocBuffer(ImplicitLocOpBuilder &b,
const LinalgPromotionOptions &options,
Type elementType, Value allocSize, DataLayout &layout,
- Optional<unsigned> alignment = None) {
+ Optional<unsigned> alignment = std::nullopt) {
auto width = layout.getTypeSize(elementType);
IntegerAttr alignmentAttr;
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp b/mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp
index e87d4f92b6c0..cde33ce740e7 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp
@@ -382,8 +382,8 @@ FailureOr<ForeachThreadTilingResult>
linalg::tileToForeachThreadOp(RewriterBase &b, TilingInterface op,
ArrayRef<OpFoldResult> numThreads,
Optional<ArrayAttr> mapping) {
- return tileToForeachThreadOpImpl(b, op, numThreads, /*nominalTileSizes=*/None,
- mapping,
+ return tileToForeachThreadOpImpl(b, op, numThreads,
+ /*nominalTileSizes=*/std::nullopt, mapping,
/*omitTileOffsetBoundsCheck=*/false);
}
@@ -467,7 +467,7 @@ linalg::tileReductionUsingForeachThread(RewriterBase &b,
calculateTileOffsetsAndSizes(
b, loc, foreachThreadOp, numThreads, iterationDomain,
/*omitTileOffsetBoundsCheck =*/false,
- /*nominalTileSizes=*/llvm::None, tiledOffsets, tiledSizes);
+ /*nominalTileSizes=*/std::nullopt, tiledOffsets, tiledSizes);
// 4. Clone the tileable op and update its destination operands to use the
// output bbArgs of the ForeachThreadOp.
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp b/mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp
index ca8911775c26..ad52a5a28c34 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp
@@ -123,7 +123,7 @@ mlir::linalg::getCombinerOpKind(Operation *combinerOp) {
using ::mlir::vector::CombiningKind;
if (!combinerOp)
- return llvm::None;
+ return std::nullopt;
return llvm::TypeSwitch<Operation *, llvm::Optional<CombiningKind>>(
combinerOp)
.Case<arith::AddIOp, arith::AddFOp>(
@@ -137,7 +137,7 @@ mlir::linalg::getCombinerOpKind(Operation *combinerOp) {
[&](auto op) { return CombiningKind::MUL; })
.Case<arith::OrIOp>([&](auto op) { return CombiningKind::OR; })
.Case<arith::XOrIOp>([&](auto op) { return CombiningKind::XOR; })
- .Default([&](auto op) { return llvm::None; });
+ .Default([&](auto op) { return std::nullopt; });
}
/// Check whether `outputOperand` is a reduction with a single combiner
diff --git a/mlir/lib/Dialect/Linalg/Utils/Utils.cpp b/mlir/lib/Dialect/Linalg/Utils/Utils.cpp
index 3267b2aff075..420b02b8502d 100644
--- a/mlir/lib/Dialect/Linalg/Utils/Utils.cpp
+++ b/mlir/lib/Dialect/Linalg/Utils/Utils.cpp
@@ -106,17 +106,17 @@ Optional<RegionMatcher::BinaryOpKind>
RegionMatcher::matchAsScalarBinaryOp(GenericOp op) {
auto ®ion = op.getRegion();
if (!llvm::hasSingleElement(region))
- return llvm::None;
+ return std::nullopt;
Block &block = region.front();
if (block.getNumArguments() != 2 ||
!block.getArgument(0).getType().isSignlessIntOrFloat() ||
!block.getArgument(1).getType().isSignlessIntOrFloat())
- return llvm::None;
+ return std::nullopt;
auto &ops = block.getOperations();
if (!llvm::hasSingleElement(block.without_terminator()))
- return llvm::None;
+ return std::nullopt;
using mlir::matchers::m_Val;
auto a = m_Val(block.getArgument(0));
@@ -126,7 +126,7 @@ RegionMatcher::matchAsScalarBinaryOp(GenericOp op) {
if (addPattern.match(&ops.back()))
return BinaryOpKind::IAdd;
- return llvm::None;
+ return std::nullopt;
}
/// Explicit instantiation of loop nest generator for
diff erent loop types.
@@ -966,7 +966,7 @@ computeAllSliceParameters(OpBuilder &builder, Location loc, LinalgOp linalgOp,
Type operandType = opOperand.get().getType();
if (!isTiled(map, tileSizes) && !(operandType.isa<RankedTensorType>() &&
linalgOp.isDpsInit(&opOperand))) {
- allSliceParams.push_back(llvm::None);
+ allSliceParams.push_back(std::nullopt);
LLVM_DEBUG(llvm::dbgs()
<< ": not tiled: use shape: " << operandType << "\n");
continue;
@@ -1088,7 +1088,7 @@ Optional<Attribute> getNeutralElement(Operation *op) {
return b.getIntegerAttr(resultType, std::numeric_limits<int64_t>::max());
if (isa<arith::MulIOp>(op))
return b.getIntegerAttr(resultType, 1);
- return llvm::None;
+ return std::nullopt;
}
} // namespace linalg
diff --git a/mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp b/mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp
index c8334496bd3c..b5d1dfd9bb24 100644
--- a/mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp
+++ b/mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp
@@ -50,7 +50,7 @@ llvm::Optional<Operation *> mlir::memref::findDealloc(Value allocValue) {
continue;
// If we found > 1 dealloc, return None.
if (dealloc)
- return llvm::None;
+ return std::nullopt;
dealloc = user;
}
return dealloc;
diff --git a/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp b/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp
index 4ba4050bb45e..223aec3d8cfe 100644
--- a/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp
+++ b/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp
@@ -986,7 +986,7 @@ computeMemRefRankReductionMask(MemRefType originalType, MemRefType reducedType,
getStridesAndOffset(originalType, originalStrides, originalOffset)) ||
failed(
getStridesAndOffset(reducedType, candidateStrides, candidateOffset)))
- return llvm::None;
+ return std::nullopt;
// For memrefs, a dimension is truly dropped if its corresponding stride is
// also dropped. This is particularly important when more than one of the dims
@@ -1021,13 +1021,13 @@ computeMemRefRankReductionMask(MemRefType originalType, MemRefType reducedType,
candidateStridesNumOccurences[originalStride]) {
// This should never happen. Cant have a stride in the reduced rank type
// that wasnt in the original one.
- return llvm::None;
+ return std::nullopt;
}
}
if ((int64_t)unusedDims.count() + reducedType.getRank() !=
originalType.getRank())
- return llvm::None;
+ return std::nullopt;
return unusedDims;
}
diff --git a/mlir/lib/Dialect/MemRef/Transforms/EmulateWideInt.cpp b/mlir/lib/Dialect/MemRef/Transforms/EmulateWideInt.cpp
index 02c6e5873bea..3de4b806cb52 100644
--- a/mlir/lib/Dialect/MemRef/Transforms/EmulateWideInt.cpp
+++ b/mlir/lib/Dialect/MemRef/Transforms/EmulateWideInt.cpp
@@ -156,8 +156,8 @@ void memref::populateMemRefWideIntEmulationConversions(
Type newElemTy = typeConverter.convertType(intTy);
if (!newElemTy)
- return None;
+ return std::nullopt;
- return ty.cloneWith(None, newElemTy);
+ return ty.cloneWith(std::nullopt, newElemTy);
});
}
diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
index b91920325bc1..7a5de2f3c0e2 100644
--- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
+++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
@@ -134,7 +134,7 @@ static OptionalParseResult parseOptionalOperandAndType(OpAsmParser &parser,
return failure(parser.parseLParen() ||
parseOperandAndType(parser, result) || parser.parseRParen());
}
- return llvm::None;
+ return std::nullopt;
}
/// Parse optional operand and its type wrapped in parenthesis.
@@ -145,7 +145,7 @@ static OptionalParseResult parseOptionalOperandAndType(OpAsmParser &parser,
if (succeeded(parser.parseOptionalLParen())) {
return failure(parseOperandAndType(parser, result) || parser.parseRParen());
}
- return llvm::None;
+ return std::nullopt;
}
/// Parse optional operand with its type prefixed with prefixKeyword `=`.
@@ -158,7 +158,7 @@ static OptionalParseResult parserOptionalOperandAndTypeWithPrefix(
return failure();
return success();
}
- return llvm::None;
+ return std::nullopt;
}
static bool isComputeOperation(Operation *op) {
diff --git a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
index 500843058b90..d10dc1bcd8d4 100644
--- a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
+++ b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
@@ -312,12 +312,12 @@ static ParseResult parseScheduleClause(
if (parser.parseOperand(*chunkSize) || parser.parseColonType(chunkType))
return failure();
} else {
- chunkSize = llvm::None;
+ chunkSize = std::nullopt;
}
break;
case ClauseScheduleKind::Auto:
case ClauseScheduleKind::Runtime:
- chunkSize = llvm::None;
+ chunkSize = std::nullopt;
}
// If there is a comma, we have one or more modifiers..
diff --git a/mlir/lib/Dialect/SCF/IR/SCF.cpp b/mlir/lib/Dialect/SCF/IR/SCF.cpp
index d8e22cf14894..97313e191fe2 100644
--- a/mlir/lib/Dialect/SCF/IR/SCF.cpp
+++ b/mlir/lib/Dialect/SCF/IR/SCF.cpp
@@ -583,7 +583,7 @@ LoopNest mlir::scf::buildLoopNest(
ValueRange steps,
function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuilder) {
// Delegate to the main function by wrapping the body builder.
- return buildLoopNest(builder, loc, lbs, ubs, steps, llvm::None,
+ return buildLoopNest(builder, loc, lbs, ubs, steps, std::nullopt,
[&bodyBuilder](OpBuilder &nestedBuilder,
Location nestedLoc, ValueRange ivs,
ValueRange) -> ValueVector {
@@ -736,7 +736,7 @@ static Optional<int64_t> computeConstDiff(Value l, Value u) {
matchPattern(
u, m_Op<arith::AddIOp>(m_ConstantInt(&
diff ), matchers::m_Val(l))))
return
diff .getSExtValue();
- return llvm::None;
+ return std::nullopt;
}
/// Rewriting pattern that erases loops that are known not to iterate, replaces
@@ -1451,7 +1451,7 @@ bool mlir::scf::insideMutuallyExclusiveBranches(Operation *a, Operation *b) {
void IfOp::build(OpBuilder &builder, OperationState &result, Value cond,
bool withElseRegion) {
- build(builder, result, /*resultTypes=*/llvm::None, cond, withElseRegion);
+ build(builder, result, /*resultTypes=*/std::nullopt, cond, withElseRegion);
}
void IfOp::build(OpBuilder &builder, OperationState &result,
@@ -2595,7 +2595,8 @@ struct MergeNestedParallelLoops : public OpRewritePattern<ParallelOp> {
auto newSteps = concatValues(op.getStep(), innerOp.getStep());
rewriter.replaceOpWithNewOp<ParallelOp>(op, newLowerBounds, newUpperBounds,
- newSteps, llvm::None, bodyBuilder);
+ newSteps, std::nullopt,
+ bodyBuilder);
return success();
}
};
diff --git a/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp b/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
index ac3d76d56922..381f2316e94a 100644
--- a/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
@@ -127,7 +127,7 @@ class ConvertForOpTypes
// convertRegionTypes already takes care of 1:N conversion.
if (failed(rewriter.convertRegionTypes(&op.getLoopBody(), *typeConverter)))
- return llvm::None;
+ return std::nullopt;
// Unpacked the iteration arguments.
SmallVector<Value> flatArgs;
@@ -201,7 +201,7 @@ class ConvertWhileOpTypes
for (auto i : {0u, 1u}) {
if (failed(rewriter.convertRegionTypes(&op.getRegion(i), *typeConverter)))
- return llvm::None;
+ return std::nullopt;
auto &dstRegion = newOp.getRegion(i);
rewriter.inlineRegionBefore(op.getRegion(i), dstRegion, dstRegion.end());
}
diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp
index d03ffd0d0869..3481bb371993 100644
--- a/mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp
+++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp
@@ -156,7 +156,7 @@ Optional<spirv::StorageClass> spirv::InterfaceVarABIAttr::getStorageClass() {
if (getImpl()->storageClass)
return static_cast<spirv::StorageClass>(
getImpl()->storageClass.cast<IntegerAttr>().getValue().getZExtValue());
- return llvm::None;
+ return std::nullopt;
}
LogicalResult spirv::InterfaceVarABIAttr::verify(
diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp
index b068d23f0e9f..306434c0297c 100644
--- a/mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp
+++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp
@@ -30,14 +30,14 @@ using namespace mlir;
/// or splat vector bool constant.
static Optional<bool> getScalarOrSplatBoolAttr(Attribute attr) {
if (!attr)
- return llvm::None;
+ return std::nullopt;
if (auto boolAttr = attr.dyn_cast<BoolAttr>())
return boolAttr.getValue();
if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>())
if (splatAttr.getElementType().isInteger(1))
return splatAttr.getSplatValue<bool>();
- return llvm::None;
+ return std::nullopt;
}
// Extracts an element from the given `composite` by following the given
diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp
index d911ea7f90ed..c5fffdf26c92 100644
--- a/mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp
+++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp
@@ -479,7 +479,7 @@ static Optional<ValTy> parseAndVerify(SPIRVDialect const &dialect,
StringRef enumSpec;
SMLoc enumLoc = parser.getCurrentLocation();
if (parser.parseKeyword(&enumSpec)) {
- return llvm::None;
+ return std::nullopt;
}
auto val = spirv::symbolizeEnum<ValTy>(enumSpec);
@@ -494,7 +494,7 @@ Optional<Type> parseAndVerify<Type>(SPIRVDialect const &dialect,
// TODO: Further verify that the element type can be sampled
auto ty = parseAndVerifyType(dialect, parser);
if (!ty)
- return llvm::None;
+ return std::nullopt;
return ty;
}
@@ -503,7 +503,7 @@ static Optional<IntTy> parseAndVerifyInteger(SPIRVDialect const &dialect,
DialectAsmParser &parser) {
IntTy offsetVal = std::numeric_limits<IntTy>::max();
if (parser.parseInteger(offsetVal))
- return llvm::None;
+ return std::nullopt;
return offsetVal;
}
@@ -524,14 +524,14 @@ struct ParseCommaSeparatedList {
operator()(SPIRVDialect const &dialect, DialectAsmParser &parser) const {
auto parseVal = parseAndVerify<ParseType>(dialect, parser);
if (!parseVal)
- return llvm::None;
+ return std::nullopt;
auto numArgs = std::tuple_size<std::tuple<Args...>>::value;
if (numArgs != 0 && failed(parser.parseComma()))
- return llvm::None;
+ return std::nullopt;
auto remainingValues = ParseCommaSeparatedList<Args...>{}(dialect, parser);
if (!remainingValues)
- return llvm::None;
+ return std::nullopt;
return std::tuple_cat(std::tuple<ParseType>(parseVal.value()),
remainingValues.value());
}
@@ -545,7 +545,7 @@ struct ParseCommaSeparatedList<ParseType> {
DialectAsmParser &parser) const {
if (auto value = parseAndVerify<ParseType>(dialect, parser))
return std::tuple<ParseType>(*value);
- return llvm::None;
+ return std::nullopt;
}
};
} // namespace
diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
index 6bb25a9fafbf..c87ac89efe17 100644
--- a/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
+++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
@@ -311,8 +311,8 @@ template <typename MemoryOpTy>
static void printMemoryAccessAttribute(
MemoryOpTy memoryOp, OpAsmPrinter &printer,
SmallVectorImpl<StringRef> &elidedAttrs,
- Optional<spirv::MemoryAccess> memoryAccessAtrrValue = None,
- Optional<uint32_t> alignmentAttrValue = None) {
+ Optional<spirv::MemoryAccess> memoryAccessAtrrValue = std::nullopt,
+ Optional<uint32_t> alignmentAttrValue = std::nullopt) {
// Print optional memory access attribute.
if (auto memAccess = (memoryAccessAtrrValue ? memoryAccessAtrrValue
: memoryOp.getMemoryAccess())) {
@@ -341,8 +341,8 @@ template <typename MemoryOpTy>
static void printSourceMemoryAccessAttribute(
MemoryOpTy memoryOp, OpAsmPrinter &printer,
SmallVectorImpl<StringRef> &elidedAttrs,
- Optional<spirv::MemoryAccess> memoryAccessAtrrValue = None,
- Optional<uint32_t> alignmentAttrValue = None) {
+ Optional<spirv::MemoryAccess> memoryAccessAtrrValue = std::nullopt,
+ Optional<uint32_t> alignmentAttrValue = std::nullopt) {
printer << ", ";
diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp
index 6c1a8f00bb95..40082b1cb36a 100644
--- a/mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp
+++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp
@@ -80,7 +80,7 @@ Optional<int64_t> ArrayType::getSizeInBytes() {
auto elementType = getElementType().cast<SPIRVType>();
Optional<int64_t> size = elementType.getSizeInBytes();
if (!size)
- return llvm::None;
+ return std::nullopt;
return (*size + getArrayStride()) * getNumElements();
}
@@ -194,10 +194,10 @@ Optional<int64_t> CompositeType::getSizeInBytes() {
Optional<int64_t> elementSize =
vectorType.getElementType().cast<ScalarType>().getSizeInBytes();
if (!elementSize)
- return llvm::None;
+ return std::nullopt;
return *elementSize * vectorType.getNumElements();
}
- return llvm::None;
+ return std::nullopt;
}
//===----------------------------------------------------------------------===//
@@ -716,7 +716,7 @@ Optional<int64_t> ScalarType::getSizeInBytes() {
// non-externally visible shader Storage Classes: Workgroup, CrossWorkgroup,
// Private, Function, Input, and Output."
if (bitWidth == 1)
- return llvm::None;
+ return std::nullopt;
return bitWidth / 8;
}
@@ -783,7 +783,7 @@ Optional<int64_t> SPIRVType::getSizeInBytes() {
return scalarType.getSizeInBytes();
if (auto compositeType = dyn_cast<CompositeType>())
return compositeType.getSizeInBytes();
- return llvm::None;
+ return std::nullopt;
}
//===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Dialect/SPIRV/IR/TargetAndABI.cpp b/mlir/lib/Dialect/SPIRV/IR/TargetAndABI.cpp
index ef13a57fcdac..ee7720fd39f5 100644
--- a/mlir/lib/Dialect/SPIRV/IR/TargetAndABI.cpp
+++ b/mlir/lib/Dialect/SPIRV/IR/TargetAndABI.cpp
@@ -54,7 +54,7 @@ spirv::TargetEnv::allows(ArrayRef<spirv::Capability> caps) const {
});
if (chosen != caps.end())
return *chosen;
- return llvm::None;
+ return std::nullopt;
}
bool spirv::TargetEnv::allows(spirv::Extension extension) const {
@@ -68,7 +68,7 @@ spirv::TargetEnv::allows(ArrayRef<spirv::Extension> exts) const {
});
if (chosen != exts.end())
return *chosen;
- return llvm::None;
+ return std::nullopt;
}
spirv::Vendor spirv::TargetEnv::getVendorID() const {
@@ -163,8 +163,8 @@ spirv::getDefaultResourceLimits(MLIRContext *context) {
/*max_compute_workgroup_invocations=*/128,
/*max_compute_workgroup_size=*/b.getI32ArrayAttr({128, 128, 64}),
/*subgroup_size=*/32,
- /*min_subgroup_size=*/llvm::None,
- /*max_subgroup_size=*/llvm::None,
+ /*min_subgroup_size=*/std::nullopt,
+ /*max_subgroup_size=*/std::nullopt,
/*cooperative_matrix_properties_nv=*/ArrayAttr());
}
diff --git a/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp b/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp
index b383c641929e..efc340c87d13 100644
--- a/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp
+++ b/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp
@@ -170,7 +170,7 @@ static LogicalResult lowerEntryPointABIAttr(spirv::FuncOp funcOp,
// Erase subgroup size.
entryPointAttr = spirv::EntryPointABIAttr::get(
entryPointAttr.getContext(), entryPointAttr.getWorkgroupSize(),
- llvm::None);
+ std::nullopt);
}
}
if (entryPointAttr.getWorkgroupSize() || entryPointAttr.getSubgroupSize())
@@ -262,7 +262,7 @@ LogicalResult ProcessInterfaceVarABI::matchAndRewrite(
// Creates a new function with the update signature.
rewriter.updateRootInPlace(funcOp, [&] {
funcOp.setType(rewriter.getFunctionType(
- signatureConverter.getConvertedTypes(), llvm::None));
+ signatureConverter.getConvertedTypes(), std::nullopt));
});
return success();
}
diff --git a/mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp b/mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp
index 5d931ac5f399..2772c0150cda 100644
--- a/mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp
+++ b/mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp
@@ -140,14 +140,14 @@ static Optional<int64_t> getTypeNumBytes(const SPIRVConversionOptions &options,
// non-externally visible shader Storage Classes: Workgroup, CrossWorkgroup,
// Private, Function, Input, and Output."
if (bitWidth == 1)
- return llvm::None;
+ return std::nullopt;
return bitWidth / 8;
}
if (auto vecType = type.dyn_cast<VectorType>()) {
auto elementSize = getTypeNumBytes(options, vecType.getElementType());
if (!elementSize)
- return llvm::None;
+ return std::nullopt;
return vecType.getNumElements() * *elementSize;
}
@@ -158,14 +158,14 @@ static Optional<int64_t> getTypeNumBytes(const SPIRVConversionOptions &options,
SmallVector<int64_t, 4> strides;
if (!memRefType.hasStaticShape() ||
failed(getStridesAndOffset(memRefType, strides, offset)))
- return llvm::None;
+ return std::nullopt;
// To get the size of the memref object in memory, the total size is the
// max(stride * dimension-size) computed for all dimensions times the size
// of the element.
auto elementSize = getTypeNumBytes(options, memRefType.getElementType());
if (!elementSize)
- return llvm::None;
+ return std::nullopt;
if (memRefType.getRank() == 0)
return elementSize;
@@ -174,7 +174,7 @@ static Optional<int64_t> getTypeNumBytes(const SPIRVConversionOptions &options,
if (llvm::is_contained(dims, ShapedType::kDynamic) ||
ShapedType::isDynamic(offset) ||
llvm::is_contained(strides, ShapedType::kDynamic))
- return llvm::None;
+ return std::nullopt;
int64_t memrefSize = -1;
for (const auto &shape : enumerate(dims))
@@ -185,11 +185,11 @@ static Optional<int64_t> getTypeNumBytes(const SPIRVConversionOptions &options,
if (auto tensorType = type.dyn_cast<TensorType>()) {
if (!tensorType.hasStaticShape())
- return llvm::None;
+ return std::nullopt;
auto elementSize = getTypeNumBytes(options, tensorType.getElementType());
if (!elementSize)
- return llvm::None;
+ return std::nullopt;
int64_t size = *elementSize;
for (auto shape : tensorType.getShape())
@@ -199,7 +199,7 @@ static Optional<int64_t> getTypeNumBytes(const SPIRVConversionOptions &options,
}
// TODO: Add size computation for other types.
- return llvm::None;
+ return std::nullopt;
}
/// Converts a scalar `type` to a suitable type under the given `targetEnv`.
diff --git a/mlir/lib/Dialect/SPIRV/Transforms/UnifyAliasedResourcePass.cpp b/mlir/lib/Dialect/SPIRV/Transforms/UnifyAliasedResourcePass.cpp
index 9c437941a72f..7330b399cde2 100644
--- a/mlir/lib/Dialect/SPIRV/Transforms/UnifyAliasedResourcePass.cpp
+++ b/mlir/lib/Dialect/SPIRV/Transforms/UnifyAliasedResourcePass.cpp
@@ -98,11 +98,12 @@ static Optional<int> deduceCanonicalResource(ArrayRef<spirv::SPIRVType> types) {
assert(type.isScalarOrVector());
if (auto vectorType = type.dyn_cast<VectorType>()) {
if (vectorType.getNumElements() % 2 != 0)
- return llvm::None; // Odd-sized vector has special layout requirements.
+ return std::nullopt; // Odd-sized vector has special layout
+ // requirements.
Optional<int64_t> numBytes = type.getSizeInBytes();
if (!numBytes)
- return llvm::None;
+ return std::nullopt;
scalarNumBits.push_back(
vectorType.getElementType().getIntOrFloatBitWidth());
@@ -122,7 +123,7 @@ static Optional<int> deduceCanonicalResource(ArrayRef<spirv::SPIRVType> types) {
// With out this, we cannot properly adjust the index later.
if (llvm::any_of(vectorNumBits,
[&](int bits) { return bits % *minVal != 0; }))
- return llvm::None;
+ return std::nullopt;
// Require all scalar type bit counts to be a multiple of the chosen
// vector's primitive type to avoid reading/writing subcomponents.
@@ -130,7 +131,7 @@ static Optional<int> deduceCanonicalResource(ArrayRef<spirv::SPIRVType> types) {
int baseNumBits = scalarNumBits[index];
if (llvm::any_of(scalarNumBits,
[&](int bits) { return bits % baseNumBits != 0; }))
- return llvm::None;
+ return std::nullopt;
return index;
}
@@ -140,7 +141,7 @@ static Optional<int> deduceCanonicalResource(ArrayRef<spirv::SPIRVType> types) {
auto *minVal = std::min_element(scalarNumBits.begin(), scalarNumBits.end());
if (llvm::any_of(scalarNumBits,
[minVal](int64_t bit) { return bit % *minVal != 0; }))
- return llvm::None;
+ return std::nullopt;
return std::distance(scalarNumBits.begin(), minVal);
}
diff --git a/mlir/lib/Dialect/Shape/IR/Shape.cpp b/mlir/lib/Dialect/Shape/IR/Shape.cpp
index 5c1a9fa85a1b..8c89ec8bba6c 100644
--- a/mlir/lib/Dialect/Shape/IR/Shape.cpp
+++ b/mlir/lib/Dialect/Shape/IR/Shape.cpp
@@ -1073,7 +1073,7 @@ Optional<int64_t> DimOp::getConstantIndex() {
return constSizeOp.getValue().getLimitedValue();
if (auto constantOp = getIndex().getDefiningOp<arith::ConstantOp>())
return constantOp.getValue().cast<IntegerAttr>().getInt();
- return llvm::None;
+ return std::nullopt;
}
OpFoldResult DimOp::fold(ArrayRef<Attribute> operands) {
@@ -1301,7 +1301,7 @@ void FuncOp::build(OpBuilder &builder, OperationState &state, StringRef name,
return;
assert(type.getNumInputs() == argAttrs.size());
function_interface_impl::addArgAndResultAttrs(builder, state, argAttrs,
- /*resultAttrs=*/llvm::None);
+ /*resultAttrs=*/std::nullopt);
}
ParseResult FuncOp::parse(OpAsmParser &parser, OperationState &result) {
@@ -1327,7 +1327,7 @@ Optional<int64_t> GetExtentOp::getConstantDim() {
return constSizeOp.getValue().getLimitedValue();
if (auto constantOp = getDim().getDefiningOp<arith::ConstantOp>())
return constantOp.getValue().cast<IntegerAttr>().getInt();
- return llvm::None;
+ return std::nullopt;
}
OpFoldResult GetExtentOp::fold(ArrayRef<Attribute> operands) {
diff --git a/mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp b/mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp
index 599de1e5fee3..44e52207537f 100644
--- a/mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp
+++ b/mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp
@@ -608,7 +608,7 @@ void ForeachOp::build(
OpBuilder &builder, OperationState &result, Value tensor,
function_ref<void(OpBuilder &, Location, ValueRange, Value, ValueRange)>
bodyBuilder) {
- build(builder, result, tensor, llvm::None, bodyBuilder);
+ build(builder, result, tensor, std::nullopt, bodyBuilder);
}
void ForeachOp::build(
diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp
index cb4dafbc7b62..52dd6647166b 100644
--- a/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp
@@ -122,7 +122,7 @@ static Optional<Value> sizeFromTensorAtDim(OpBuilder &builder, Location loc,
Value adaptedValue, unsigned dim) {
auto enc = getSparseTensorEncoding(tensorTp);
if (!enc)
- return llvm::None;
+ return std::nullopt;
// Access into static dimension can query original type directly.
// Note that this is typically already done by DimOp's folding.
@@ -200,7 +200,7 @@ static Optional<LogicalResult>
convertSparseTensorType(Type type, SmallVectorImpl<Type> &fields) {
auto enc = getSparseTensorEncoding(type);
if (!enc)
- return llvm::None;
+ return std::nullopt;
// Construct the basic types.
auto *context = type.getContext();
RankedTensorType rType = type.cast<RankedTensorType>();
@@ -1105,7 +1105,7 @@ mlir::SparseTensorTypeToBufferConverter::SparseTensorTypeToBufferConverter() {
Location loc) -> Optional<Value> {
if (!getSparseTensorEncoding(tp))
// Not a sparse tensor.
- return llvm::None;
+ return std::nullopt;
// Sparse compiler knows how to cancel out these casts.
return genTuple(builder, loc, tp, inputs);
});
diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp
index 40570fc42cd3..5017d0e63552 100644
--- a/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp
@@ -42,7 +42,7 @@ namespace {
static Optional<Type> convertSparseTensorTypes(Type type) {
if (getSparseTensorEncoding(type) != nullptr)
return LLVM::LLVMPointerType::get(IntegerType::get(type.getContext(), 8));
- return llvm::None;
+ return std::nullopt;
}
/// Replaces the `op` with a `CallOp` to the function reference returned
diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp
index b65bcaccf40d..b7461ec3740c 100644
--- a/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp
@@ -695,7 +695,7 @@ struct ConvertRewriter : public OpRewritePattern<ConvertOp> {
Block *insertionBlock = rewriter.getInsertionBlock();
bool noEscape = bufferization::allocationDoesNotEscape(op->getOpResult(0));
- rewriter.create<ForeachOp>(loc, src, llvm::None,
+ rewriter.create<ForeachOp>(loc, src, std::nullopt,
[&](OpBuilder &builder, Location loc,
ValueRange args, Value v, ValueRange reduc) {
builder.create<memref::StoreOp>(loc, v, dst,
@@ -1065,7 +1065,7 @@ struct OutRewriter : public OpRewritePattern<OutOp> {
ModuleOp module = op->getParentOfType<ModuleOp>();
// For each element in the source tensor, output the element.
rewriter.create<ForeachOp>(
- loc, src, llvm::None,
+ loc, src, std::nullopt,
[&](OpBuilder &builder, Location loc, ValueRange args, Value v,
ValueRange reduc) {
for (uint64_t i = 0; i < rank; i++) {
diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp
index 94ac0ccecab3..81f3845eebec 100644
--- a/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp
@@ -508,7 +508,8 @@ static bool computeIterationGraph(Merger &merger, linalg::GenericOp op,
if (tldx && merger.isFilterLoop(tldx.value())) {
assert(!ta.isa<AffineDimExpr>() &&
!isDenseDLT(getDimLevelType(enc, d)));
- addAffineOrderings(adjM, inDegree, ta, AffineExpr(), llvm::None, tldx);
+ addAffineOrderings(adjM, inDegree, ta, AffineExpr(), std::nullopt,
+ tldx);
// Now that the ordering of affine expression is captured by filter
// loop idx, we only need to ensure the affine ordering against filter
// loop. Thus, we reset the affine express to nil here to mark it as
@@ -1532,7 +1533,7 @@ static bool endLoop(Merger &merger, CodeGen &codegen, RewriterBase &rewriter,
genLoopBoundary(codegen, merger, [&](MutableArrayRef<Value> reduc) {
codegen.loopEmitter.exitCurrentLoop(rewriter, op.getLoc(), reduc);
- return llvm::None;
+ return std::nullopt;
});
return needsUniv;
diff --git a/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp b/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
index 8b86840520ae..35530bf4ed3b 100644
--- a/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
@@ -1071,7 +1071,7 @@ Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) {
}
}
// Cannot build.
- return None;
+ return std::nullopt;
}
static Value insertYieldOp(RewriterBase &rewriter, Location loc, Region ®ion,
diff --git a/mlir/lib/Dialect/Tensor/IR/TensorOps.cpp b/mlir/lib/Dialect/Tensor/IR/TensorOps.cpp
index 9b7cad34c5d4..9841165668a9 100644
--- a/mlir/lib/Dialect/Tensor/IR/TensorOps.cpp
+++ b/mlir/lib/Dialect/Tensor/IR/TensorOps.cpp
@@ -2330,7 +2330,7 @@ struct InsertSliceOpCastFolder final : public OpRewritePattern<InsertOpTy> {
auto getSourceOfCastOp = [](Value v) -> Optional<Value> {
auto castOp = v.getDefiningOp<tensor::CastOp>();
if (!castOp || !canFoldIntoConsumerOp(castOp))
- return llvm::None;
+ return std::nullopt;
return castOp.getSource();
};
Optional<Value> sourceCastSource =
diff --git a/mlir/lib/Dialect/Traits.cpp b/mlir/lib/Dialect/Traits.cpp
index 5c18fcff7c41..b763f2bb1b3b 100644
--- a/mlir/lib/Dialect/Traits.cpp
+++ b/mlir/lib/Dialect/Traits.cpp
@@ -152,7 +152,7 @@ Type OpTrait::util::getBroadcastedType(Type type1, Type type2,
auto getCompositeTypeKind = [](Type type) -> Optional<TypeID> {
if (type.isa<VectorType, RankedTensorType>())
return type.getTypeID();
- return llvm::None;
+ return std::nullopt;
};
// Make sure the composite type, if has, is consistent.
diff --git a/mlir/lib/Dialect/Utils/IndexingUtils.cpp b/mlir/lib/Dialect/Utils/IndexingUtils.cpp
index ed92ade8ab09..3f8015cccba3 100644
--- a/mlir/lib/Dialect/Utils/IndexingUtils.cpp
+++ b/mlir/lib/Dialect/Utils/IndexingUtils.cpp
@@ -34,7 +34,7 @@ SmallVector<int64_t> mlir::computeElementwiseMul(ArrayRef<int64_t> v1,
Optional<SmallVector<int64_t>>
mlir::computeShapeRatio(ArrayRef<int64_t> shape, ArrayRef<int64_t> subShape) {
if (shape.size() < subShape.size())
- return None;
+ return std::nullopt;
assert(llvm::all_of(shape, [](int64_t s) { return s > 0; }) &&
"shape must be nonnegative");
assert(llvm::all_of(subShape, [](int64_t s) { return s > 0; }) &&
@@ -47,7 +47,7 @@ mlir::computeShapeRatio(ArrayRef<int64_t> shape, ArrayRef<int64_t> subShape) {
llvm::zip(llvm::reverse(shape), llvm::reverse(subShape))) {
// If integral division does not occur, return and let the caller decide.
if (size % subSize != 0)
- return None;
+ return std::nullopt;
result.push_back(size / subSize);
}
// At this point we computed the ratio (in reverse) for the common size.
diff --git a/mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp b/mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp
index b65c027f5b64..272692db8710 100644
--- a/mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp
+++ b/mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp
@@ -24,14 +24,14 @@ mlir::getReassociationIndicesForReshape(ShapedType sourceType,
if (sourceType.getRank() < targetType.getRank())
return getReassociationIndicesForCollapse(targetType.getShape(),
sourceType.getShape());
- return llvm::None;
+ return std::nullopt;
}
Optional<SmallVector<ReassociationIndices>>
mlir::getReassociationIndicesForCollapse(ArrayRef<int64_t> sourceShape,
ArrayRef<int64_t> targetShape) {
if (sourceShape.size() <= targetShape.size())
- return llvm::None;
+ return std::nullopt;
unsigned sourceDim = 0;
SmallVector<ReassociationIndices> reassociationMap;
reassociationMap.reserve(targetShape.size());
@@ -59,18 +59,18 @@ mlir::getReassociationIndicesForCollapse(ArrayRef<int64_t> sourceShape,
if (sourceShape[sourceDim] == ShapedType::kDynamic &&
(currTargetShape != ShapedType::kDynamic ||
prodOfCollapsedDims != 1))
- return llvm::None;
+ return std::nullopt;
// If the collapsed dim is dynamic, the current expanded dim should also
// be dynamic.
if (currTargetShape == ShapedType::kDynamic &&
sourceShape[sourceDim] != ShapedType::kDynamic)
- return llvm::None;
+ return std::nullopt;
// For static shapes, if the product of dimensions of the expanded shape
// should match the collapsed dimension shape.
if (prodOfCollapsedDims * sourceShape[sourceDim] != currTargetShape)
- return llvm::None;
+ return std::nullopt;
currIndices.push_back(sourceDim++);
reassociationMap.emplace_back(ReassociationIndices{});
@@ -79,13 +79,13 @@ mlir::getReassociationIndicesForCollapse(ArrayRef<int64_t> sourceShape,
}
// All the dimensions in the target must have been processed.
if (reassociationMap.size() != targetShape.size())
- return llvm::None;
+ return std::nullopt;
// Process any remaining entries in the source shape. They all need to be
// 1 or dynamic.
for (; sourceDim < sourceShape.size(); sourceDim++) {
if (sourceShape[sourceDim] != ShapedType::kDynamic &&
sourceShape[sourceDim] != 1)
- return llvm::None;
+ return std::nullopt;
// The map is empty when the target type is a scalar.
if (!reassociationMap.empty())
reassociationMap.back().push_back(sourceDim);
@@ -101,7 +101,7 @@ Optional<SmallVector<ReassociationIndices>> mlir::composeReassociationIndices(
// Make the producer the larger sized vector. If they are of same size, the
// resulting reshape is not a supported reshape op.
if (producerReassociations.size() == consumerReassociations.size())
- return llvm::None;
+ return std::nullopt;
if (producerReassociations.size() < consumerReassociations.size())
std::swap(producerReassociations, consumerReassociations);
@@ -116,7 +116,7 @@ Optional<SmallVector<ReassociationIndices>> mlir::composeReassociationIndices(
return all + indices.size();
});
if (producerReassociations.size() != consumerDims)
- return llvm::None;
+ return std::nullopt;
for (ReassociationIndicesRef consumerIndices : consumerReassociations) {
ReassociationIndices reassociations;
@@ -359,13 +359,13 @@ SliceFromCollapseHelper::getInsertSliceParams(MLIRContext *ctx,
static Optional<int64_t> getUniqueNonUnitDim(ArrayRef<int64_t> indices,
ArrayRef<int64_t> shape) {
// Return false if more than one of the dimensions in this group are not 1.
- Optional<int64_t> dimIndex = None;
+ Optional<int64_t> dimIndex = std::nullopt;
if (indices.size() < 2)
- return None;
+ return std::nullopt;
for (int64_t idx : indices) {
if (shape[idx] != 1) {
- if (dimIndex != None)
- return None;
+ if (dimIndex != std::nullopt)
+ return std::nullopt;
dimIndex = idx;
}
}
@@ -427,7 +427,8 @@ mlir::getSimplifyCollapseShapeWithRankReducingSliceInfo(
// If the rank-reducing slice simplified every segment, then we are done.
if (sliceShape.size() == reassociationIndices.size())
- return CollapseShapeRankReducingSliceSimplificationInfo{sliceType, None};
+ return CollapseShapeRankReducingSliceSimplificationInfo{sliceType,
+ std::nullopt};
// Otherwise, we need to create a new collapse_shape op for the segments that
// weren't covered by the slice. By design, the new reassociation indices has
diff --git a/mlir/lib/Dialect/Utils/StaticValueUtils.cpp b/mlir/lib/Dialect/Utils/StaticValueUtils.cpp
index 432e75618917..601e85b0248b 100644
--- a/mlir/lib/Dialect/Utils/StaticValueUtils.cpp
+++ b/mlir/lib/Dialect/Utils/StaticValueUtils.cpp
@@ -99,13 +99,13 @@ Optional<int64_t> getConstantIntValue(OpFoldResult ofr) {
APSInt intVal;
if (matchPattern(val, m_ConstantInt(&intVal)))
return intVal.getSExtValue();
- return llvm::None;
+ return std::nullopt;
}
// Case 2: Check for IntegerAttr.
Attribute attr = ofr.dyn_cast<Attribute>();
if (auto intAttr = attr.dyn_cast_or_null<IntegerAttr>())
return intAttr.getValue().getSExtValue();
- return llvm::None;
+ return std::nullopt;
}
/// Return true if `ofr` is constant integer equal to `value`.
diff --git a/mlir/lib/Dialect/Vector/IR/VectorOps.cpp b/mlir/lib/Dialect/Vector/IR/VectorOps.cpp
index 4d563df09d33..18dae281821e 100644
--- a/mlir/lib/Dialect/Vector/IR/VectorOps.cpp
+++ b/mlir/lib/Dialect/Vector/IR/VectorOps.cpp
@@ -5565,7 +5565,7 @@ void WarpExecuteOnLane0Op::build(OpBuilder &builder, OperationState &result,
TypeRange resultTypes, Value laneId,
int64_t warpSize) {
build(builder, result, resultTypes, laneId, warpSize,
- /*operands=*/llvm::None, /*argTypes=*/llvm::None);
+ /*operands=*/std::nullopt, /*argTypes=*/std::nullopt);
}
void WarpExecuteOnLane0Op::build(OpBuilder &builder, OperationState &result,
diff --git a/mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp b/mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp
index 323a173db1d2..0cfbe396e3bb 100644
--- a/mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp
+++ b/mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp
@@ -43,7 +43,7 @@ static Optional<int64_t> extractConstantIndex(Value v) {
if (auto affineApplyOp = v.getDefiningOp<AffineApplyOp>())
if (affineApplyOp.getAffineMap().isSingleConstant())
return affineApplyOp.getAffineMap().getSingleConstantResult();
- return None;
+ return std::nullopt;
}
// Missing foldings of scf.if make it necessary to perform poor man's folding
diff --git a/mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp b/mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp
index d44d46690b7e..592697d1e58e 100644
--- a/mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp
+++ b/mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp
@@ -50,7 +50,7 @@ static Optional<int64_t> getResultIndex(AffineMap map, int64_t index) {
if (idx == index)
return i;
}
- return None;
+ return std::nullopt;
}
// Helper to construct iterator types with one index removed.
@@ -157,7 +157,7 @@ static Optional<Value> createContractArithOp(Location loc, Value x, Value y,
if (isInt) {
if (kind == CombiningKind::MINF || kind == CombiningKind::MAXF)
// Only valid for floating point types.
- return None;
+ return std::nullopt;
mul = rewriter.create<arith::MulIOp>(loc, x, y);
} else {
// Float case.
@@ -166,7 +166,7 @@ static Optional<Value> createContractArithOp(Location loc, Value x, Value y,
kind == CombiningKind::MAXSI || kind == CombiningKind::OR ||
kind == CombiningKind::XOR)
// Only valid for integer types.
- return None;
+ return std::nullopt;
// Special case for fused multiply-add.
if (acc && acc.getType().isa<VectorType>() && kind == CombiningKind::ADD) {
return Optional<Value>(rewriter.create<vector::FMAOp>(loc, x, y, acc));
@@ -196,7 +196,7 @@ static llvm::Optional<unsigned> getDimPosition(AffineMap map, unsigned dim) {
if (map.getDimPosition(i) == dim)
return i;
}
- return llvm::None;
+ return std::nullopt;
}
namespace {
diff --git a/mlir/lib/Dialect/Vector/Transforms/VectorUnroll.cpp b/mlir/lib/Dialect/Vector/Transforms/VectorUnroll.cpp
index 5d07fb3a925b..c4d16d43e819 100644
--- a/mlir/lib/Dialect/Vector/Transforms/VectorUnroll.cpp
+++ b/mlir/lib/Dialect/Vector/Transforms/VectorUnroll.cpp
@@ -137,23 +137,23 @@ static Operation *cloneOpWithOperandsAndTypes(OpBuilder &builder, Location loc,
static Optional<SmallVector<int64_t>>
getTargetShape(const vector::UnrollVectorOptions &options, Operation *op) {
if (options.filterConstraint && failed(options.filterConstraint(op)))
- return llvm::None;
+ return std::nullopt;
assert(options.nativeShape &&
"vector unrolling expects the native shape or native"
"shape call back function to be set");
auto unrollableVectorOp = dyn_cast<VectorUnrollOpInterface>(op);
if (!unrollableVectorOp)
- return llvm::None;
+ return std::nullopt;
auto maybeUnrollShape = unrollableVectorOp.getShapeForUnroll();
if (!maybeUnrollShape)
- return llvm::None;
+ return std::nullopt;
Optional<SmallVector<int64_t>> targetShape = options.nativeShape(op);
if (!targetShape)
- return llvm::None;
+ return std::nullopt;
auto maybeShapeRatio = computeShapeRatio(*maybeUnrollShape, *targetShape);
if (!maybeShapeRatio ||
llvm::all_of(*maybeShapeRatio, [](int64_t v) { return v == 1; }))
- return llvm::None;
+ return std::nullopt;
return targetShape;
}
diff --git a/mlir/lib/ExecutionEngine/OptUtils.cpp b/mlir/lib/ExecutionEngine/OptUtils.cpp
index 893a8a490d44..a7203055e65f 100644
--- a/mlir/lib/ExecutionEngine/OptUtils.cpp
+++ b/mlir/lib/ExecutionEngine/OptUtils.cpp
@@ -47,7 +47,7 @@ static Optional<OptimizationLevel> mapToLevel(unsigned optLevel,
case 3:
return OptimizationLevel::O3;
}
- return None;
+ return std::nullopt;
}
// Create and return a lambda that uses LLVM pass manager builder to set up
// optimizations based on the given level.
diff --git a/mlir/lib/IR/AffineMap.cpp b/mlir/lib/IR/AffineMap.cpp
index e6186834cf5e..2b6d0bcf4193 100644
--- a/mlir/lib/IR/AffineMap.cpp
+++ b/mlir/lib/IR/AffineMap.cpp
@@ -63,13 +63,13 @@ class AffineExprConstantFolder {
if (auto attr = operandConsts[expr.cast<AffineDimExpr>().getPosition()]
.dyn_cast_or_null<IntegerAttr>())
return attr.getInt();
- return llvm::None;
+ return std::nullopt;
case AffineExprKind::SymbolId:
if (auto attr = operandConsts[numDims +
expr.cast<AffineSymbolExpr>().getPosition()]
.dyn_cast_or_null<IntegerAttr>())
return attr.getInt();
- return llvm::None;
+ return std::nullopt;
}
llvm_unreachable("Unknown AffineExpr");
}
@@ -81,7 +81,7 @@ class AffineExprConstantFolder {
if (auto lhs = constantFoldImpl(binOpExpr.getLHS()))
if (auto rhs = constantFoldImpl(binOpExpr.getRHS()))
return op(*lhs, *rhs);
- return llvm::None;
+ return std::nullopt;
}
// The number of dimension operands in AffineMap containing this expression.
@@ -330,14 +330,14 @@ unsigned AffineMap::getDimPosition(unsigned idx) const {
Optional<unsigned> AffineMap::getResultPosition(AffineExpr input) const {
if (!input.isa<AffineDimExpr>())
- return llvm::None;
+ return std::nullopt;
for (unsigned i = 0, numResults = getNumResults(); i < numResults; i++) {
if (getResult(i) == input)
return i;
}
- return llvm::None;
+ return std::nullopt;
}
/// Folds the results of the application of an affine map on the provided
diff --git a/mlir/lib/IR/BuiltinAttributes.cpp b/mlir/lib/IR/BuiltinAttributes.cpp
index a9671d627ac9..0046590c0394 100644
--- a/mlir/lib/IR/BuiltinAttributes.cpp
+++ b/mlir/lib/IR/BuiltinAttributes.cpp
@@ -95,7 +95,7 @@ static bool dictionaryAttrSort(ArrayRef<NamedAttribute> value,
/// attributes. Returns llvm::None if all elements have unique names.
static Optional<NamedAttribute>
findDuplicateElement(ArrayRef<NamedAttribute> value) {
- const Optional<NamedAttribute> none{llvm::None};
+ const Optional<NamedAttribute> none{std::nullopt};
if (value.size() < 2)
return none;
@@ -1604,7 +1604,7 @@ Optional<ArrayRef<T>>
DenseResourceElementsAttrBase<T>::tryGetAsArrayRef() const {
if (AsmResourceBlob *blob = this->getRawHandle().getBlob())
return blob->template getDataAs<T>();
- return llvm::None;
+ return std::nullopt;
}
template <typename T>
diff --git a/mlir/lib/IR/BuiltinTypes.cpp b/mlir/lib/IR/BuiltinTypes.cpp
index 85592dbae6d2..3dfaa12393fb 100644
--- a/mlir/lib/IR/BuiltinTypes.cpp
+++ b/mlir/lib/IR/BuiltinTypes.cpp
@@ -405,11 +405,11 @@ mlir::computeRankReductionMask(ArrayRef<int64_t> originalShape,
// If no match on `originalIdx`, the `originalShape` at this dimension
// must be 1, otherwise we bail.
if (originalShape[originalIdx] != 1)
- return llvm::None;
+ return std::nullopt;
}
// The whole reducedShape must be scanned, otherwise we bail.
if (reducedIdx != reducedRank)
- return llvm::None;
+ return std::nullopt;
return unusedDims;
}
diff --git a/mlir/lib/IR/Diagnostics.cpp b/mlir/lib/IR/Diagnostics.cpp
index ca99c6caec61..ef8b1a177925 100644
--- a/mlir/lib/IR/Diagnostics.cpp
+++ b/mlir/lib/IR/Diagnostics.cpp
@@ -401,9 +401,9 @@ static Optional<CallSiteLoc> getCallSiteLoc(Location loc) {
return callLoc;
}
}
- return llvm::None;
+ return std::nullopt;
}
- return llvm::None;
+ return std::nullopt;
}
/// Given a diagnostic kind, returns the LLVM DiagKind.
@@ -530,7 +530,7 @@ Optional<Location> SourceMgrDiagnosticHandler::findLocToShow(Location loc) {
if (!shouldShowLocFn)
return loc;
if (!shouldShowLocFn(loc))
- return llvm::None;
+ return std::nullopt;
// Recurse into the child locations of some of location types.
return TypeSwitch<LocationAttr, Optional<Location>>(loc)
@@ -546,7 +546,7 @@ Optional<Location> SourceMgrDiagnosticHandler::findLocToShow(Location loc) {
for (Location childLoc : fusedLoc.getLocations())
if (Optional<Location> showableLoc = findLocToShow(childLoc))
return showableLoc;
- return llvm::None;
+ return std::nullopt;
})
.Case([&](NameLoc nameLoc) -> Optional<Location> {
return findLocToShow(nameLoc.getChildLoc());
@@ -557,7 +557,7 @@ Optional<Location> SourceMgrDiagnosticHandler::findLocToShow(Location loc) {
})
.Case([](UnknownLoc) -> Optional<Location> {
// Prefer not to show unknown locations.
- return llvm::None;
+ return std::nullopt;
});
}
@@ -699,7 +699,7 @@ SourceMgrDiagnosticVerifierHandlerImpl::getExpectedDiags(StringRef bufName) {
auto expectedDiags = expectedDiagsPerFile.find(bufName);
if (expectedDiags != expectedDiagsPerFile.end())
return MutableArrayRef<ExpectedDiag>(expectedDiags->second);
- return llvm::None;
+ return std::nullopt;
}
MutableArrayRef<ExpectedDiag>
@@ -707,7 +707,7 @@ SourceMgrDiagnosticVerifierHandlerImpl::computeExpectedDiags(
raw_ostream &os, llvm::SourceMgr &mgr, const llvm::MemoryBuffer *buf) {
// If the buffer is invalid, return an empty list.
if (!buf)
- return llvm::None;
+ return std::nullopt;
auto &expectedDiags = expectedDiagsPerFile[buf->getBufferIdentifier()];
// The number of the last line that did not correlate to a designator.
diff --git a/mlir/lib/IR/Dialect.cpp b/mlir/lib/IR/Dialect.cpp
index c97c800d3f02..7fd484a20636 100644
--- a/mlir/lib/IR/Dialect.cpp
+++ b/mlir/lib/IR/Dialect.cpp
@@ -77,7 +77,7 @@ Type Dialect::parseType(DialectAsmParser &parser) const {
Optional<Dialect::ParseOpHook>
Dialect::getParseOperationHook(StringRef opName) const {
- return None;
+ return std::nullopt;
}
llvm::unique_function<void(Operation *, OpAsmPrinter &printer)>
diff --git a/mlir/lib/IR/ExtensibleDialect.cpp b/mlir/lib/IR/ExtensibleDialect.cpp
index 41f44f57bfae..fd169a8bde7f 100644
--- a/mlir/lib/IR/ExtensibleDialect.cpp
+++ b/mlir/lib/IR/ExtensibleDialect.cpp
@@ -468,7 +468,7 @@ OptionalParseResult ExtensibleDialect::parseOptionalDynamicType(
StringRef typeName, AsmParser &parser, Type &resultType) const {
DynamicTypeDefinition *typeDef = lookupTypeDefinition(typeName);
if (!typeDef)
- return llvm::None;
+ return std::nullopt;
DynamicType dynType;
if (DynamicType::parse(parser, typeDef, dynType))
@@ -490,7 +490,7 @@ OptionalParseResult ExtensibleDialect::parseOptionalDynamicAttr(
StringRef attrName, AsmParser &parser, Attribute &resultAttr) const {
DynamicAttrDefinition *attrDef = lookupAttrDefinition(attrName);
if (!attrDef)
- return llvm::None;
+ return std::nullopt;
DynamicAttr dynAttr;
if (DynamicAttr::parse(parser, attrDef, dynAttr))
diff --git a/mlir/lib/IR/MLIRContext.cpp b/mlir/lib/IR/MLIRContext.cpp
index 298f722da361..18b45137dc3d 100644
--- a/mlir/lib/IR/MLIRContext.cpp
+++ b/mlir/lib/IR/MLIRContext.cpp
@@ -753,7 +753,7 @@ RegisteredOperationName::lookup(StringRef name, MLIRContext *ctx) {
auto it = impl.registeredOperations.find(name);
if (it != impl.registeredOperations.end())
return it->getValue();
- return llvm::None;
+ return std::nullopt;
}
ParseResult
diff --git a/mlir/lib/IR/SymbolTable.cpp b/mlir/lib/IR/SymbolTable.cpp
index 2874ddcbbc97..54ab2f58dd6a 100644
--- a/mlir/lib/IR/SymbolTable.cpp
+++ b/mlir/lib/IR/SymbolTable.cpp
@@ -555,7 +555,7 @@ walkSymbolUses(MutableArrayRef<Region> regions,
return walkSymbolTable(regions, [&](Operation *op) -> Optional<WalkResult> {
// Check that this isn't a potentially unknown symbol table.
if (isPotentiallyUnknownSymbolTable(op))
- return llvm::None;
+ return std::nullopt;
return walkSymbolRefs(op, callback);
});
@@ -571,7 +571,7 @@ walkSymbolUses(Operation *from,
// symbol table, so we can't opaquely know if we should traverse to find
// nested uses.
if (isPotentiallyUnknownSymbolTable(from))
- return llvm::None;
+ return std::nullopt;
// Walk the uses on this operation.
if (walkSymbolRefs(from, callback).wasInterrupted())
@@ -740,7 +740,8 @@ static Optional<SymbolTable::UseRange> getSymbolUsesImpl(FromT from) {
return WalkResult::advance();
};
auto result = walkSymbolUses(from, walkFn);
- return result ? Optional<SymbolTable::UseRange>(std::move(uses)) : llvm::None;
+ return result ? Optional<SymbolTable::UseRange>(std::move(uses))
+ : std::nullopt;
}
/// Get an iterator range for all of the uses, for any symbol, that are nested
@@ -770,7 +771,7 @@ static Optional<SymbolTable::UseRange> getSymbolUsesImpl(SymbolT symbol,
if (isReferencePrefixOf(scope.symbol, symbolUse.getSymbolRef()))
uses.push_back(symbolUse);
}))
- return llvm::None;
+ return std::nullopt;
}
return SymbolTable::UseRange(std::move(uses));
}
diff --git a/mlir/lib/Interfaces/ControlFlowInterfaces.cpp b/mlir/lib/Interfaces/ControlFlowInterfaces.cpp
index 900617c3f15f..77b57bc4a892 100644
--- a/mlir/lib/Interfaces/ControlFlowInterfaces.cpp
+++ b/mlir/lib/Interfaces/ControlFlowInterfaces.cpp
@@ -42,13 +42,13 @@ detail::getBranchSuccessorArgument(const SuccessorOperands &operands,
OperandRange forwardedOperands = operands.getForwardedOperands();
// Check that the operands are valid.
if (forwardedOperands.empty())
- return llvm::None;
+ return std::nullopt;
// Check to ensure that this operand is within the range.
unsigned operandsStart = forwardedOperands.getBeginOperandIndex();
if (operandIndex < operandsStart ||
operandIndex >= (operandsStart + forwardedOperands.size()))
- return llvm::None;
+ return std::nullopt;
// Index the successor.
unsigned argIndex =
@@ -156,7 +156,7 @@ LogicalResult detail::verifyTypesAlongControlFlowEdges(Operation *op) {
};
// Verify types along control flow edges originating from the parent.
- if (failed(verifyTypesAlongAllEdges(op, llvm::None, inputTypesFromParent)))
+ if (failed(verifyTypesAlongAllEdges(op, std::nullopt, inputTypesFromParent)))
return failure();
auto areTypesCompatible = [&](TypeRange lhs, TypeRange rhs) {
@@ -206,7 +206,7 @@ LogicalResult detail::verifyTypesAlongControlFlowEdges(Operation *op) {
// If there is no return-like terminator, the op itself should verify
// type consistency.
if (!regionReturnOperands)
- return llvm::None;
+ return std::nullopt;
// All successors get the same set of operand types.
return TypeRange(regionReturnOperands->getTypes());
@@ -382,7 +382,7 @@ mlir::getMutableRegionBranchSuccessorOperands(Operation *operation,
// easier. Furthermore, this may even make this function obsolete.
if (operation->hasTrait<OpTrait::ReturnLike>())
return MutableOperandRange(operation);
- return llvm::None;
+ return std::nullopt;
}
/// Returns the read only operands that are passed to the region with the given
@@ -392,5 +392,5 @@ Optional<OperandRange>
mlir::getRegionBranchSuccessorOperands(Operation *operation,
Optional<unsigned> regionIndex) {
auto range = getMutableRegionBranchSuccessorOperands(operation, regionIndex);
- return range ? Optional<OperandRange>(*range) : llvm::None;
+ return range ? Optional<OperandRange>(*range) : std::nullopt;
}
diff --git a/mlir/lib/Interfaces/InferIntRangeInterface.cpp b/mlir/lib/Interfaces/InferIntRangeInterface.cpp
index d81674c27652..b72045aede3d 100644
--- a/mlir/lib/Interfaces/InferIntRangeInterface.cpp
+++ b/mlir/lib/Interfaces/InferIntRangeInterface.cpp
@@ -118,7 +118,7 @@ Optional<APInt> ConstantIntRanges::getConstantValue() const {
return umin();
if (smin() == smax() && smin().getBitWidth() != 0)
return smin();
- return None;
+ return std::nullopt;
}
raw_ostream &mlir::operator<<(raw_ostream &os, const ConstantIntRanges &range) {
diff --git a/mlir/lib/Pass/Pass.cpp b/mlir/lib/Pass/Pass.cpp
index edb5a5350772..8dab26714159 100644
--- a/mlir/lib/Pass/Pass.cpp
+++ b/mlir/lib/Pass/Pass.cpp
@@ -716,7 +716,7 @@ void OpToOpPassAdaptor::runOnOperationAsyncImpl(bool verifyPasses) {
for (auto ®ion : getOperation()->getRegions()) {
for (Operation &op : region.getOps()) {
// Get the pass manager index for this operation type.
- auto pmIdxIt = knownOpPMIdx.try_emplace(op.getName(), llvm::None);
+ auto pmIdxIt = knownOpPMIdx.try_emplace(op.getName(), std::nullopt);
if (pmIdxIt.second) {
if (auto *mgr = findPassManagerFor(mgrs, op.getName(), *context))
pmIdxIt.first->second = std::distance(mgrs.begin(), mgr);
diff --git a/mlir/lib/Pass/PassStatistics.cpp b/mlir/lib/Pass/PassStatistics.cpp
index 4dfb9257abb4..198009942c4f 100644
--- a/mlir/lib/Pass/PassStatistics.cpp
+++ b/mlir/lib/Pass/PassStatistics.cpp
@@ -27,7 +27,7 @@ struct Statistic {
/// Utility to print a pass entry in the statistics output.
static void printPassEntry(raw_ostream &os, unsigned indent, StringRef pass,
- MutableArrayRef<Statistic> stats = llvm::None) {
+ MutableArrayRef<Statistic> stats = std::nullopt) {
os.indent(indent) << pass << "\n";
if (stats.empty())
return;
diff --git a/mlir/lib/Reducer/Tester.cpp b/mlir/lib/Reducer/Tester.cpp
index 367ba4f76b05..14760c0be70d 100644
--- a/mlir/lib/Reducer/Tester.cpp
+++ b/mlir/lib/Reducer/Tester.cpp
@@ -68,7 +68,7 @@ Tester::Interestingness Tester::isInteresting(StringRef testCase) const {
std::string errMsg;
int result = llvm::sys::ExecuteAndWait(
- testScript, testerArgs, /*Env=*/None, /*Redirects=*/None,
+ testScript, testerArgs, /*Env=*/std::nullopt, /*Redirects=*/std::nullopt,
/*SecondsToWait=*/0, /*MemoryLimit=*/0, &errMsg);
if (result < 0)
diff --git a/mlir/lib/Support/FileUtilities.cpp b/mlir/lib/Support/FileUtilities.cpp
index 67f0bb393355..9fc86fcd6202 100644
--- a/mlir/lib/Support/FileUtilities.cpp
+++ b/mlir/lib/Support/FileUtilities.cpp
@@ -37,7 +37,7 @@ openInputFileImpl(StringRef inputFilename, std::string *errorMessage,
std::unique_ptr<llvm::MemoryBuffer>
mlir::openInputFile(StringRef inputFilename, std::string *errorMessage) {
return openInputFileImpl(inputFilename, errorMessage,
- /*alignment=*/llvm::None);
+ /*alignment=*/std::nullopt);
}
std::unique_ptr<llvm::MemoryBuffer>
mlir::openInputFile(llvm::StringRef inputFilename, llvm::Align alignment,
diff --git a/mlir/lib/Support/Timing.cpp b/mlir/lib/Support/Timing.cpp
index 4fd00c69413b..b2380ed2d024 100644
--- a/mlir/lib/Support/Timing.cpp
+++ b/mlir/lib/Support/Timing.cpp
@@ -511,7 +511,7 @@ void DefaultTimingManager::dumpAsTree(raw_ostream &os) {
Optional<void *> DefaultTimingManager::rootTimer() {
if (impl->enabled)
return impl->rootTimer.get();
- return llvm::None;
+ return std::nullopt;
}
void DefaultTimingManager::startTimer(void *handle) {
diff --git a/mlir/lib/TableGen/AttrOrTypeDef.cpp b/mlir/lib/TableGen/AttrOrTypeDef.cpp
index 38f1823b1437..f8fdf727f9d9 100644
--- a/mlir/lib/TableGen/AttrOrTypeDef.cpp
+++ b/mlir/lib/TableGen/AttrOrTypeDef.cpp
@@ -22,7 +22,7 @@ using namespace mlir::tblgen;
Optional<StringRef> AttrOrTypeBuilder::getReturnType() const {
Optional<StringRef> type = def->getValueAsOptionalString("returnType");
- return type && !type->empty() ? type : llvm::None;
+ return type && !type->empty() ? type : std::nullopt;
}
bool AttrOrTypeBuilder::hasInferredContextParameter() const {
@@ -282,7 +282,7 @@ bool AttrOrTypeParameter::isOptional() const {
Optional<StringRef> AttrOrTypeParameter::getDefaultValue() const {
Optional<StringRef> result = getDefValue<llvm::StringInit>("defaultValue");
- return result && !result->empty() ? result : llvm::None;
+ return result && !result->empty() ? result : std::nullopt;
}
llvm::Init *AttrOrTypeParameter::getDef() const { return def->getArg(index); }
diff --git a/mlir/lib/TableGen/Attribute.cpp b/mlir/lib/TableGen/Attribute.cpp
index 0b2841c296d3..37ce14e410e3 100644
--- a/mlir/lib/TableGen/Attribute.cpp
+++ b/mlir/lib/TableGen/Attribute.cpp
@@ -73,7 +73,7 @@ StringRef Attribute::getReturnType() const {
llvm::Optional<Type> Attribute::getValueType() const {
if (auto *defInit = dyn_cast<llvm::DefInit>(def->getValueInit("valueType")))
return Type(defInit->getDef());
- return llvm::None;
+ return std::nullopt;
}
StringRef Attribute::getConvertFromStorageCall() const {
diff --git a/mlir/lib/TableGen/Builder.cpp b/mlir/lib/TableGen/Builder.cpp
index e8dec691dfdc..7e39255a47fe 100644
--- a/mlir/lib/TableGen/Builder.cpp
+++ b/mlir/lib/TableGen/Builder.cpp
@@ -36,10 +36,10 @@ StringRef Builder::Parameter::getCppType() const {
/// parameter.
Optional<StringRef> Builder::Parameter::getDefaultValue() const {
if (isa<llvm::StringInit>(def))
- return llvm::None;
+ return std::nullopt;
const llvm::Record *record = cast<llvm::DefInit>(def)->getDef();
Optional<StringRef> value = record->getValueAsOptionalString("defaultValue");
- return value && !value->empty() ? value : llvm::None;
+ return value && !value->empty() ? value : std::nullopt;
}
//===----------------------------------------------------------------------===//
@@ -77,5 +77,5 @@ Builder::Builder(const llvm::Record *record, ArrayRef<SMLoc> loc)
/// Return an optional string containing the body of the builder.
Optional<StringRef> Builder::getBody() const {
Optional<StringRef> body = def->getValueAsOptionalString("body");
- return body && !body->empty() ? body : llvm::None;
+ return body && !body->empty() ? body : std::nullopt;
}
diff --git a/mlir/lib/TableGen/Constraint.cpp b/mlir/lib/TableGen/Constraint.cpp
index 071262ab6180..f8568889cba4 100644
--- a/mlir/lib/TableGen/Constraint.cpp
+++ b/mlir/lib/TableGen/Constraint.cpp
@@ -90,20 +90,20 @@ Optional<StringRef> Constraint::getBaseDefName() const {
if (const auto *defInit = dyn_cast<llvm::DefInit>(defValue->getValue()))
return Constraint(defInit->getDef(), kind).getDefName();
}
- return llvm::None;
+ return std::nullopt;
};
switch (kind) {
case CK_Attr:
if (def->isAnonymous())
return checkBaseDefFn("baseAttr");
- return llvm::None;
+ return std::nullopt;
case CK_Type:
if (def->isAnonymous())
return checkBaseDefFn("baseType");
- return llvm::None;
+ return std::nullopt;
default:
- return llvm::None;
+ return std::nullopt;
}
}
diff --git a/mlir/lib/TableGen/Interfaces.cpp b/mlir/lib/TableGen/Interfaces.cpp
index 1ee0b140756f..bc002869f134 100644
--- a/mlir/lib/TableGen/Interfaces.cpp
+++ b/mlir/lib/TableGen/Interfaces.cpp
@@ -120,7 +120,7 @@ llvm::Optional<StringRef> Interface::getExtraSharedClassDeclaration() const {
llvm::Optional<StringRef> Interface::getVerify() const {
// Only OpInterface supports the verify method.
if (!isa<OpInterface>(this))
- return llvm::None;
+ return std::nullopt;
auto value = def->getValueAsString("verify");
return value.empty() ? llvm::Optional<StringRef>() : value;
}
diff --git a/mlir/lib/TableGen/Type.cpp b/mlir/lib/TableGen/Type.cpp
index 115fb3ba41dc..bb65c1bcc8b3 100644
--- a/mlir/lib/TableGen/Type.cpp
+++ b/mlir/lib/TableGen/Type.cpp
@@ -49,13 +49,13 @@ Optional<StringRef> TypeConstraint::getBuilderCall() const {
// Check to see if this type constraint has a builder call.
const llvm::RecordVal *builderCall = baseType->getValue("builderCall");
if (!builderCall || !builderCall->getValue())
- return llvm::None;
+ return std::nullopt;
return TypeSwitch<llvm::Init *, Optional<StringRef>>(builderCall->getValue())
.Case<llvm::StringInit>([&](auto *init) {
StringRef value = init->getValue();
return value.empty() ? Optional<StringRef>() : value;
})
- .Default([](auto *) { return llvm::None; });
+ .Default([](auto *) { return std::nullopt; });
}
// Return the C++ class name for this type (which may just be ::mlir::Type).
diff --git a/mlir/lib/Target/LLVMIR/DebugTranslation.cpp b/mlir/lib/Target/LLVMIR/DebugTranslation.cpp
index 4e3656b74345..2423e95df326 100644
--- a/mlir/lib/Target/LLVMIR/DebugTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/DebugTranslation.cpp
@@ -125,7 +125,7 @@ llvm::DIDerivedType *DebugTranslation::translateImpl(DIDerivedTypeAttr attr) {
/*File=*/nullptr, /*Line=*/0,
/*Scope=*/nullptr, translate(attr.getBaseType()), attr.getSizeInBits(),
attr.getAlignInBits(), attr.getOffsetInBits(),
- /*DWARFAddressSpace=*/llvm::None, /*Flags=*/llvm::DINode::FlagZero);
+ /*DWARFAddressSpace=*/std::nullopt, /*Flags=*/llvm::DINode::FlagZero);
}
llvm::DIFile *DebugTranslation::translateImpl(DIFileAttr attr) {
diff --git a/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp b/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp
index abc2fadbbc9a..f8f1637891dd 100644
--- a/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp
@@ -213,7 +213,7 @@ static void setLoopMetadata(Operation &opInst, llvm::Instruction &llvmInst,
SmallVector<llvm::Metadata *> loopOptions;
// Reserve operand 0 for loop id self reference.
- auto dummy = llvm::MDNode::getTemporary(ctx, llvm::None);
+ auto dummy = llvm::MDNode::getTemporary(ctx, std::nullopt);
loopOptions.push_back(dummy.get());
auto loopAttr = attr.cast<DictionaryAttr>();
diff --git a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp
index a398002bd104..9ea32c28f8a9 100644
--- a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp
@@ -56,7 +56,7 @@ using namespace mlir::LLVM::detail;
static FailureOr<llvm::DataLayout>
translateDataLayout(DataLayoutSpecInterface attribute,
const DataLayout &dataLayout,
- Optional<Location> loc = llvm::None) {
+ Optional<Location> loc = std::nullopt) {
if (!loc)
loc = UnknownLoc::get(attribute.getContext());
diff --git a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
index f662fb653f10..1a6e0ba6bc9f 100644
--- a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
+++ b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
@@ -490,7 +490,7 @@ spirv::Deserializer::processFunctionEnd(ArrayRef<uint32_t> operands) {
}
curBlock = nullptr;
- curFunction = llvm::None;
+ curFunction = std::nullopt;
LLVM_DEBUG({
logger.unindent();
@@ -504,7 +504,7 @@ Optional<std::pair<Attribute, Type>>
spirv::Deserializer::getConstant(uint32_t id) {
auto constIt = constantMap.find(id);
if (constIt == constantMap.end())
- return llvm::None;
+ return std::nullopt;
return constIt->getSecond();
}
@@ -512,7 +512,7 @@ Optional<spirv::SpecConstOperationMaterializationInfo>
spirv::Deserializer::getSpecConstantOperation(uint32_t id) {
auto constIt = specConstOperationMap.find(id);
if (constIt == specConstOperationMap.end())
- return llvm::None;
+ return std::nullopt;
return constIt->getSecond();
}
@@ -2102,7 +2102,7 @@ spirv::Deserializer::processDebugLine(ArrayRef<uint32_t> operands) {
return success();
}
-void spirv::Deserializer::clearDebugLine() { debugLine = llvm::None; }
+void spirv::Deserializer::clearDebugLine() { debugLine = std::nullopt; }
LogicalResult
spirv::Deserializer::processDebugString(ArrayRef<uint32_t> operands) {
diff --git a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.h b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.h
index 236f3a660298..a4c6d6a8e18d 100644
--- a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.h
+++ b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.h
@@ -421,7 +421,7 @@ class Deserializer {
/// compose the error message) or the next instruction is malformed.
LogicalResult
sliceInstruction(spirv::Opcode &opcode, ArrayRef<uint32_t> &operands,
- Optional<spirv::Opcode> expectedOpcode = llvm::None);
+ Optional<spirv::Opcode> expectedOpcode = std::nullopt);
/// Processes a SPIR-V instruction with the given `opcode` and `operands`.
/// This method is the main entrance for handling SPIR-V instruction; it
diff --git a/mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp b/mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp
index 33ede71b987b..6cb15dd20d93 100644
--- a/mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp
+++ b/mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp
@@ -346,8 +346,8 @@ Value CodeGen::genNonInitializerVar(const ast::VariableDecl *varDecl,
Value results = builder.create<pdl::TypesOp>(
loc, pdl::RangeType::get(builder.getType<pdl::TypeType>()),
/*types=*/ArrayAttr());
- return builder.create<pdl::OperationOp>(loc, opType.getName(), operands,
- llvm::None, ValueRange(), results);
+ return builder.create<pdl::OperationOp>(
+ loc, opType.getName(), operands, std::nullopt, ValueRange(), results);
}
if (ast::RangeType rangeTy = type.dyn_cast<ast::RangeType>()) {
diff --git a/mlir/lib/Tools/PDLL/Parser/Parser.cpp b/mlir/lib/Tools/PDLL/Parser/Parser.cpp
index b84fd3440147..bbb68cac2051 100644
--- a/mlir/lib/Tools/PDLL/Parser/Parser.cpp
+++ b/mlir/lib/Tools/PDLL/Parser/Parser.cpp
@@ -981,7 +981,8 @@ ast::Decl *Parser::createODSNativePDLLConstraintDecl(
// Build the native constraint.
auto *constraintDecl = ast::UserConstraintDecl::createNative(
ctx, ast::Name::create(ctx, name, loc), paramVar,
- /*results=*/llvm::None, codeBlock, ast::TupleType::get(ctx), nativeType);
+ /*results=*/std::nullopt, codeBlock, ast::TupleType::get(ctx),
+ nativeType);
constraintDecl->setDocComment(ctx, docString);
curDeclScope->add(constraintDecl);
return constraintDecl;
@@ -1782,7 +1783,7 @@ Parser::parseConstraint(Optional<SMRange> &typeConstraint,
FailureOr<ast::ConstraintRef> Parser::parseArgOrResultConstraint() {
Optional<SMRange> typeConstraint;
- return parseConstraint(typeConstraint, /*existingConstraints=*/llvm::None,
+ return parseConstraint(typeConstraint, /*existingConstraints=*/std::nullopt,
/*allowInlineTypeConstraints=*/false);
}
@@ -2856,7 +2857,7 @@ Parser::validateOperationOperands(SMRange loc, Optional<StringRef> name,
SmallVectorImpl<ast::Expr *> &operands) {
return validateOperationOperandsOrResults(
"operand", loc, odsOp ? odsOp->getLoc() : Optional<SMRange>(), name,
- operands, odsOp ? odsOp->getOperands() : llvm::None, valueTy,
+ operands, odsOp ? odsOp->getOperands() : std::nullopt, valueTy,
valueRangeTy);
}
@@ -2866,7 +2867,7 @@ Parser::validateOperationResults(SMRange loc, Optional<StringRef> name,
SmallVectorImpl<ast::Expr *> &results) {
return validateOperationOperandsOrResults(
"result", loc, odsOp ? odsOp->getLoc() : Optional<SMRange>(), name,
- results, odsOp ? odsOp->getResults() : llvm::None, typeTy, typeRangeTy);
+ results, odsOp ? odsOp->getResults() : std::nullopt, typeTy, typeRangeTy);
}
void Parser::checkOperationResultTypeInferrence(SMRange loc, StringRef opName,
@@ -2965,8 +2966,8 @@ LogicalResult Parser::validateOperationOperandsOrResults(
// Otherwise, create dummy values for each of the entries so that we
// adhere to the ODS signature.
for (unsigned i = 0, e = odsValues.size(); i < e; ++i) {
- values.push_back(
- ast::RangeExpr::create(ctx, loc, /*elements=*/llvm::None, rangeTy));
+ values.push_back(ast::RangeExpr::create(
+ ctx, loc, /*elements=*/std::nullopt, rangeTy));
}
return success();
}
diff --git a/mlir/lib/Tools/lsp-server-support/SourceMgrUtils.cpp b/mlir/lib/Tools/lsp-server-support/SourceMgrUtils.cpp
index 3e029171bffd..5fc74970e533 100644
--- a/mlir/lib/Tools/lsp-server-support/SourceMgrUtils.cpp
+++ b/mlir/lib/Tools/lsp-server-support/SourceMgrUtils.cpp
@@ -71,10 +71,10 @@ Optional<std::string> lsp::extractSourceDocComment(llvm::SourceMgr &sourceMgr,
// cover the most common. We essentially look for a comment preceding the
// line, and if we find one, use that as the documentation.
if (!loc.isValid())
- return llvm::None;
+ return std::nullopt;
int bufferId = sourceMgr.FindBufferContainingLoc(loc);
if (bufferId == 0)
- return llvm::None;
+ return std::nullopt;
const char *bufferStart =
sourceMgr.getMemoryBuffer(bufferId)->getBufferStart();
StringRef buffer(bufferStart, loc.getPointer() - bufferStart);
@@ -83,7 +83,7 @@ Optional<std::string> lsp::extractSourceDocComment(llvm::SourceMgr &sourceMgr,
auto popLastLine = [&]() -> Optional<StringRef> {
size_t newlineOffset = buffer.find_last_of("\n");
if (newlineOffset == StringRef::npos)
- return llvm::None;
+ return std::nullopt;
StringRef lastLine = buffer.drop_front(newlineOffset).trim();
buffer = buffer.take_front(newlineOffset);
return lastLine;
@@ -91,7 +91,7 @@ Optional<std::string> lsp::extractSourceDocComment(llvm::SourceMgr &sourceMgr,
// Try to pop the current line.
if (!popLastLine())
- return llvm::None;
+ return std::nullopt;
// Try to parse a comment string from the source file.
SmallVector<StringRef> commentLines;
@@ -105,7 +105,7 @@ Optional<std::string> lsp::extractSourceDocComment(llvm::SourceMgr &sourceMgr,
}
if (commentLines.empty())
- return llvm::None;
+ return std::nullopt;
return llvm::join(llvm::reverse(commentLines), "\n");
}
diff --git a/mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp b/mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp
index deac47e071cb..0c60c7123a9f 100644
--- a/mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp
+++ b/mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp
@@ -32,7 +32,7 @@ static Optional<lsp::Location> getLocationFromLoc(StringRef uriScheme,
lsp::Logger::error("Failed to create URI for file `{0}`: {1}",
loc.getFilename(),
llvm::toString(sourceURI.takeError()));
- return llvm::None;
+ return std::nullopt;
}
lsp::Position position;
@@ -140,7 +140,7 @@ static Optional<unsigned> getResultNumberFromLoc(SMLoc loc) {
// Check to see if this location indexes into the result group, via `#`. If it
// doesn't, we can't extract a sub result number.
if (*curPtr != '#')
- return llvm::None;
+ return std::nullopt;
// Compute the sub result number from the remaining portion of the string.
const char *numberStart = ++curPtr;
@@ -156,7 +156,7 @@ static Optional<unsigned> getResultNumberFromLoc(SMLoc loc) {
/// If the range is invalid, returns None.
static Optional<StringRef> getTextFromRange(SMRange range) {
if (!range.isValid())
- return None;
+ return std::nullopt;
const char *startPtr = range.Start.getPointer();
return StringRef(startPtr, range.End.getPointer() - startPtr);
}
@@ -490,7 +490,7 @@ Optional<lsp::Hover> MLIRDocument::findHover(const lsp::URIForFile &uri,
hoverRange, block.block->getArgument(arg.index()), block);
}
}
- return llvm::None;
+ return std::nullopt;
}
Optional<lsp::Hover> MLIRDocument::buildHoverForOperation(
@@ -1227,7 +1227,7 @@ void lsp::MLIRServer::addOrUpdateDocument(
Optional<int64_t> lsp::MLIRServer::removeDocument(const URIForFile &uri) {
auto it = impl->files.find(uri.file());
if (it == impl->files.end())
- return llvm::None;
+ return std::nullopt;
int64_t version = it->second->getVersion();
impl->files.erase(it);
@@ -1255,7 +1255,7 @@ Optional<lsp::Hover> lsp::MLIRServer::findHover(const URIForFile &uri,
auto fileIt = impl->files.find(uri.file());
if (fileIt != impl->files.end())
return fileIt->second->findHover(uri, hoverPos);
- return llvm::None;
+ return std::nullopt;
}
void lsp::MLIRServer::findDocumentSymbols(
diff --git a/mlir/lib/Tools/mlir-pdll-lsp-server/PDLLServer.cpp b/mlir/lib/Tools/mlir-pdll-lsp-server/PDLLServer.cpp
index 7846103ff9da..b22c7c8eec05 100644
--- a/mlir/lib/Tools/mlir-pdll-lsp-server/PDLLServer.cpp
+++ b/mlir/lib/Tools/mlir-pdll-lsp-server/PDLLServer.cpp
@@ -79,7 +79,7 @@ getLspDiagnoticFromDiag(llvm::SourceMgr &sourceMgr, const ast::Diagnostic &diag,
// Skip diagnostics that weren't emitted within the main file.
if (loc.uri != uri)
- return llvm::None;
+ return std::nullopt;
// Convert the severity for the diagnostic.
switch (diag.getSeverity()) {
@@ -460,7 +460,7 @@ Optional<lsp::Hover> PDLDocument::findHover(const lsp::URIForFile &uri,
SMRange hoverRange;
const PDLIndexSymbol *symbol = index.lookup(posLoc, &hoverRange);
if (!symbol)
- return llvm::None;
+ return std::nullopt;
// Add hover for operation names.
if (const auto *op = symbol->definition.dyn_cast<const ods::Operation *>())
@@ -491,7 +491,7 @@ Optional<lsp::Hover> PDLDocument::findHover(const ast::Decl *decl,
if (const auto *rewrite = dyn_cast<ast::UserRewriteDecl>(decl))
return buildHoverForUserConstraintOrRewrite("Rewrite", rewrite, hoverRange);
- return llvm::None;
+ return std::nullopt;
}
lsp::Hover PDLDocument::buildHoverForOpName(const ods::Operation *op,
@@ -1037,7 +1037,7 @@ class LSPSignatureHelpContext : public CodeCompleteContext {
const ods::Operation *odsOp =
opName ? odsContext.lookupOperation(*opName) : nullptr;
codeCompleteOperationOperandOrResultSignature(
- opName, odsOp, odsOp ? odsOp->getOperands() : llvm::None,
+ opName, odsOp, odsOp ? odsOp->getOperands() : std::nullopt,
currentNumOperands, "operand", "Value");
}
@@ -1046,7 +1046,7 @@ class LSPSignatureHelpContext : public CodeCompleteContext {
const ods::Operation *odsOp =
opName ? odsContext.lookupOperation(*opName) : nullptr;
codeCompleteOperationOperandOrResultSignature(
- opName, odsOp, odsOp ? odsOp->getResults() : llvm::None,
+ opName, odsOp, odsOp ? odsOp->getResults() : std::nullopt,
currentNumResults, "result", "Type");
}
@@ -1732,7 +1732,7 @@ void lsp::PDLLServer::updateDocument(
Optional<int64_t> lsp::PDLLServer::removeDocument(const URIForFile &uri) {
auto it = impl->files.find(uri.file());
if (it == impl->files.end())
- return llvm::None;
+ return std::nullopt;
int64_t version = it->second->getVersion();
impl->files.erase(it);
@@ -1767,7 +1767,7 @@ Optional<lsp::Hover> lsp::PDLLServer::findHover(const URIForFile &uri,
auto fileIt = impl->files.find(uri.file());
if (fileIt != impl->files.end())
return fileIt->second->findHover(uri, hoverPos);
- return llvm::None;
+ return std::nullopt;
}
void lsp::PDLLServer::findDocumentSymbols(
@@ -1813,5 +1813,5 @@ lsp::PDLLServer::getPDLLViewOutput(const URIForFile &uri,
auto fileIt = impl->files.find(uri.file());
if (fileIt != impl->files.end())
return fileIt->second->getPDLLViewOutput(kind);
- return llvm::None;
+ return std::nullopt;
}
diff --git a/mlir/lib/Tools/mlir-translate/Translation.cpp b/mlir/lib/Tools/mlir-translate/Translation.cpp
index 548e3f9825b3..d8a2e9c4b5c0 100644
--- a/mlir/lib/Tools/mlir-translate/Translation.cpp
+++ b/mlir/lib/Tools/mlir-translate/Translation.cpp
@@ -62,7 +62,7 @@ static void registerTranslation(StringRef name, StringRef description,
TranslateRegistration::TranslateRegistration(
StringRef name, StringRef description, const TranslateFunction &function) {
- registerTranslation(name, description, /*inputAlignment=*/llvm::None,
+ registerTranslation(name, description, /*inputAlignment=*/std::nullopt,
function);
}
@@ -116,7 +116,7 @@ TranslateFromMLIRRegistration::TranslateFromMLIRRegistration(
const TranslateFromMLIRFunction &function,
const std::function<void(DialectRegistry &)> &dialectRegistration) {
registerTranslation(
- name, description, /*inputAlignment=*/llvm::None,
+ name, description, /*inputAlignment=*/std::nullopt,
[function, dialectRegistration](llvm::SourceMgr &sourceMgr,
raw_ostream &output,
MLIRContext *context) {
diff --git a/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp b/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp
index 5a4d3b29d4bb..5b7fea1fb3bd 100644
--- a/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp
+++ b/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp
@@ -59,7 +59,7 @@ getLspDiagnoticFromDiag(const llvm::SMDiagnostic &diag,
const lsp::URIForFile &uri) {
auto *sourceMgr = const_cast<llvm::SourceMgr *>(diag.getSourceMgr());
if (!sourceMgr || !diag.getLoc().isValid())
- return llvm::None;
+ return std::nullopt;
lsp::Diagnostic lspDiag;
lspDiag.source = "tablegen";
@@ -71,7 +71,7 @@ getLspDiagnoticFromDiag(const llvm::SMDiagnostic &diag,
// Skip diagnostics that weren't emitted within the main file.
if (loc.uri != uri)
- return llvm::None;
+ return std::nullopt;
// Convert the severity for the diagnostic.
switch (diag.getKind()) {
@@ -531,7 +531,7 @@ TableGenTextFile::findHover(const lsp::URIForFile &uri,
SMLoc posLoc = hoverPos.getAsSMLoc(sourceMgr);
const TableGenIndexSymbol *symbol = index.lookup(posLoc, &hoverRange);
if (!symbol)
- return llvm::None;
+ return std::nullopt;
// Build hover for a Record.
if (auto *record = dyn_cast<TableGenRecordSymbol>(symbol))
@@ -693,7 +693,7 @@ void lsp::TableGenServer::updateDocument(
Optional<int64_t> lsp::TableGenServer::removeDocument(const URIForFile &uri) {
auto it = impl->files.find(uri.file());
if (it == impl->files.end())
- return llvm::None;
+ return std::nullopt;
int64_t version = it->second->getVersion();
impl->files.erase(it);
@@ -728,5 +728,5 @@ Optional<lsp::Hover> lsp::TableGenServer::findHover(const URIForFile &uri,
auto fileIt = impl->files.find(uri.file());
if (fileIt != impl->files.end())
return fileIt->second->findHover(uri, hoverPos);
- return llvm::None;
+ return std::nullopt;
}
diff --git a/mlir/lib/Transforms/Utils/DialectConversion.cpp b/mlir/lib/Transforms/Utils/DialectConversion.cpp
index c56f4d481487..e942238cd6df 100644
--- a/mlir/lib/Transforms/Utils/DialectConversion.cpp
+++ b/mlir/lib/Transforms/Utils/DialectConversion.cpp
@@ -1571,7 +1571,7 @@ void ConversionPatternRewriter::replaceUsesOfBlockArgument(BlockArgument from,
Value ConversionPatternRewriter::getRemappedValue(Value key) {
SmallVector<Value> remappedValues;
- if (failed(impl->remapValues("value", /*inputLoc=*/llvm::None, *this, key,
+ if (failed(impl->remapValues("value", /*inputLoc=*/std::nullopt, *this, key,
remappedValues)))
return nullptr;
return remappedValues.front();
@@ -1582,7 +1582,7 @@ ConversionPatternRewriter::getRemappedValues(ValueRange keys,
SmallVectorImpl<Value> &results) {
if (keys.empty())
return success();
- return impl->remapValues("value", /*inputLoc=*/llvm::None, *this, keys,
+ return impl->remapValues("value", /*inputLoc=*/std::nullopt, *this, keys,
results);
}
@@ -3048,7 +3048,7 @@ auto TypeConverter::convertBlockSignature(Block *block)
-> Optional<SignatureConversion> {
SignatureConversion conversion(block->getNumArguments());
if (failed(convertSignatureArgs(block->getArgumentTypes(), conversion)))
- return llvm::None;
+ return std::nullopt;
return conversion;
}
@@ -3147,7 +3147,7 @@ auto ConversionTarget::isLegal(Operation *op) const
-> Optional<LegalOpDetails> {
Optional<LegalizationInfo> info = getOpInfo(op->getName());
if (!info)
- return llvm::None;
+ return std::nullopt;
// Returns true if this operation instance is known to be legal.
auto isOpLegal = [&] {
@@ -3162,7 +3162,7 @@ auto ConversionTarget::isLegal(Operation *op) const
return info->action == LegalizationAction::Legal;
};
if (!isOpLegal())
- return llvm::None;
+ return std::nullopt;
// This operation is legal, compute any additional legality information.
LegalOpDetails legalityDetails;
@@ -3269,7 +3269,7 @@ auto ConversionTarget::getOpInfo(OperationName op) const
if (unknownLegalityFn)
return LegalizationInfo{LegalizationAction::Dynamic,
/*isRecursivelyLegal=*/false, unknownLegalityFn};
- return llvm::None;
+ return std::nullopt;
}
//===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Transforms/ViewOpGraph.cpp b/mlir/lib/Transforms/ViewOpGraph.cpp
index 9afe2f5dc00c..b4b069e7327a 100644
--- a/mlir/lib/Transforms/ViewOpGraph.cpp
+++ b/mlir/lib/Transforms/ViewOpGraph.cpp
@@ -69,7 +69,7 @@ namespace {
/// cluster, an invisible "anchor" node is created.
struct Node {
public:
- Node(int id = 0, Optional<int> clusterId = llvm::None)
+ Node(int id = 0, Optional<int> clusterId = std::nullopt)
: id(id), clusterId(clusterId) {}
int id;
diff --git a/mlir/test/lib/Analysis/DataFlow/TestDenseDataFlowAnalysis.cpp b/mlir/test/lib/Analysis/DataFlow/TestDenseDataFlowAnalysis.cpp
index f21a2edc97dc..9e81b85dac9e 100644
--- a/mlir/test/lib/Analysis/DataFlow/TestDenseDataFlowAnalysis.cpp
+++ b/mlir/test/lib/Analysis/DataFlow/TestDenseDataFlowAnalysis.cpp
@@ -21,7 +21,7 @@ namespace {
class UnderlyingValue {
public:
/// Create an underlying value state with a known underlying value.
- explicit UnderlyingValue(Optional<Value> underlyingValue = None)
+ explicit UnderlyingValue(Optional<Value> underlyingValue = std::nullopt)
: underlyingValue(underlyingValue) {}
/// Whether the state is uninitialized.
diff --git a/mlir/test/lib/Dialect/Bufferization/TestTensorCopyInsertion.cpp b/mlir/test/lib/Dialect/Bufferization/TestTensorCopyInsertion.cpp
index 6c4011d462a7..a1f6078d9c94 100644
--- a/mlir/test/lib/Dialect/Bufferization/TestTensorCopyInsertion.cpp
+++ b/mlir/test/lib/Dialect/Bufferization/TestTensorCopyInsertion.cpp
@@ -46,7 +46,7 @@ struct TestTensorCopyInsertionPass
options.bufferizeFunctionBoundaries = bufferizeFunctionBoundaries;
options.createDeallocs = createDeallocs;
if (mustInferMemorySpace)
- options.defaultMemorySpace = None;
+ options.defaultMemorySpace = std::nullopt;
if (failed(bufferization::insertTensorCopies(getOperation(), options)))
signalPassFailure();
}
diff --git a/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp b/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp
index f47d05bc470f..84338d699123 100644
--- a/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp
+++ b/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp
@@ -75,7 +75,7 @@ struct TestDecomposeCallGraphTypes
[](OpBuilder &builder, TupleType resultType, ValueRange inputs,
Location loc) -> Optional<Value> {
if (inputs.size() == 1)
- return llvm::None;
+ return std::nullopt;
TupleType tuple = builder.getTupleType(inputs.getTypes());
Value value = builder.create<test::MakeTupleOp>(loc, tuple, inputs);
return value;
diff --git a/mlir/test/lib/Dialect/Test/TestAttributes.cpp b/mlir/test/lib/Dialect/Test/TestAttributes.cpp
index c8ccd58ac602..7b79ce67c5fb 100644
--- a/mlir/test/lib/Dialect/Test/TestAttributes.cpp
+++ b/mlir/test/lib/Dialect/Test/TestAttributes.cpp
@@ -157,7 +157,7 @@ void TestSubElementsAccessAttr::print(::mlir::AsmPrinter &printer) const {
ArrayRef<uint64_t> TestExtern1DI64ElementsAttr::getElements() const {
if (auto *blob = getHandle().getBlob())
return blob->getDataAs<uint64_t>();
- return llvm::None;
+ return std::nullopt;
}
//===----------------------------------------------------------------------===//
diff --git a/mlir/test/lib/Dialect/Test/TestDialect.cpp b/mlir/test/lib/Dialect/Test/TestDialect.cpp
index 93e4fbaac779..d20d4fc26bad 100644
--- a/mlir/test/lib/Dialect/Test/TestDialect.cpp
+++ b/mlir/test/lib/Dialect/Test/TestDialect.cpp
@@ -94,7 +94,7 @@ struct TestOpAsmInterface : public OpAsmDialectInterface {
.Case("alias_test:sanitize_conflict_b",
StringRef("test_alias_conflict0_"))
.Case("alias_test:tensor_encoding", StringRef("test_encoding"))
- .Default(llvm::None);
+ .Default(std::nullopt);
if (!aliasName)
return AliasResult::NoAlias;
@@ -441,7 +441,7 @@ TestDialect::getParseOperationHook(StringRef opName) const {
return ParseResult::success();
}};
}
- return None;
+ return std::nullopt;
}
llvm::unique_function<void(Operation *, OpAsmPrinter &)>
diff --git a/mlir/test/lib/Dialect/Test/TestPatterns.cpp b/mlir/test/lib/Dialect/Test/TestPatterns.cpp
index 2d2bf8d71286..4590419ed249 100644
--- a/mlir/test/lib/Dialect/Test/TestPatterns.cpp
+++ b/mlir/test/lib/Dialect/Test/TestPatterns.cpp
@@ -311,7 +311,7 @@ static void invokeCreateWithInferredReturnType(Operation *op) {
std::array<Value, 2> values = {{fop.getArgument(i), fop.getArgument(j)}};
SmallVector<Type, 2> inferredReturnTypes;
if (succeeded(OpTy::inferReturnTypes(
- context, llvm::None, values, op->getAttrDictionary(),
+ context, std::nullopt, values, op->getAttrDictionary(),
op->getRegions(), inferredReturnTypes))) {
OperationState state(location, OpTy::getOperationName());
// TODO: Expand to regions.
@@ -568,8 +568,8 @@ struct TestPassthroughInvalidOp : public ConversionPattern {
LogicalResult
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
ConversionPatternRewriter &rewriter) const final {
- rewriter.replaceOpWithNewOp<TestValidOp>(op, llvm::None, operands,
- llvm::None);
+ rewriter.replaceOpWithNewOp<TestValidOp>(op, std::nullopt, operands,
+ std::nullopt);
return success();
}
};
diff --git a/mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp b/mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp
index 00bd07a03433..b03318658094 100644
--- a/mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp
+++ b/mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp
@@ -84,10 +84,10 @@ struct TestVectorToVectorLowering
for (Operation *users : readOp->getUsers()) {
auto extract = dyn_cast<ExtractStridedSliceOp>(users);
if (!extract)
- return llvm::None;
+ return std::nullopt;
auto vecType = extract.getResult().getType().cast<VectorType>();
if (dstVec && dstVec != vecType)
- return llvm::None;
+ return std::nullopt;
dstVec = vecType;
}
return SmallVector<int64_t>(dstVec.getShape().begin(),
@@ -96,11 +96,11 @@ struct TestVectorToVectorLowering
if (auto writeOp = dyn_cast<vector::TransferWriteOp>(op)) {
auto insert = writeOp.getVector().getDefiningOp<InsertStridedSliceOp>();
if (!insert)
- return llvm::None;
+ return std::nullopt;
ArrayRef<int64_t> shape = insert.getSourceVectorType().getShape();
return SmallVector<int64_t>(shape.begin(), shape.end());
}
- return llvm::None;
+ return std::nullopt;
}
static LogicalResult filter(Operation *op) {
@@ -334,7 +334,7 @@ struct TestVectorUnrollingPatterns
vector::ContractionOp contractOp = cast<vector::ContractionOp>(op);
if (contractOp.getIteratorTypes().size() == unrollOrder.size())
return SmallVector<int64_t>(unrollOrder.begin(), unrollOrder.end());
- return None;
+ return std::nullopt;
});
}
populateVectorUnrollPatterns(patterns, opts);
@@ -342,7 +342,7 @@ struct TestVectorUnrollingPatterns
auto nativeShapeFn = [](Operation *op) -> Optional<SmallVector<int64_t>> {
auto contractOp = dyn_cast<ContractionOp>(op);
if (!contractOp)
- return None;
+ return std::nullopt;
return SmallVector<int64_t>(contractOp.getIteratorTypes().size(), 2);
};
populateVectorUnrollPatterns(patterns,
@@ -404,7 +404,7 @@ struct TestVectorTransferUnrollingPatterns
else if (auto writeOp = dyn_cast<vector::TransferWriteOp>(op))
numLoops = writeOp.getVectorType().getRank();
else
- return None;
+ return std::nullopt;
auto order = llvm::reverse(llvm::seq<int64_t>(0, numLoops));
return llvm::to_vector(order);
});
diff --git a/mlir/test/lib/Interfaces/TilingInterface/TestTilingInterface.cpp b/mlir/test/lib/Interfaces/TilingInterface/TestTilingInterface.cpp
index 290c9c577761..58ad2692087e 100644
--- a/mlir/test/lib/Interfaces/TilingInterface/TestTilingInterface.cpp
+++ b/mlir/test/lib/Interfaces/TilingInterface/TestTilingInterface.cpp
@@ -50,11 +50,11 @@ struct LinalgTransformationFilter {
explicit LinalgTransformationFilter(
ArrayRef<StringAttr> matchDisjunction = {},
- Optional<StringAttr> replacement = None);
+ Optional<StringAttr> replacement = std::nullopt);
explicit LinalgTransformationFilter(
const FilterFunction &f, ArrayRef<StringAttr> matchDisjunction = {},
- Optional<StringAttr> replacement = None);
+ Optional<StringAttr> replacement = std::nullopt);
LinalgTransformationFilter(LinalgTransformationFilter &&) = default;
LinalgTransformationFilter(const LinalgTransformationFilter &) = default;
diff --git a/mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp b/mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp
index 3595be880f36..476b9351a24e 100644
--- a/mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp
+++ b/mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp
@@ -398,7 +398,7 @@ findTensorDefArgIndex(StringRef name, SmallVectorImpl<LinalgOperandDef> &args) {
if (it.value().name == name)
return it.index();
}
- return None;
+ return std::nullopt;
}
// Try to map the TypeVar to a predefined or an argument type.
@@ -425,7 +425,7 @@ findTypeValue(StringRef typeVar, SmallVectorImpl<LinalgOperandDef> &args) {
.str();
}
- return None;
+ return std::nullopt;
}
static ScalarAssign *findAssignment(StringRef name,
@@ -1064,7 +1064,7 @@ if ({1}Iter != attrs.end()) {{
if (!argIndex) {
emitError(genContext.getLoc())
<< "scalar argument not defined on the op: " << *expression.arg;
- return None;
+ return std::nullopt;
}
return std::string(
llvm::formatv("block.getArgument({0})", *argIndex));
@@ -1118,7 +1118,7 @@ if ({1}Iter != attrs.end()) {{
<< "type variable " << expression.scalarFn->typeVar.value()
<< ", used in a type conversion, must map to a predefined or "
<< "an argument type but it does not";
- return None;
+ return std::nullopt;
}
operandCppValues.push_back(typeCppValue.value());
}
@@ -1127,7 +1127,7 @@ if ({1}Iter != attrs.end()) {{
for (ScalarExpression &operand : expression.scalarFn->operands) {
auto operandCppValue = generateExpression(operand);
if (!operandCppValue)
- return None;
+ return std::nullopt;
operandCppValues.push_back(*operandCppValue);
}
@@ -1139,7 +1139,7 @@ if ({1}Iter != attrs.end()) {{
return cppIdent;
}
emitError(genContext.getLoc()) << "unknown ScalarExpression type";
- return None;
+ return std::nullopt;
};
Optional<std::string> cppValue = generateExpression(assignment->value);
if (!cppValue)
diff --git a/mlir/tools/mlir-tblgen/DialectGen.cpp b/mlir/tools/mlir-tblgen/DialectGen.cpp
index 1085407f561d..c69154c8903f 100644
--- a/mlir/tools/mlir-tblgen/DialectGen.cpp
+++ b/mlir/tools/mlir-tblgen/DialectGen.cpp
@@ -59,7 +59,7 @@ filterForDialect(ArrayRef<llvm::Record *> records, Dialect &dialect) {
Optional<Dialect> tblgen::findDialectToGenerate(ArrayRef<Dialect> dialects) {
if (dialects.empty()) {
llvm::errs() << "no dialect was found\n";
- return llvm::None;
+ return std::nullopt;
}
// Select the dialect to gen for.
@@ -69,7 +69,7 @@ Optional<Dialect> tblgen::findDialectToGenerate(ArrayRef<Dialect> dialects) {
if (selectedDialect.getNumOccurrences() == 0) {
llvm::errs() << "when more than 1 dialect is present, one must be selected "
"via '-dialect'\n";
- return llvm::None;
+ return std::nullopt;
}
const auto *dialectIt = llvm::find_if(dialects, [](const Dialect &dialect) {
@@ -77,7 +77,7 @@ Optional<Dialect> tblgen::findDialectToGenerate(ArrayRef<Dialect> dialects) {
});
if (dialectIt == dialects.end()) {
llvm::errs() << "selected dialect with '-dialect' does not exist\n";
- return llvm::None;
+ return std::nullopt;
}
return *dialectIt;
}
diff --git a/mlir/tools/mlir-tblgen/EnumsGen.cpp b/mlir/tools/mlir-tblgen/EnumsGen.cpp
index e95d5d61a693..f4e7566c762d 100644
--- a/mlir/tools/mlir-tblgen/EnumsGen.cpp
+++ b/mlir/tools/mlir-tblgen/EnumsGen.cpp
@@ -234,7 +234,7 @@ getAllBitsUnsetCase(llvm::ArrayRef<EnumAttrCase> cases) {
if (attrCase.getValue() == 0)
return attrCase;
}
- return llvm::None;
+ return std::nullopt;
}
// Emits the following inline function for bit enums:
diff --git a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
index 5e29019eee0d..1898c3917c27 100644
--- a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
+++ b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
@@ -354,13 +354,13 @@ void OpOrAdaptorHelper::computeAttrMetadata() {
attrMetadata.insert(
{operandSegmentAttrName,
AttributeMetadata{operandSegmentAttrName, /*isRequired=*/true,
- /*attr=*/llvm::None}});
+ /*attr=*/std::nullopt}});
}
if (op.getTrait("::mlir::OpTrait::AttrSizedResultSegments")) {
attrMetadata.insert(
{resultSegmentAttrName,
AttributeMetadata{resultSegmentAttrName, /*isRequired=*/true,
- /*attr=*/llvm::None}});
+ /*attr=*/std::nullopt}});
}
// Store the metadata in sorted order.
diff --git a/mlir/tools/mlir-tblgen/OpFormatGen.cpp b/mlir/tools/mlir-tblgen/OpFormatGen.cpp
index 1d0f50fc6552..861bfa758cbc 100644
--- a/mlir/tools/mlir-tblgen/OpFormatGen.cpp
+++ b/mlir/tools/mlir-tblgen/OpFormatGen.cpp
@@ -61,7 +61,7 @@ struct AttributeVariable
/// if it doesn't have one.
llvm::Optional<StringRef> getTypeBuilder() const {
llvm::Optional<Type> attrType = var->attr.getValueType();
- return attrType ? attrType->getBuilderCall() : llvm::None;
+ return attrType ? attrType->getBuilderCall() : std::nullopt;
}
/// Return if this attribute refers to a UnitAttr.
@@ -2472,7 +2472,7 @@ static Optional<LogicalResult> checkRangeForElement(
return success();
}
// Return None to indicate that we reached the end.
- return llvm::None;
+ return std::nullopt;
}
/// For the given elements, check whether any attributes are followed by a colon
@@ -2751,9 +2751,9 @@ void OpFormatParser::handleAllTypesMatchConstraint(
// Mark this value as the type resolver for the other variables.
for (unsigned j = 0; j != i; ++j)
- variableTyResolver[values[j]] = {arg, llvm::None};
+ variableTyResolver[values[j]] = {arg, std::nullopt};
for (unsigned j = i + 1; j != e; ++j)
- variableTyResolver[values[j]] = {arg, llvm::None};
+ variableTyResolver[values[j]] = {arg, std::nullopt};
}
}
@@ -2774,11 +2774,11 @@ void OpFormatParser::handleSameTypesConstraint(
// Set the resolvers for each operand and result.
for (unsigned i = 0, e = op.getNumOperands(); i != e; ++i)
if (!seenOperandTypes.test(i))
- variableTyResolver[op.getOperand(i).name] = {resolver, llvm::None};
+ variableTyResolver[op.getOperand(i).name] = {resolver, std::nullopt};
if (includeResults) {
for (unsigned i = 0, e = op.getNumResults(); i != e; ++i)
if (!seenResultTypes.test(i))
- variableTyResolver[op.getResultName(i)] = {resolver, llvm::None};
+ variableTyResolver[op.getResultName(i)] = {resolver, std::nullopt};
}
}
More information about the Mlir-commits
mailing list