[Mlir-commits] [mlir] [mlir][ODS] Verify type constraints in Types and Attributes (PR #102326)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Wed Aug 7 09:02:05 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-mlir-llvm
Author: Matthias Springer (matthias-springer)
<details>
<summary>Changes</summary>
When a type/attribute is defined in TableGen, a type constraint can be used for parameters, but the type constraint verification was missing.
Example:
```
def TestTypeVerification : Test_Type<"TestTypeVerification"> {
let parameters = (ins AnyTypeOf<[I16, I32]>:$param);
// ...
}
```
No verification code was generated to ensure that `$param` is I16 or I32.
When type constraints a present, a new method will generated for types and attributes: `verifyInvariantsImpl`. (The naming is similar to op verifiers.) The user-provided verifier is called `verify` (no change). There is now a new entry point to type/attribute verification: `verifyInvariants`. This function calls both `verifyInvariantsImpl` and `verify`. If neither of those two verifications are present, the `verifyInvariants` function is not generated.
When a type/attribute is not defined in TableGen, but a verifier is needed, users can implement the `verifyInvariants` function. (This function was previously called `verify`.)
---
Patch is 33.88 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/102326.diff
22 Files Affected:
- (modified) mlir/include/mlir/Dialect/GPU/IR/GPUDialect.h (+4-3)
- (modified) mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h (+7-5)
- (modified) mlir/include/mlir/Dialect/Quant/QuantTypes.h (+22-21)
- (modified) mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAttributes.h (+8-6)
- (modified) mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h (+6-4)
- (modified) mlir/include/mlir/IR/CommonTypeConstraints.td (+1)
- (modified) mlir/include/mlir/IR/Constraints.td (+3)
- (modified) mlir/include/mlir/IR/StorageUniquerSupport.h (+6-4)
- (modified) mlir/include/mlir/IR/Types.h (+8-11)
- (modified) mlir/include/mlir/TableGen/AttrOrTypeDef.h (+6)
- (modified) mlir/include/mlir/TableGen/Class.h (+2)
- (modified) mlir/lib/Dialect/GPU/IR/GPUDialect.cpp (+3-3)
- (modified) mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp (+6-6)
- (modified) mlir/lib/Dialect/Quant/IR/QuantTypes.cpp (+22-17)
- (modified) mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp (+4-5)
- (modified) mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp (+5-4)
- (modified) mlir/lib/TableGen/AttrOrTypeDef.cpp (+13)
- (added) mlir/test/IR/test-verifiers-type.mlir (+9)
- (modified) mlir/test/lib/Dialect/Test/TestAttrDefs.td (-1)
- (modified) mlir/test/lib/Dialect/Test/TestTypeDefs.td (+6)
- (modified) mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp (+92-10)
- (modified) mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp (+1-1)
``````````diff
diff --git a/mlir/include/mlir/Dialect/GPU/IR/GPUDialect.h b/mlir/include/mlir/Dialect/GPU/IR/GPUDialect.h
index 96e1935bd0a84..57acd72610415 100644
--- a/mlir/include/mlir/Dialect/GPU/IR/GPUDialect.h
+++ b/mlir/include/mlir/Dialect/GPU/IR/GPUDialect.h
@@ -148,9 +148,10 @@ class MMAMatrixType
/// Verify that shape and elementType are actually allowed for the
/// MMAMatrixType.
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- ArrayRef<int64_t> shape, Type elementType,
- StringRef operand);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ ArrayRef<int64_t> shape, Type elementType,
+ StringRef operand);
/// Get number of dims.
unsigned getNumDims() const;
diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h b/mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h
index 1befdfa74f67c..2ea589a7c4c3b 100644
--- a/mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h
+++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h
@@ -180,11 +180,13 @@ class LLVMStructType
ArrayRef<Type> getBody() const;
/// Verifies that the type about to be constructed is well-formed.
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- StringRef, bool);
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- ArrayRef<Type> types, bool);
- using Base::verify;
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError, StringRef,
+ bool);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ ArrayRef<Type> types, bool);
+ using Base::verifyInvariants;
/// Hooks for DataLayoutTypeInterface. Should not be called directly. Obtain a
/// DataLayout instance and query it instead.
diff --git a/mlir/include/mlir/Dialect/Quant/QuantTypes.h b/mlir/include/mlir/Dialect/Quant/QuantTypes.h
index de5aed0a91a20..57a2aa2983365 100644
--- a/mlir/include/mlir/Dialect/Quant/QuantTypes.h
+++ b/mlir/include/mlir/Dialect/Quant/QuantTypes.h
@@ -54,10 +54,10 @@ class QuantizedType : public Type {
/// The maximum number of bits supported for storage types.
static constexpr unsigned MaxStorageBits = 32;
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- unsigned flags, Type storageType,
- Type expressedType, int64_t storageTypeMin,
- int64_t storageTypeMax);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+ Type storageType, Type expressedType, int64_t storageTypeMin,
+ int64_t storageTypeMax);
/// Support method to enable LLVM-style type casting.
static bool classof(Type type);
@@ -214,10 +214,10 @@ class AnyQuantizedType
int64_t storageTypeMax);
/// Verifies construction invariants and issues errors/warnings.
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- unsigned flags, Type storageType,
- Type expressedType, int64_t storageTypeMin,
- int64_t storageTypeMax);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+ Type storageType, Type expressedType, int64_t storageTypeMin,
+ int64_t storageTypeMax);
};
/// Represents a family of uniform, quantized types.
@@ -276,11 +276,11 @@ class UniformQuantizedType
int64_t zeroPoint, int64_t storageTypeMin, int64_t storageTypeMax);
/// Verifies construction invariants and issues errors/warnings.
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- unsigned flags, Type storageType,
- Type expressedType, double scale,
- int64_t zeroPoint, int64_t storageTypeMin,
- int64_t storageTypeMax);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+ Type storageType, Type expressedType, double scale,
+ int64_t zeroPoint, int64_t storageTypeMin,
+ int64_t storageTypeMax);
/// Gets the scale term. The scale designates the difference between the real
/// values corresponding to consecutive quantized values differing by 1.
@@ -338,12 +338,12 @@ class UniformQuantizedPerAxisType
int64_t storageTypeMin, int64_t storageTypeMax);
/// Verifies construction invariants and issues errors/warnings.
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- unsigned flags, Type storageType,
- Type expressedType, ArrayRef<double> scales,
- ArrayRef<int64_t> zeroPoints,
- int32_t quantizedDimension,
- int64_t storageTypeMin, int64_t storageTypeMax);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+ Type storageType, Type expressedType,
+ ArrayRef<double> scales, ArrayRef<int64_t> zeroPoints,
+ int32_t quantizedDimension, int64_t storageTypeMin,
+ int64_t storageTypeMax);
/// Gets the quantization scales. The scales designate the difference between
/// the real values corresponding to consecutive quantized values differing
@@ -403,8 +403,9 @@ class CalibratedQuantizedType
double min, double max);
/// Verifies construction invariants and issues errors/warnings.
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- Type expressedType, double min, double max);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ Type expressedType, double min, double max);
double getMin() const;
double getMax() const;
};
diff --git a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAttributes.h b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAttributes.h
index 5ebfa9ca5ec25..2bdd7a5bf3dd8 100644
--- a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAttributes.h
+++ b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAttributes.h
@@ -76,9 +76,10 @@ class InterfaceVarABIAttr
/// Returns `spirv::StorageClass`.
std::optional<StorageClass> getStorageClass();
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- IntegerAttr descriptorSet, IntegerAttr binding,
- IntegerAttr storageClass);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ IntegerAttr descriptorSet, IntegerAttr binding,
+ IntegerAttr storageClass);
static constexpr StringLiteral name = "spirv.interface_var_abi";
};
@@ -128,9 +129,10 @@ class VerCapExtAttr
/// Returns the capabilities as an integer array attribute.
ArrayAttr getCapabilitiesAttr();
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- IntegerAttr version, ArrayAttr capabilities,
- ArrayAttr extensions);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ IntegerAttr version, ArrayAttr capabilities,
+ ArrayAttr extensions);
static constexpr StringLiteral name = "spirv.ver_cap_ext";
};
diff --git a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h
index 55f0c787b4440..e2d04553d91b8 100644
--- a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h
+++ b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h
@@ -258,8 +258,9 @@ class SampledImageType
static SampledImageType
getChecked(function_ref<InFlightDiagnostic()> emitError, Type imageType);
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- Type imageType);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ Type imageType);
Type getImageType() const;
@@ -462,8 +463,9 @@ class MatrixType : public Type::TypeBase<MatrixType, CompositeType,
static MatrixType getChecked(function_ref<InFlightDiagnostic()> emitError,
Type columnType, uint32_t columnCount);
- static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
- Type columnType, uint32_t columnCount);
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ Type columnType, uint32_t columnCount);
/// Returns true if the matrix elements are vectors of float elements.
static bool isValidColumnType(Type columnType);
diff --git a/mlir/include/mlir/IR/CommonTypeConstraints.td b/mlir/include/mlir/IR/CommonTypeConstraints.td
index 5b6ec167fa242..4d3e1428e6c40 100644
--- a/mlir/include/mlir/IR/CommonTypeConstraints.td
+++ b/mlir/include/mlir/IR/CommonTypeConstraints.td
@@ -180,6 +180,7 @@ class AnyTypeOf<list<Type> allowedTypeList, string summary = "",
summary),
cppClassName> {
list<Type> allowedTypes = allowedTypeList;
+ string cppType = cppClassName;
}
// A type that satisfies the constraints of all given types.
diff --git a/mlir/include/mlir/IR/Constraints.td b/mlir/include/mlir/IR/Constraints.td
index a026d58ccffb8..242c850f38f30 100644
--- a/mlir/include/mlir/IR/Constraints.td
+++ b/mlir/include/mlir/IR/Constraints.td
@@ -153,6 +153,9 @@ class TypeConstraint<Pred predicate, string summary = "",
Constraint<predicate, summary> {
// The name of the C++ Type class if known, or Type if not.
string cppClassName = cppClassNameParam;
+ // TODO: This field is sometimes called `cppClassName` and sometimes
+ // `cppType`. Use a single name consistently.
+ string cppType = cppClassNameParam;
}
// Subclass for constraints on an attribute.
diff --git a/mlir/include/mlir/IR/StorageUniquerSupport.h b/mlir/include/mlir/IR/StorageUniquerSupport.h
index fb64f15162df5..d6ccbbd857994 100644
--- a/mlir/include/mlir/IR/StorageUniquerSupport.h
+++ b/mlir/include/mlir/IR/StorageUniquerSupport.h
@@ -176,8 +176,8 @@ class StorageUserBase : public BaseT, public Traits<ConcreteT>... {
template <typename... Args>
static ConcreteT get(MLIRContext *ctx, Args &&...args) {
// Ensure that the invariants are correct for construction.
- assert(
- succeeded(ConcreteT::verify(getDefaultDiagnosticEmitFn(ctx), args...)));
+ assert(succeeded(
+ ConcreteT::verifyInvariants(getDefaultDiagnosticEmitFn(ctx), args...)));
return UniquerT::template get<ConcreteT>(ctx, std::forward<Args>(args)...);
}
@@ -198,7 +198,7 @@ class StorageUserBase : public BaseT, public Traits<ConcreteT>... {
static ConcreteT getChecked(function_ref<InFlightDiagnostic()> emitErrorFn,
MLIRContext *ctx, Args... args) {
// If the construction invariants fail then we return a null attribute.
- if (failed(ConcreteT::verify(emitErrorFn, args...)))
+ if (failed(ConcreteT::verifyInvariants(emitErrorFn, args...)))
return ConcreteT();
return UniquerT::template get<ConcreteT>(ctx, args...);
}
@@ -226,7 +226,9 @@ class StorageUserBase : public BaseT, public Traits<ConcreteT>... {
/// Default implementation that just returns success.
template <typename... Args>
- static LogicalResult verify(Args... args) {
+ static LogicalResult
+ verifyInvariants(function_ref<InFlightDiagnostic()> emitErrorFn,
+ Args... args) {
return success();
}
diff --git a/mlir/include/mlir/IR/Types.h b/mlir/include/mlir/IR/Types.h
index 60dc8fee0f4a9..91b457deeba2f 100644
--- a/mlir/include/mlir/IR/Types.h
+++ b/mlir/include/mlir/IR/Types.h
@@ -34,7 +34,7 @@ class AsmState;
/// Derived type classes are expected to implement several required
/// implementation hooks:
/// * Optional:
-/// - static LogicalResult verify(
+/// - static LogicalResult verifyInvariants(
/// function_ref<InFlightDiagnostic()> emitError,
/// Args... args)
/// * This method is invoked when calling the 'TypeBase::get/getChecked'
@@ -97,20 +97,17 @@ class Type {
bool operator!() const { return impl == nullptr; }
template <typename... Tys>
- [[deprecated("Use mlir::isa<U>() instead")]]
- bool isa() const;
+ [[deprecated("Use mlir::isa<U>() instead")]] bool isa() const;
template <typename... Tys>
- [[deprecated("Use mlir::isa_and_nonnull<U>() instead")]]
- bool isa_and_nonnull() const;
+ [[deprecated("Use mlir::isa_and_nonnull<U>() instead")]] bool
+ isa_and_nonnull() const;
template <typename U>
- [[deprecated("Use mlir::dyn_cast<U>() instead")]]
- U dyn_cast() const;
+ [[deprecated("Use mlir::dyn_cast<U>() instead")]] U dyn_cast() const;
template <typename U>
- [[deprecated("Use mlir::dyn_cast_or_null<U>() instead")]]
- U dyn_cast_or_null() const;
+ [[deprecated("Use mlir::dyn_cast_or_null<U>() instead")]] U
+ dyn_cast_or_null() const;
template <typename U>
- [[deprecated("Use mlir::cast<U>() instead")]]
- U cast() const;
+ [[deprecated("Use mlir::cast<U>() instead")]] U cast() const;
/// Return a unique identifier for the concrete type. This is used to support
/// dynamic type casting.
diff --git a/mlir/include/mlir/TableGen/AttrOrTypeDef.h b/mlir/include/mlir/TableGen/AttrOrTypeDef.h
index 19c3a9183ec2c..c7819ef7c0ffa 100644
--- a/mlir/include/mlir/TableGen/AttrOrTypeDef.h
+++ b/mlir/include/mlir/TableGen/AttrOrTypeDef.h
@@ -15,7 +15,9 @@
#define MLIR_TABLEGEN_ATTRORTYPEDEF_H
#include "mlir/Support/LLVM.h"
+#include "mlir/TableGen/Argument.h"
#include "mlir/TableGen/Builder.h"
+#include "mlir/TableGen/Predicate.h"
#include "mlir/TableGen/Trait.h"
namespace llvm {
@@ -85,6 +87,8 @@ class AttrOrTypeParameter {
/// Get an optional C++ parameter parser.
std::optional<StringRef> getParser() const;
+ std::optional<TypeConstraint> getTypeConstraint() const;
+
/// Get an optional C++ parameter printer.
std::optional<StringRef> getPrinter() const;
@@ -198,6 +202,8 @@ class AttrOrTypeDef {
/// method.
bool genVerifyDecl() const;
+ bool genVerifyInvariantsImpl() const;
+
/// Returns the def's extra class declaration code.
std::optional<StringRef> getExtraDecls() const;
diff --git a/mlir/include/mlir/TableGen/Class.h b/mlir/include/mlir/TableGen/Class.h
index 855952d19492d..f750a34a3b2ba 100644
--- a/mlir/include/mlir/TableGen/Class.h
+++ b/mlir/include/mlir/TableGen/Class.h
@@ -67,6 +67,8 @@ class MethodParameter {
/// Get the C++ type.
StringRef getType() const { return type; }
+ /// Get the C++ parameter name.
+ StringRef getName() const { return name; }
/// Returns true if the parameter has a default value.
bool hasDefaultValue() const { return !defaultValue.empty(); }
diff --git a/mlir/lib/Dialect/GPU/IR/GPUDialect.cpp b/mlir/lib/Dialect/GPU/IR/GPUDialect.cpp
index 7bc2668310ddb..a1f87a637a614 100644
--- a/mlir/lib/Dialect/GPU/IR/GPUDialect.cpp
+++ b/mlir/lib/Dialect/GPU/IR/GPUDialect.cpp
@@ -148,9 +148,9 @@ bool MMAMatrixType::isValidElementType(Type elementType) {
}
LogicalResult
-MMAMatrixType::verify(function_ref<InFlightDiagnostic()> emitError,
- ArrayRef<int64_t> shape, Type elementType,
- StringRef operand) {
+MMAMatrixType::verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ ArrayRef<int64_t> shape, Type elementType,
+ StringRef operand) {
if (operand != "AOp" && operand != "BOp" && operand != "COp")
return emitError() << "operand expected to be one of AOp, BOp or COp";
diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp
index dc7aef8ef7f85..7f10a15ff31ff 100644
--- a/mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp
+++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp
@@ -418,8 +418,7 @@ LogicalResult LLVMPointerType::verifyEntries(DataLayoutEntryListRef entries,
bool LLVMStructType::isValidElementType(Type type) {
return !llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
- LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>(
- type);
+ LLVMFunctionType, LLVMTokenType>(type);
}
LLVMStructType LLVMStructType::getIdentified(MLIRContext *context,
@@ -492,14 +491,15 @@ ArrayRef<Type> LLVMStructType::getBody() const {
: getImpl()->getTypeList();
}
-LogicalResult LLVMStructType::verify(function_ref<InFlightDiagnostic()>,
- StringRef, bool) {
+LogicalResult
+LLVMStructType::verifyInvariants(function_ref<InFlightDiagnostic()>, StringRef,
+ bool) {
return success();
}
LogicalResult
-LLVMStructType::verify(function_ref<InFlightDiagnostic()> emitError,
- ArrayRef<Type> types, bool) {
+LLVMStructType::verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ ArrayRef<Type> types, bool) {
for (Type t : types)
if (!isValidElementType(t))
return emitError() << "invalid LLVM structure element type: " << t;
diff --git a/mlir/lib/Dialect/Quant/IR/QuantTypes.cpp b/mlir/lib/Dialect/Quant/IR/QuantTypes.cpp
index 81e3b914755be..c2ba9c04e8771 100644
--- a/mlir/lib/Dialect/Quant/IR/QuantTypes.cpp
+++ b/mlir/lib/Dialect/Quant/IR/QuantTypes.cpp
@@ -29,9 +29,10 @@ bool QuantizedType::classof(Type type) {
}
LogicalResult
-QuantizedType::verify(function_ref<InFlightDiagnostic()> emitError,
- unsigned flags, Type storageType, Type expressedType,
- int64_t storageTypeMin, int64_t storageTypeMax) {
+QuantizedType::verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ unsigned flags, Type storageType,
+ Type expressedType, int64_t storageTypeMin,
+ int64_t storageTypeMax) {
// Verify that the storage type is integral.
// This restriction may be lifted at some point in favor of using bf16
// or f16 as exact representations on hardware where that is advantageous.
@@ -233,11 +234,13 @@ AnyQuantizedType::getChecked(function_ref<InFlightDiagnostic()> emitError,
}
LogicalResult
-AnyQuantizedType::verify(function_ref<InFlightDiagnostic()> emitError,
- unsigned flags, Type storageType, Type expressedType,
- int64_t storageTypeMin, int64_t storageTypeMax) {
- if (failed(QuantizedType::verify(emitError, flags, storageType, expressedType,
- storageTypeMin, storageTypeMax))) {
+AnyQuantizedType::verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
+ unsigned flags, Type storageType,
+ Type expressedType, int64_t storageTypeMin,
+ int64_t storageTypeMax) {
+ if (failed(QuantizedType::verifyInvariants(emitError, flags, storageType,
+ expressedType, storageTypeMin,
+ storageTypeMax))) {
return failure();
}
@@ -268,12 +271,13 @@ UniformQuantizedType UniformQuantizedType::getChecked(
storageTypeMin, storageTypeMax);
}
-LogicalResult UniformQuantizedType::verify(
+LogicalResult UniformQuantizedType::verifyInvariants(
function_ref<InFlightDiagnostic()> emitError, unsigned flags,
Type storageType, Type expressedType, double scale, int64_t zeroPoint,
int64_t storageTypeMin, int64_t storageTypeMax) {
- if (failed(QuantizedType::verify(emitError, flags, storageType, expressedType,
- storageTypeMin, storageTypeMax))) {
+ if (failed(QuantizedType::verifyInvariants(emit...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/102326
More information about the Mlir-commits
mailing list