NFC - Rename QuantOps to Quant

[rsuderman]

Summary

Rename QuantOps to Quant to match dialect naming. The Ops suffix is redundant as all dialects contain Ops.

[rsuderman]

Moved remaining QuantOps folder

[rsuderman]

Nuking due to local corrupted git repo.

mlir/include/mlir/Dialect/CMakeLists.txt

 add_subdirectory(AffineOps)
 add_subdirectory(FxpMathOps)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(LoopOps)
 add_subdirectory(OpenMP)
-add_subdirectory(QuantOps)
+add_subdirectory(Quant)
 add_subdirectory(Shape)
 add_subdirectory(SPIRV)
 add_subdirectory(StandardOps)
 add_subdirectory(VectorOps)

mlir/include/mlir/Dialect/FxpMathOps/FxpMathOps.td

 // equivalents).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef DIALECT_FXPMATHOPS_FXPMATH_OPS_
 #define DIALECT_FXPMATHOPS_FXPMATH_OPS_
 
 include "mlir/IR/OpBase.td"
-include "mlir/Dialect/QuantOps/QuantOpsBase.td"
+include "mlir/Dialect/Quant/QuantOpsBase.td"
 include "mlir/Interfaces/SideEffects.td"
 
 def FxpMathOps_Dialect : Dialect {
   let name = "fxpmath";
 }
 
 //===----------------------------------------------------------------------===//
 // Attributes

mlir/include/mlir/Dialect/Quant/CMakeLists.txt

 add_mlir_dialect(QuantOps quant QuantOps)

mlir/include/mlir/Dialect/Quant/FakeQuantSupport.h

 //
 // As canonically used in TensorFlow graphs, the presence of a FakeQuant node
 // is a hint that the specific math represented here has been simulated at
 // training time. As such, it is usually not advised to arbitrarily change
 // quantization parameters derived from FakeQuant.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_QUANTOPS_FAKEQUANTSUPPORT_H_
-#define MLIR_DIALECT_QUANTOPS_FAKEQUANTSUPPORT_H_
+#ifndef MLIR_DIALECT_QUANT_FAKEQUANTSUPPORT_H_
+#define MLIR_DIALECT_QUANT_FAKEQUANTSUPPORT_H_
 
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 
 namespace mlir {
 namespace quant {
 
 /// Converts per-layer FakeQuant attributes to the corresponding type.
 /// In the event that the parameters cannot be converted, returns a nullptr
 /// convertible Type and issues an appropriate error.
 /// Note that there are multiple variants of a per-layer FakeQuant op, so

 UniformQuantizedPerAxisType
 fakeQuantAttrsToType(Location loc, unsigned numBits, int32_t quantizedDimension,
                      ArrayRef<double> rmins, ArrayRef<double> rmax,
                      bool narrowRange, Type expressedType,
                      bool isSigned = false);
 } // namespace quant
 } // namespace mlir
 
-#endif // MLIR_DIALECT_QUANTOPS_FAKEQUANTSUPPORT_H_
+#endif // MLIR_DIALECT_QUANT_FAKEQUANTSUPPORT_H_

mlir/include/mlir/Dialect/Quant/Passes.h

 //===- Passes.h - Quantization Passes ------ --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines all of the passes owned by the quantization dialect. As
 // things mature, it is expected that passes specific to certain frontend or
 // backend dialects will move to those dialects directly. For now, they are
 // incubated here.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_QUANTOPS_PASSES_H
-#define MLIR_DIALECT_QUANTOPS_PASSES_H
+#ifndef MLIR_DIALECT_QUANT_PASSES_H
+#define MLIR_DIALECT_QUANT_PASSES_H
 
 #include <memory>
 
 namespace mlir {
 class FuncOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 namespace quant {
 
 /// Creates a pass that converts quantization simulation operations (i.e.
 /// FakeQuant and those like it) to casts into/out of supported QuantizedTypes.
 std::unique_ptr<OpPassBase<FuncOp>> createConvertSimulatedQuantPass();
 
 /// Creates a pass that converts constants followed by a qbarrier to a
 /// constant whose value is quantized. This is typically one of the last
 /// passes done when lowering to express actual quantized arithmetic in a
 /// low level representation. Because it modifies the constant, it is
 /// destructive and cannot be undone.
 std::unique_ptr<OpPassBase<FuncOp>> createConvertConstPass();
 
 } // namespace quant
 } // namespace mlir
 
-#endif // MLIR_DIALECT_QUANTOPS_PASSES_H
+#endif // MLIR_DIALECT_QUANT_PASSES_H

mlir/include/mlir/Dialect/Quant/QuantOps.h

 //===- QuantOps.h - Quantization Ops and Types ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_QUANTOPS_QUANTOPS_H_
-#define MLIR_DIALECT_QUANTOPS_QUANTOPS_H_
+#ifndef MLIR_DIALECT_QUANT_QUANT_H_
+#define MLIR_DIALECT_QUANT_QUANT_H_
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Interfaces/SideEffects.h"
 #include "llvm/Support/MathExtras.h"
 
 namespace mlir {
 namespace quant {
 
-#include "mlir/Dialect/QuantOps/QuantOpsDialect.h.inc"
+#include "mlir/Dialect/Quant/QuantOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
-#include "mlir/Dialect/QuantOps/QuantOps.h.inc"
+#include "mlir/Dialect/Quant/QuantOps.h.inc"
 
 } // namespace quant
 } // namespace mlir
 
-#endif // MLIR_DIALECT_QUANTOPS_QUANTOPS_H_
+#endif // MLIR_DIALECT_QUANT_QUANT_H_

mlir/include/mlir/Dialect/Quant/QuantOps.td

 //===- QuantOps.td - Quantization operation definition -----*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the operation definition file for Quantization.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef DIALECT_QUANTOPS_QUANT_OPS_
-#define DIALECT_QUANTOPS_QUANT_OPS_
+#ifndef DIALECT_QUANT_QUANT_OPS_
+#define DIALECT_QUANT_QUANT_OPS_
 
-include "mlir/Dialect/QuantOps/QuantOpsBase.td"
+include "mlir/Dialect/Quant/QuantOpsBase.td"
 include "mlir/Interfaces/SideEffects.td"
 
 //===----------------------------------------------------------------------===//
 // Base classes
 //===----------------------------------------------------------------------===//
 
 class quant_Op<string mnemonic, list<OpTrait> traits> :
     Op<Quantization_Dialect, mnemonic, traits>;
def quant_CoupledRefOp : quant_Op<"coupled_ref", [SameOperandsAndResultType]> {
   }];
 
   let arguments = (ins
     quant_RealValueType:$arg,
     StrAttr:$coupledKey);
   let results = (outs quant_RealValueType);
 }
 
-#endif // DIALECT_QUANTOPS_QUANT_OPS_
+#endif // DIALECT_QUANT_QUANT_OPS_

mlir/include/mlir/Dialect/Quant/QuantOpsBase.td

 //===- QuantOpsBase.td - Quantization dialect base ---------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Predicates for types in the Quantization dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef DIALECT_QUANTOPS_QUANT_OPS_BASE_
-#define DIALECT_QUANTOPS_QUANT_OPS_BASE_
+#ifndef DIALECT_QUANT_QUANT_OPS_BASE_
+#define DIALECT_QUANT_QUANT_OPS_BASE_
 
 include "mlir/IR/OpBase.td"
 
 def Quantization_Dialect : Dialect {
   let name = "quant";
 }
 
 //===----------------------------------------------------------------------===//
def quant_UniformQuantizedType :
     DialectType<Quantization_Dialect,
                 CPred<"$_self.isa<UniformQuantizedType>()">,
                 "UniformQuantizedType">;
 
 // Predicate for detecting a container or primitive of UniformQuantizedType.
 def quant_UniformQuantizedValueType :
     quant_TypedPrimitiveOrContainer<quant_UniformQuantizedType>;
 
-#endif // DIALECT_QUANTOPS_QUANT_OPS_BASE_
+#endif // DIALECT_QUANT_QUANT_OPS_BASE_

mlir/include/mlir/Dialect/Quant/QuantTypes.h

 //===- QuantTypes.h - Quantization Ops and Types ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_QUANTOPS_QUANT_TYPES_H_
-#define MLIR_DIALECT_QUANTOPS_QUANT_TYPES_H_
+#ifndef MLIR_DIALECT_QUANT_QUANT_TYPES_H_
+#define MLIR_DIALECT_QUANT_QUANT_TYPES_H_
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "llvm/Support/MathExtras.h"
bool isFixedPoint() const {
     return llvm::all_of(getZeroPoints(),
                         [](int64_t zeroPoint) { return zeroPoint != 0; });
   }
 };
 
 } // namespace quant
 } // namespace mlir
 
-#endif // MLIR_DIALECT_QUANTOPS_QUANT_TYPES_H_
+#endif // MLIR_DIALECT_QUANT_QUANT_TYPES_H_

mlir/include/mlir/Dialect/Quant/QuantizeUtils.h

 //===- QuantizeUtils.h - Support utilities for quantization -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_QUANTOPS_QUANTIZEUTILS_H_
-#define MLIR_DIALECT_QUANTOPS_QUANTIZEUTILS_H_
+#ifndef MLIR_DIALECT_QUANT_QUANTIZEUTILS_H_
+#define MLIR_DIALECT_QUANT_QUANTIZEUTILS_H_
 
 namespace mlir {
 class Attribute;
 class Type;
 
 namespace quant {
 class QuantizedType;
 class UniformQuantizedType;

 ///   -> (DenseElementsAttr[tensor<2x2xi8>], outConvertedType: tensor<2x2xi8>)
 Attribute quantizeAttrUniform(Attribute realValue,
                               UniformQuantizedType quantizedElementType,
                               const UniformQuantizedValueConverter &converter,
                               Type &outConvertedType);
 } // namespace quant
 } // namespace mlir
 
-#endif // MLIR_DIALECT_QUANTOPS_QUANTIZEUTILS_H_
+#endif // MLIR_DIALECT_QUANT_QUANTIZEUTILS_H_

mlir/include/mlir/Dialect/Quant/UniformSupport.h

 //===- UniformSupport.h - Support utilities for uniform quant ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_QUANTOPS_UNIFORMSUPPORT_H_
-#define MLIR_DIALECT_QUANTOPS_UNIFORMSUPPORT_H_
+#ifndef MLIR_DIALECT_QUANT_UNIFORMSUPPORT_H_
+#define MLIR_DIALECT_QUANT_UNIFORMSUPPORT_H_
 
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/APSInt.h"
 
 namespace mlir {
 namespace quant {
private:
   const uint32_t storageBitWidth;
   const bool isSigned;
   int32_t quantizationDim;
 };
 
 } // namespace quant
 } // namespace mlir
 
-#endif // MLIR_DIALECT_QUANTOPS_UNIFORMSUPPORT_H_
+#endif // MLIR_DIALECT_QUANT_UNIFORMSUPPORT_H_

mlir/include/mlir/InitAllDialects.h

 #include "mlir/Dialect/FxpMathOps/FxpMathOps.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
-#include "mlir/Dialect/QuantOps/QuantOps.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
 #include "mlir/Dialect/SDBM/SDBMDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/VectorOps/VectorOps.h"
 #include "mlir/IR/Dialect.h"
 
 namespace mlir {
 

mlir/include/mlir/InitAllPasses.h

 #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
 #include "mlir/Conversion/LoopsToGPU/LoopsToGPUPass.h"
 #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h"
 #include "mlir/Dialect/FxpMathOps/Passes.h"
 #include "mlir/Dialect/GPU/Passes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/LoopOps/Passes.h"
-#include "mlir/Dialect/QuantOps/Passes.h"
+#include "mlir/Dialect/Quant/Passes.h"
 #include "mlir/Dialect/SPIRV/Passes.h"
 #include "mlir/Quantizer/Transforms/Passes.h"
 #include "mlir/Transforms/LocationSnapshot.h"
 #include "mlir/Transforms/Passes.h"
 
 #include <cstdlib>
 
 namespace mlir {

mlir/include/mlir/Quantizer/Support/Configuration.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_QUANTIZER_SUPPORT_CONFIGURATION_H
 #define MLIR_QUANTIZER_SUPPORT_CONFIGURATION_H
 
 #include <functional>
 
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/Quantizer/Support/ConstraintAnalysisGraph.h"
 #include "mlir/Quantizer/Support/Metadata.h"
 #include "mlir/Quantizer/Support/Rules.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/StringSet.h"
 

mlir/include/mlir/Quantizer/Support/Metadata.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_QUANTIZER_SUPPORT_METADATA_H
 #define MLIR_QUANTIZER_SUPPORT_METADATA_H
 
 #include <limits>
 
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Quantizer/Support/Rules.h"
 #include "llvm/ADT/SmallBitVector.h"
 
 namespace mlir {
 namespace quantizer {
 
 class SolverContext {

mlir/lib/Dialect/CMakeLists.txt

 add_subdirectory(AffineOps)
 add_subdirectory(FxpMathOps)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(LoopOps)
 add_subdirectory(OpenMP)
-add_subdirectory(QuantOps)
+add_subdirectory(Quant)
 add_subdirectory(SDBM)
 #add_subdirectory(Shape)
 add_subdirectory(SPIRV)
 add_subdirectory(StandardOps)
 add_subdirectory(VectorOps)
 
 set(LLVM_OPTIONAL_SOURCES
   Traits.cpp

mlir/lib/Dialect/FxpMathOps/IR/FxpMathOps.cpp

 //===- FxpMathOps.cpp - Op implementation for FxpMathOps ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/FxpMathOps/FxpMathOps.h"
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace mlir;
 using namespace mlir::fxpmath;

mlir/lib/Dialect/FxpMathOps/Transforms/UniformKernelUtils.h

 //===- UniformKernelUtils.h - Utilities for lowering uniform math - C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_FXPMATH_UNIFORM_KERNEL_UTILS_H_
 #define MLIR_FXPMATH_UNIFORM_KERNEL_UTILS_H_
 
-#include "mlir/Dialect/QuantOps/QuantOps.h"
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
-#include "mlir/Dialect/QuantOps/UniformSupport.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
+#include "mlir/Dialect/Quant/UniformSupport.h"
 #include "mlir/IR/Operation.h"
 
 #include <cmath>
 
 namespace mlir {
 namespace fxpmath {
 namespace detail {
 

mlir/lib/Dialect/Quant/CMakeLists.txt

 add_mlir_dialect_library(MLIRQuantOps
   IR/QuantOps.cpp
   IR/QuantTypes.cpp
   IR/TypeDetail.h
   IR/TypeParser.cpp
   Transforms/ConvertConst.cpp
   Transforms/ConvertSimQuant.cpp
   Utils/QuantizeUtils.cpp
   Utils/UniformSupport.cpp
   Utils/FakeQuantSupport.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/QuantOps
 
   DEPENDS
   MLIRQuantOpsIncGen
   )
 target_link_libraries(MLIRQuantOps
   PUBLIC
   MLIRIR
   MLIRPass
   MLIRSideEffects
   MLIRSupport
   MLIRStandardOps
   MLIRTransformUtils
   )

mlir/lib/Dialect/Quant/IR/QuantOps.cpp

 //===- QuantOps.cpp - Quantization Type and Ops Implementation --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/QuantOps.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
 #include "TypeDetail.h"
 
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/StandardTypes.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/MathExtras.h"
 #include <numeric>
 
 using namespace mlir;
 using namespace mlir::quant;
 using namespace mlir::quant::detail;
 
 QuantizationDialect::QuantizationDialect(MLIRContext *context)
     : Dialect(/*name=*/"quant", context) {
   addTypes<AnyQuantizedType, UniformQuantizedType,
            UniformQuantizedPerAxisType>();
   addOperations<
 #define GET_OP_LIST
-#include "mlir/Dialect/QuantOps/QuantOps.cpp.inc"
+#include "mlir/Dialect/Quant/QuantOps.cpp.inc"
       >();
 }
 
 OpFoldResult StorageCastOp::fold(ArrayRef<Attribute> operands) {
   /// Matches x -> [scast -> scast] -> y, replacing the second scast with the
   /// value of x if the casts invert each other.
   auto srcScastOp = dyn_cast_or_null<StorageCastOp>(arg().getDefiningOp());
   if (!srcScastOp || srcScastOp.arg().getType() != getType())
     return OpFoldResult();
   return srcScastOp.arg();
 }
 
 #define GET_OP_CLASSES
-#include "mlir/Dialect/QuantOps/QuantOps.cpp.inc"
+#include "mlir/Dialect/Quant/QuantOps.cpp.inc"

mlir/lib/Dialect/Quant/IR/QuantTypes.cpp

 //===- QuantOps.cpp - Quantization Type and Ops Implementation --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "TypeDetail.h"
 
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/MathExtras.h"
 

mlir/lib/Dialect/Quant/IR/TypeDetail.h

-//===- TypeDetail.h - QuantOps Type detail ----------------------*- C++ -*-===//
+//===- TypeDetail.h - Quant Type detail -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TYPE_DETAIL_H_

mlir/lib/Dialect/Quant/IR/TypeParser.cpp

 //===- TypeParser.h - Quantization Type Parser ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/QuantOps.h"
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"

mlir/lib/Dialect/Quant/Transforms/ConvertConst.cpp

 //===- ConvertConst.cpp - Quantizes constant ops --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/Passes.h"
-#include "mlir/Dialect/QuantOps/QuantOps.h"
-#include "mlir/Dialect/QuantOps/QuantizeUtils.h"
-#include "mlir/Dialect/QuantOps/UniformSupport.h"
+#include "mlir/Dialect/Quant/Passes.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
+#include "mlir/Dialect/Quant/QuantizeUtils.h"
+#include "mlir/Dialect/Quant/UniformSupport.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;

mlir/lib/Dialect/Quant/Transforms/ConvertSimQuant.cpp

 //===- ConvertSimQuant.cpp - Converts simulated quant ops------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/FakeQuantSupport.h"
-#include "mlir/Dialect/QuantOps/Passes.h"
-#include "mlir/Dialect/QuantOps/QuantOps.h"
-#include "mlir/Dialect/QuantOps/UniformSupport.h"
+#include "mlir/Dialect/Quant/FakeQuantSupport.h"
+#include "mlir/Dialect/Quant/Passes.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
+#include "mlir/Dialect/Quant/UniformSupport.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 using namespace mlir::quant;
 

mlir/lib/Dialect/Quant/Utils/FakeQuantSupport.cpp

 //===- FakeQuantSupport.cpp - Support utilities for FakeQuant ops ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/FakeQuantSupport.h"
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/FakeQuantSupport.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 
 using namespace mlir;
 using namespace mlir::quant;
 
 static bool getDefaultStorageParams(unsigned numBits, bool narrowRange,
                                     bool isSigned, MLIRContext *ctx,
                                     Type &storageType, int64_t &qmin,
                                     int64_t &qmax) {

mlir/lib/Dialect/Quant/Utils/QuantizeUtils.cpp

 //===- QuantizeUtils.cpp - Support utilities for quantization -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/QuantizeUtils.h"
-#include "mlir/Dialect/QuantOps/UniformSupport.h"
+#include "mlir/Dialect/Quant/QuantizeUtils.h"
+#include "mlir/Dialect/Quant/UniformSupport.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/StandardTypes.h"
 
 using namespace mlir;
 using namespace mlir::quant;
 
 /// Converts a possible primitive, real expressed value attribute to a
 /// corresponding storage attribute (typically FloatAttr -> IntegerAttr).

mlir/lib/Dialect/Quant/Utils/UniformSupport.cpp

 //===- UniformSupport.cpp - Support utilities for uniform quant -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/UniformSupport.h"
+#include "mlir/Dialect/Quant/UniformSupport.h"
 #include "mlir/IR/StandardTypes.h"
 #include <numeric>
 
 using namespace mlir;
 using namespace mlir::quant;
 
 static bool isQuantizablePrimitiveType(Type inputType) {
   return inputType.isa<FloatType>();

mlir/lib/Quantizer/Configurations/FxpMathConfig.cpp

 // quantization scheme based on the FxpMathOps (plus a small category of
 // extension ops that can be added from other dialects).
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Quantizer/Configurations/FxpMathConfig.h"
 
 #include "mlir/Dialect/FxpMathOps/FxpMathOps.h"
-#include "mlir/Dialect/QuantOps/QuantOps.h"
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Quantizer/Support/ConstraintAnalysisGraph.h"
 #include "mlir/Quantizer/Support/Metadata.h"
 #include "mlir/Quantizer/Support/Statistics.h"
 #include "mlir/Quantizer/Support/UniformConstraints.h"
 

mlir/lib/Quantizer/Support/UniformConstraints.cpp

 //===- UniformConstraints.cpp - Constraints for uniform quant -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Quantizer/Support/UniformConstraints.h"
 
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Quantizer/Support/Configuration.h"
 #include "mlir/Quantizer/Support/ConstraintAnalysisGraph.h"
 #include "mlir/Quantizer/Support/Metadata.h"
 #include "mlir/Quantizer/Support/Rules.h"
 #include "mlir/Quantizer/Support/TypeUtils.h"

mlir/lib/Quantizer/Transforms/AddDefaultStatsTestPass.cpp

 //===- AddDefaultStatsTestPass.cpp - Testing pass to add default stats ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a testing pass to add default statistics nodes to every
 // quantization eligible op. Useful for unit testing.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/QuantOps.h"
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Quantizer/Configurations/FxpMathConfig.h"
 #include "mlir/Quantizer/Support/Configuration.h"
 #include "mlir/Quantizer/Support/ConstraintAnalysisGraph.h"
 #include "mlir/Quantizer/Support/ConstraintAnalysisGraphTraits.h"
 #include "mlir/Quantizer/Transforms/Passes.h"
 #include "mlir/Support/LogicalResult.h"

mlir/lib/Quantizer/Transforms/InferQuantizedTypesPass.cpp

 //===- InferQuantizedTypesPass.cpp - Infers quantized types ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the primary pass for instantiating a CAG, running it to
 // convergence on a module to determine eligible quantized type transforms, and
 // applying those transforms to the IR.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/QuantOps.h"
-#include "mlir/Dialect/QuantOps/QuantTypes.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
+#include "mlir/Dialect/Quant/QuantTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Quantizer/Configurations/FxpMathConfig.h"
 #include "mlir/Quantizer/Support/Configuration.h"
 #include "mlir/Quantizer/Support/ConstraintAnalysisGraph.h"
 #include "mlir/Quantizer/Support/ConstraintAnalysisGraphTraits.h"
 #include "mlir/Quantizer/Transforms/Passes.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/Support/DOTGraphTraits.h"

mlir/lib/Quantizer/Transforms/RemoveInstrumentationPass.cpp

 //===- RemoveInstrumentationPass.cpp - Removes instrumentation ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a pass to remove any instrumentation ops. It is often one
 // of the final steps when performing quantization and is run after any
 // decisions requiring instrumentation have been made.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/QuantOps.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Quantizer/Transforms/Passes.h"
 
 using namespace mlir;
 using namespace mlir::quantizer;
 using namespace mlir::quant;

mlir/test/Dialect/Quant/canonicalize.mlir

 // RUN: mlir-opt %s -split-input-file -pass-pipeline='func(canonicalize)' | FileCheck %s --dump-input=fail
 
 // -----
 // CHECK-LABEL: redundant_scast
 func @redundant_scast() -> tensor<4xi8> {
   // CHECK-NEXT: constant dense<10> : tensor<4xi8>
   // CHECK-NEXT: return
   %cst = constant dense<5> : tensor<4xi8>
   %1 = "quant.scast"(%cst) : (tensor<4xi8>) -> tensor<4x!quant.uniform<u8:f32, 7.812500e-03:128>>
   %2 = "quant.scast"(%1) : (tensor<4x!quant.uniform<u8:f32, 7.812500e-03:128>>) -> tensor<4xi8>
   %3 = addi %2, %2 : tensor<4xi8>
   return %3 : tensor<4xi8>
 }
 
 // -----
 // CHECK-LABEL: non_redundant_scast
 func @non_redundant_scast() -> tensor<4x!quant.uniform<u8:f32, 7.812500e-03:128>> {
   // CHECK-NEXT: constant dense<5> : tensor<4xi8>
   // CHECK-NEXT: scast
   // CHECK-NEXT: return
   %cst = constant dense<5> : tensor<4xi8>
   %1 = "quant.scast"(%cst) : (tensor<4xi8>) -> tensor<4x!quant.uniform<u8:f32, 7.812500e-03:128>>
   return %1 : tensor<4x!quant.uniform<u8:f32, 7.812500e-03:128>>
 }

mlir/test/Dialect/Quant/convert-const.mlir

 // RUN: mlir-opt %s -split-input-file -quant-convert-const | FileCheck %s --dump-input=fail
 
 // Magic numbers:
 //   7.8125e-03 = 1/128 = 2/256 : real range = [-1.0, 0.9921875] (for 8bit, zeroPoint=128)
 //   1.250000e-01 = 1/8 = 2/16  : real range = [-1.0, 0.875] (for 4bit, zeroPoint=8)
 
 // -----
 // Verifies u8 affine quantization on a splat tensor.
 // Note that MLIR prints int attributes as signed, so the constant, when
 // quantized, is the signed printed version of an unsigned quantity
 // (-64 signed == 192 unsigned).
 // CHECK-LABEL: constant_splat_tensor_u8_affine
 func @constant_splat_tensor_u8_affine() -> tensor<4xf32> {
   // CHECK: %cst = constant dense<-64> : tensor<4xi8>
   // CHECK-NEXT: %0 = "quant.scast"(%cst) : (tensor<4xi8>) -> tensor<4x!quant.uniform<u8:f32, 7.812500e-03:128>>
   %cst = constant dense<0.5> : tensor<4xf32>
   %1 = "quant.qcast"(%cst) : (tensor<4xf32>) -> tensor<4x!quant.uniform<u8:f32, 7.812500e-03:128>>
   %2 = "quant.dcast"(%1) : (tensor<4x!quant.uniform<u8:f32, 7.812500e-03:128>>) -> (tensor<4xf32>)
   return %2 : tensor<4xf32>
 }
 
 // -----
 // Verifies i8 affine quantization on a splat tensor.
 // CHECK-LABEL: constant_splat_tensor_i8_affine
 func @constant_splat_tensor_i8_affine() -> tensor<4xf32> {
   // CHECK: %cst = constant dense<63> : tensor<4xi8>
   // CHECK-NEXT: %0 = "quant.scast"(%cst) : (tensor<4xi8>) -> tensor<4x!quant.uniform<i8:f32, 7.812500e-03:-1>>
   %cst = constant dense<0.5> : tensor<4xf32>
   %1 = "quant.qcast"(%cst) : (tensor<4xf32>) -> tensor<4x!quant.uniform<i8:f32, 7.812500e-03:-1>>
   %2 = "quant.dcast"(%1) : (tensor<4x!quant.uniform<i8:f32, 7.812500e-03:-1>>) -> (tensor<4xf32>)
   return %2 : tensor<4xf32>
 }
 
 // -----
 // Verifies i8 fixedpoint quantization on a splat tensor.
 // CHECK-LABEL: const_splat_tensor_i8_fixedpoint
 func @const_splat_tensor_i8_fixedpoint() -> tensor<4xf32> {
   // CHECK: %cst = constant dense<64> : tensor<4xi8>
   // CHECK-NEXT: %0 = "quant.scast"(%cst) : (tensor<4xi8>) -> tensor<4x!quant.uniform<i8:f32, 7.812500e-03>>
   %cst = constant dense<0.5> : tensor<4xf32>
   %1 = "quant.qcast"(%cst) : (tensor<4xf32>) -> tensor<4x!quant.uniform<i8:f32, 7.812500e-03>>
   %2 = "quant.dcast"(%1) : (tensor<4x!quant.uniform<i8:f32, 7.812500e-03>>) -> (tensor<4xf32>)
   return %2 : tensor<4xf32>
 }
 
 // -----
 // Verifies i8 fixedpoint quantization on a splat tensor resulting in a negative storage value.
 // CHECK-LABEL: const_splat_tensor_i8_fixedpoint_neg
 func @const_splat_tensor_i8_fixedpoint_neg() -> tensor<4xf32> {
   // CHECK: %cst = constant dense<-64> : tensor<4xi8>
   %cst = constant dense<-0.5> : tensor<4xf32>
   %1 = "quant.qcast"(%cst) : (tensor<4xf32>) -> tensor<4x!quant.uniform<i8:f32, 7.812500e-03>>
   %2 = "quant.dcast"(%1) : (tensor<4x!quant.uniform<i8:f32, 7.812500e-03>>) -> (tensor<4xf32>)
   return %2 : tensor<4xf32>
 }
 
 // -----
 // Verifies i8 fixedpoint quantization on a dense tensor, sweeping values.
 // CHECK-LABEL: const_dense_tensor_i8_fixedpoint
 func @const_dense_tensor_i8_fixedpoint() -> tensor<7xf32> {
   // CHECK: %cst = constant dense<[-128, -128, -64, 0, 64, 127, 127]> : tensor<7xi8>
   %cst = constant dense<[-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]> : tensor<7xf32>
   %1 = "quant.qcast"(%cst) : (tensor<7xf32>) -> tensor<7x!quant.uniform<i8:f32, 7.812500e-03>>
   %2 = "quant.dcast"(%1) : (tensor<7x!quant.uniform<i8:f32, 7.812500e-03>>) -> (tensor<7xf32>)
   return %2 : tensor<7xf32>
 }
 
 // -----
 // Verifies i8 fixedpoint quantization on a sparse tensor, sweeping values.
 // CHECK-LABEL: const_sparse_tensor_i8_fixedpoint
 func @const_sparse_tensor_i8_fixedpoint() -> tensor<7x2xf32> {
   // NOTE: Ugly regex match pattern for opening "[[" of indices tensor.
   // CHECK: %cst = constant sparse<{{\[}}[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6]], [-128, -128, -64, 0, 64, 127, 127]> : tensor<7x2xi8>
   %cst = constant sparse<
       [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6]],
       [-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]> : tensor<7x2xf32>
   %1 = "quant.qcast"(%cst) : (tensor<7x2xf32>) -> tensor<7x2x!quant.uniform<i8:f32, 7.812500e-03>>
   %2 = "quant.dcast"(%1) : (tensor<7x2x!quant.uniform<i8:f32, 7.812500e-03>>) -> (tensor<7x2xf32>)
   return %2 : tensor<7x2xf32>
 }
 
 // -----
 // Verifies i8 fixedpoint quantization on a primitive const.
 // CHECK-LABEL: const_primitive_float_i8_fixedpoint
 func @const_primitive_float_i8_fixedpoint() -> f32 {
   // CHECK: %c64_i8 = constant 64 : i8
   // CHECK-NEXT: %0 = "quant.scast"(%c64_i8) : (i8) -> !quant.uniform<i8:f32, 7.812500e-03>
   %cst = constant 0.5 : f32
   %1 = "quant.qcast"(%cst) : (f32) -> !quant.uniform<i8:f32, 7.812500e-03>
   %2 = "quant.dcast"(%1) : (!quant.uniform<i8:f32, 7.812500e-03>) -> (f32)
   return %2 : f32
 }
 
 // -----
 // Verifies u4 affine quantization on a dense tensor, sweeping values.
 // CHECK-LABEL: const_dense_tensor_u4_affine
 func @const_dense_tensor_u4_affine() -> tensor<7xf32> {
   // NOTE: Unsigned quantities printed by MLIR as signed.
   // CHECK: %cst = constant dense<[0, 0, 4, -8, -4, -1, -1]> : tensor<7xi4>
   %cst = constant dense<[-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]> : tensor<7xf32>
   %1 = "quant.qcast"(%cst) : (tensor<7xf32>) -> tensor<7x!quant.uniform<u4:f32, 1.250000e-01:8>>
   %2 = "quant.dcast"(%1) : (tensor<7x!quant.uniform<u4:f32, 1.250000e-01:8>>) -> (tensor<7xf32>)
   return %2 : tensor<7xf32>
 }
 
 // -----
 // Verifies i4 affine quantization on a dense tensor, sweeping values.
 // CHECK-LABEL: const_dense_tensor_i4_affine
 func @const_dense_tensor_i4_affine() -> tensor<7xf32> {
   // NOTE: Unsigned quantities printed by MLIR as signed.
   // CHECK: %cst = constant dense<[-8, -8, -5, -1, 3, 7, 7]> : tensor<7xi4>
   %cst = constant dense<[-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]> : tensor<7xf32>
   %1 = "quant.qcast"(%cst) : (tensor<7xf32>) -> tensor<7x!quant.uniform<i4:f32, 1.250000e-01:-1>>
   %2 = "quant.dcast"(%1) : (tensor<7x!quant.uniform<i4:f32, 1.250000e-01:-1>>) -> (tensor<7xf32>)
   return %2 : tensor<7xf32>
 }
 
 // -----
 // Verifies i4 fixed point quantization on a dense tensor, sweeping values.
 // CHECK-LABEL: const_dense_tensor_i4_fixedpoint
 func @const_dense_tensor_i4_fixedpoint() -> tensor<7xf32> {
   // CHECK: %cst = constant dense<[-8, -8, -4, 0, 4, 7, 7]> : tensor<7xi4>
   %cst = constant dense<[-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]> : tensor<7xf32>
   %1 = "quant.qcast"(%cst) : (tensor<7xf32>) -> tensor<7x!quant.uniform<i4:f32, 1.250000e-01>>
   %2 = "quant.dcast"(%1) : (tensor<7x!quant.uniform<i4:f32, 1.250000e-01>>) -> (tensor<7xf32>)
   return %2 : tensor<7xf32>
 }
 
 // -----
 // Verifies i8 fixedpoint quantization on a dense tensor, sweeping values, and
 // custom storage range. (the -128 should be clamped to -100, and the 127 should
 // be clamped to 100).
 // CHECK-LABEL: const_custom_storage_range_i8_fixedpoint
 func @const_custom_storage_range_i8_fixedpoint() -> tensor<7xf32> {
   // CHECK: %cst = constant dense<[-100, -100, -64, 0, 64, 100, 100]> : tensor<7xi8>
   %cst = constant dense<[-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]> : tensor<7xf32>
   %1 = "quant.qcast"(%cst) : (tensor<7xf32>) -> tensor<7x!quant.uniform<i8<-100:100>:f32, 7.812500e-03>>
   %2 = "quant.dcast"(%1) : (tensor<7x!quant.uniform<i8<-100:100>:f32, 7.812500e-03>>) -> (tensor<7xf32>)
   return %2 : tensor<7xf32>
 }
 
 // -----
 // Verifies quantization results of all-0.0 tensors are quantized to zero points.
 // CHECK-LABEL: zero_tensors_to_zero_points
 func @zero_tensors_to_zero_points() -> (tensor<7xf32>, tensor<7xf32>, tensor<7xf32>, tensor<7xf32>) {
 
 // CHECK: %[[cst:.*]] = constant dense<-127> : tensor<7xi8>
 // CHECK: %[[cst0:.*]] = constant dense<0> : tensor<7xi8>
 // CHECK: %[[cst1:.*]] = constant dense<1> : tensor<7xi8>
 // CHECK: "quant.scast"(%[[cst0]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<i8:f32, 1.000000e+00>>
 // CHECK: "quant.scast"(%[[cst]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<i8<-127:127>:f32, 1.000000e+00:-127>>
 // CHECK: "quant.scast"(%[[cst0]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<u8:f32, 1.000000e+00>>
 // CHECK: "quant.scast"(%[[cst1]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<u8<1:255>:f32, 1.000000e+00:1>>
 
   %cst = constant dense<0.0> : tensor<7xf32>
   %1 = "quant.qcast"(%cst) : (tensor<7xf32>) -> tensor<7x!quant.uniform<i8:f32, 1.0>>
   %2 = "quant.dcast"(%1) : (tensor<7x!quant.uniform<i8:f32, 1.0>>) -> (tensor<7xf32>)
 
   %cst0 = constant dense<0.0> : tensor<7xf32>
   %3 = "quant.qcast"(%cst0) : (tensor<7xf32>) -> tensor<7x!quant.uniform<i8<-127:127>:f32, 1.0:-127>>
   %4 = "quant.dcast"(%3) : (tensor<7x!quant.uniform<i8<-127:127>:f32, 1.0:-127>>) -> (tensor<7xf32>)
 
   %cst1 = constant dense<0.0> : tensor<7xf32>
   %5 = "quant.qcast"(%cst1) : (tensor<7xf32>) -> tensor<7x!quant.uniform<u8:f32, 1.0>>
   %6 = "quant.dcast"(%5) : (tensor<7x!quant.uniform<u8:f32, 1.0>>) -> (tensor<7xf32>)
 
   %cst2 = constant dense<0.0> : tensor<7xf32>
   %7 = "quant.qcast"(%cst2) : (tensor<7xf32>) -> tensor<7x!quant.uniform<u8<1:255>:f32, 1.0:1>>
   %8 = "quant.dcast"(%7) : (tensor<7x!quant.uniform<u8<1:255>:f32, 1.0:1>>) -> (tensor<7xf32>)
 
   return %2, %4, %6, %8 : tensor<7xf32>, tensor<7xf32>, tensor<7xf32>, tensor<7xf32>
 }
 
 // -----
 // Verifies per-axis quantization results for dense.
 // CHECK-LABEL: per_axis_dense_quantization
 func @per_axis_dense_quantization() -> (tensor<2x3xf32>, tensor<2x3xf32>) {
 
 // CHECK-NEXT: %[[cst:.*]] = constant dense<{{\[}}[-128, 64, 127], [0, 1, 2]]> : tensor<2x3xi8>
 // CHECK-NEXT: %[[cst0:.*]] = constant dense<{{\[}}[-128, -1, 1], [127, 1, 3]]> : tensor<2x3xi8>
 // CHECK: "quant.scast"(%[[cst]]) : (tensor<2x3xi8>) -> tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128,1.000000e+00}>>
 // CHECK: "quant.scast"(%cst_0) : (tensor<2x3xi8>) -> tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128,1.000000e+00,1.000000e+00:1}>>
 
   %cst = constant dense<[[-2.0, -0.5, 0.0], [0.0, 1.0, 2.0]]> : tensor<2x3xf32>
   %1 = "quant.qcast"(%cst) : (tensor<2x3xf32>) -> tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128, 1.0}>>
   %2 = "quant.dcast"(%1) : (tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128, 1.0}>>) -> (tensor<2x3xf32>)
 
   %cst0 = constant dense<[[-2.0, -0.5, 0.0], [0.0, 1.0, 2.0]]> : tensor<2x3xf32>
   %3 = "quant.qcast"(%cst0) : (tensor<2x3xf32>) -> tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128, 1.0, 1.0:1}>>
   %4 = "quant.dcast"(%3) : (tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128, 1.0, 1.0:1}>>) -> (tensor<2x3xf32>)
 
   return %2, %4 : tensor<2x3xf32>, tensor<2x3xf32>
 }

mlir/test/Dialect/Quant/convert-fakequant-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics -quant-convert-simulated-quantization
 
 // -----
 // Unsupported quantizable type (i1 is currently not a supported element type).
 func @fakeQuantArgs(tensor<8x4x3xi1>) -> tensor<8x4x3xi1> {
 ^bb0(%arg0: tensor<8x4x3xi1>):
   // expected-error@+1 {{op operand #0 must be tensor of 32-bit float values}}
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 1.1 : f32, max = 1.0 : f32, num_bits = 8
   } : (tensor<8x4x3xi1>) -> tensor<8x4x3xi1>
   return %0 : tensor<8x4x3xi1>
 }

mlir/test/Dialect/Quant/convert-fakequant.mlir

 // RUN: mlir-opt %s -split-input-file -quant-convert-simulated-quantization | FileCheck %s --dump-input=fail
 
 // -----
 // Verifies a quint8 single point.
 // CHECK-LABEL: fakeQuantArgs_Quint8_0
 func @fakeQuantArgs_Quint8_0(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %[[qc:.*]] = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<u8:f32, 1.000000e+00>>
   // CHECK-NEXT: "quant.dcast"(%[[qc]]) : (tensor<8x4x3x!quant.uniform<u8:f32, 1.000000e+00>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.0 : f32, max = 0.0 : f32, num_bits = 8
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a quint8 single point (with narrow_range = true).
 // CHECK-LABEL: fakeQuantArgs_Quint8_0_NarrowRange
 func @fakeQuantArgs_Quint8_0_NarrowRange(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %[[qc:.*]] = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<u8<1:255>:f32, 1.000000e+00:1>>
   // CHECK-NEXT: "quant.dcast"(%[[qc]]) : (tensor<8x4x3x!quant.uniform<u8<1:255>:f32, 1.000000e+00:1>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.0 : f32, max = 0.0 : f32, num_bits = 8, narrow_range = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a quint8 asymmetric 0..1 range.
 // CHECK-LABEL: fakeQuantArgs_Quint8_0_1
 func @fakeQuantArgs_Quint8_0_1(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %0 = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<u8:f32, 0.0039215686274509803>>
   // CHECK-NEXT: %1 = "quant.dcast"(%0) : (tensor<8x4x3x!quant.uniform<u8:f32, 0.0039215686274509803>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.0 : f32, max = 1.0 : f32, num_bits = 8
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a quint8 asymmetric 0..1 range (with narrow_range = true).
 // CHECK-LABEL: fakeQuantArgs_Quint8_NarrowRange
 func @fakeQuantArgs_Quint8_NarrowRange(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %0 = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<u8<1:255>:f32, 0.003937007874015748:1>>
   // CHECK-NEXT: %1 = "quant.dcast"(%0) : (tensor<8x4x3x!quant.uniform<u8<1:255>:f32, 0.003937007874015748:1>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.0 : f32, max = 1.0 : f32, num_bits = 8, narrow_range = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a quint8 symmetric range of -1..127/128.
 // CHECK-LABEL: fakeQuantArgs_Quint8_SymmetricRange
 func @fakeQuantArgs_Quint8_SymmetricRange(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %0 = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<u8:f32, 7.812500e-03:128>>
   // CHECK-NEXT: %1 = "quant.dcast"(%0) : (tensor<8x4x3x!quant.uniform<u8:f32, 7.812500e-03:128>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = -1.0 : f32, max = 0.9921875 : f32, num_bits = 8, narrow_range = false
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a qint8 single point.
 // CHECK-LABEL: fakeQuantArgs_Qint8_0
 func @fakeQuantArgs_Qint8_0(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %[[qc:.*]] = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<i8:f32, 1.000000e+00:-128>>
   // CHECK-NEXT: "quant.dcast"(%[[qc]]) : (tensor<8x4x3x!quant.uniform<i8:f32, 1.000000e+00:-128>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.0 : f32, max = 0.0 : f32, num_bits = 8, is_signed = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a qint8 single point (with narrow_range = true).
 // CHECK-LABEL: fakeQuantArgs_Qint8_0_NarrowRange
 func @fakeQuantArgs_Qint8_0_NarrowRange(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %[[qc:.*]]  = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<i8<-127:127>:f32, 1.000000e+00:-127>>
   // CHECK-NEXT: "quant.dcast"(%[[qc]]) : (tensor<8x4x3x!quant.uniform<i8<-127:127>:f32, 1.000000e+00:-127>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.0 : f32, max = 0.0 : f32, num_bits = 8, narrow_range = true, is_signed = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a qint8 asymmetric 0..1 range.
 // CHECK-LABEL: fakeQuantArgs_Qint8_0_1
 func @fakeQuantArgs_Qint8_0_1(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %0 = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<i8:f32, 0.0039215686274509803:-128>>
   // CHECK-NEXT: %1 = "quant.dcast"(%0) : (tensor<8x4x3x!quant.uniform<i8:f32, 0.0039215686274509803:-128>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.0 : f32, max = 1.0 : f32, num_bits = 8, is_signed = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a qint8 asymmetric 0..1 range (with narrow_range = true).
 // CHECK-LABEL: fakeQuantArgs_Qint8_NarrowRange
 func @fakeQuantArgs_Qint8_NarrowRange(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %0 = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<i8<-127:127>:f32, 0.003937007874015748:-127>>
   // CHECK-NEXT: %1 = "quant.dcast"(%0) : (tensor<8x4x3x!quant.uniform<i8<-127:127>:f32, 0.003937007874015748:-127>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.0 : f32, max = 1.0 : f32, num_bits = 8, narrow_range = true, is_signed = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a qint8 symmetric range of -1..127/128.
 // CHECK-LABEL: fakeQuantArgs_Qint8_SymmetricRange
 func @fakeQuantArgs_Qint8_SymmetricRange(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %0 = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<i8:f32, 7.812500e-03>>
   // CHECK-NEXT: %1 = "quant.dcast"(%0) : (tensor<8x4x3x!quant.uniform<i8:f32, 7.812500e-03>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = -1.0 : f32, max = 0.9921875 : f32, num_bits = 8, narrow_range = false, is_signed = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a commonly used -1..1 symmetric 16bit range with a zero point of
 // 0 and range -1.0 .. 32767/32768.
 // CHECK-LABEL: fakeQuantArgs_Qint16_Symmetric
 func @fakeQuantArgs_Qint16_Symmetric(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
   // CHECK: %0 = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<i16:f32, 3.0517578125E-5>>
   // CHECK-NEXT: %1 = "quant.dcast"(%0) : (tensor<8x4x3x!quant.uniform<i16:f32, 3.0517578125E-5>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = -1.0 : f32, max = 0.999969482 : f32, num_bits = 16, is_signed = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verify that lowering to barriers of unranked tensors functions.
 // CHECK-LABEL: fakeQuantArgs_UnrankedTensor
 func @fakeQuantArgs_UnrankedTensor(tensor<f32>) -> tensor<f32> {
 ^bb0(%arg0: tensor<f32>):
   // CHECK: %0 = "quant.qcast"(%arg0) : (tensor<f32>)
   // CHECK-SAME: -> tensor<!quant.uniform<u8:f32, 0.0039215686274509803>>
   // CHECK-NEXT: %1 = "quant.dcast"(%0) : (tensor<!quant.uniform<u8:f32, 0.0039215686274509803>>)
   // CHECK-SAME: -> tensor<f32>
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.0 : f32, max = 1.0 : f32, num_bits = 8
   } : (tensor<f32>) -> tensor<f32>
   return %0 : tensor<f32>
 }
 
 // -----
 // CHECK-LABEL: fakeQuantArgs_all_positive
 func @fakeQuantArgs_all_positive(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
 
   // CHECK: %[[qc:.*]] = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<i8:f32, 0.0039215686274509803:-128>>
   // CHECK-NEXT: "quant.dcast"(%[[qc]]) : (tensor<8x4x3x!quant.uniform<i8:f32, 0.0039215686274509803:-128>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
 
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.5 : f32, max = 1.5 : f32, num_bits = 8, narrow_range = false, is_signed = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // CHECK-LABEL: fakeQuantArgs_all_negative
 func @fakeQuantArgs_all_negative(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
 
   // CHECK: %[[qc:.*]] = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<i8:f32, 0.0039215686274509803:127>>
   // CHECK-NEXT: "quant.dcast"(%[[qc]]) : (tensor<8x4x3x!quant.uniform<i8:f32, 0.0039215686274509803:127>>)
   // CHECK-SAME: -> tensor<8x4x3xf32>
 
   %0 = "quant.const_fake_quant"(%arg0) {
     min = -1.5 : f32, max = -0.5 : f32, num_bits = 8, narrow_range = false, is_signed = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // Verifies a qint8 per axis
 // CHECK-LABEL: fakeQuantPerAxis
 func @fakeQuantPerAxis(tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
 ^bb0(%arg0: tensor<8x4x3xf32>):
 
   // CHECK: %[[q:.*]] = "quant.qcast"(%arg0) : (tensor<8x4x3xf32>)
   // CHECK-SAME: -> tensor<8x4x3x!quant.uniform<i8:f32:2, {7.812500e-03,1.000000e+00:-128,0.0039215686274509803:-128}>>
   // CHECK: %[[d:.*]] = "quant.dcast"(%[[q]])
   // CHECK-SAME: (tensor<8x4x3x!quant.uniform<i8:f32:2, {7.812500e-03,1.000000e+00:-128,0.0039215686274509803:-128}>>)
 
   %0 = "quant.const_fake_quant_per_axis"(%arg0) {
     min = [-1.0 : f32, 0.0 : f32, 0.0 : f32],
     max = [0.9921875 : f32, 0.0: f32, 1.0 : f32],
     num_bits = 8, narrow_range = false, is_signed = true, axis = 2
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }

mlir/test/Dialect/Quant/parse-any-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // -----
 // Unrecognized token: missing storage type maximum
 // expected-error@+1 {{expected ':'}}
 !qalias = type !quant.any<i8<16>:f32>
 
 // -----
 // Unrecognized token: missing closing angle bracket
 // expected-error@+1 {{expected '>'}}
 !qalias = type !quant<"any<i8<-4:3:f32>">
 
 // -----
 // Unrecognized token: missing type colon
 // expected-error@+1 {{expected '>'}}
 !qalias = type !quant.any<i8<-4:3>f32>
 
 // -----
 // Unrecognized storage type: illegal prefix
 // expected-error@+1 {{illegal storage type prefix}}
 !qalias = type !quant.any<int8<-4:3>:f32>
 
 // -----
 // Unrecognized storage type: no width
 // expected-error@+1 {{illegal storage type prefix}}
 !qalias = type !quant.any<i<-4:3>:f32>
 
 // -----
 // Unrecognized storage type: storage size > 32
 // expected-error@+1 {{illegal storage type size: 33}}
 !qalias = type !quant.any<i33:f32>
 
 // -----
 // Unrecognized storage type: storage size < 0
 // expected-error@+1 {{illegal storage type size: 1024}}
 !qalias = type !quant.any<i1024<-4:3>:f32>
 
 // -----
 // Unrecognized storage type: storage size == 0
 // expected-error@+1 {{invalid integer width}}
 !qalias = type !quant.any<i0<-4:3>:f32>
 
 // -----
 // Illegal storage min/max: max - min < 0
 // expected-error@+1 {{illegal storage min and storage max: (2:1)}}
 !qalias = type !quant.any<i8<2:1>:f32>
 
 // -----
 // Illegal storage min/max: max - min == 0
 // expected-error@+1 {{illegal storage min and storage max: (1:1)}}
 !qalias = type !quant.any<i8<1:1>:f32>
 
 // -----
 // Illegal storage min/max: max > defaultMax
 // expected-error@+1 {{illegal storage type maximum: 9}}
 !qalias = type !quant.any<i4<-1:9>:f32>
 
 // -----
 // Illegal storage min/max: min < defaultMin
 // expected-error@+1 {{illegal storage type minimum: -9}}
 !qalias = type !quant.any<i4<-9:1>:f32>

mlir/test/Dialect/Quant/parse-any.mlir

 // RUN: mlir-opt %s -split-input-file | FileCheck %s
 
 // -----
 // CHECK-LABEL: parseFullySpecified
 // CHECK: !quant.any<i8<-8:7>:f32>
 !qalias = type !quant.any<i8<-8:7>:f32>
 func @parseFullySpecified() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // CHECK-LABEL: parseNoExpressedType
 // CHECK: !quant.any<i8<-8:7>>
 !qalias = type !quant.any<i8<-8:7>>
 func @parseNoExpressedType() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // CHECK-LABEL: parseOnlyStorageType
 // CHECK: !quant.any<i8>
 !qalias = type !quant.any<i8>
 func @parseOnlyStorageType() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }

mlir/test/Dialect/Quant/parse-ops-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // -----
 func @invalidStatisticsMismatchedLayerType(%arg0: tensor<8x4x3xf32>) ->
     tensor<8x4x3xf32> {
   // expected-error@+1 {{layerStats must have a floating point element type}}
   %0 = "quant.stats"(%arg0) {
     layerStats = dense<[-1, 1]> : tensor<2xi8>
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 func @invalidStatisticsMismatchedLayerRank(%arg0: tensor<8x4x3xf32>) ->
     tensor<8x4x3xf32> {
   // expected-error@+1 {{layerStats must have shape [2]}}
   %0 = "quant.stats"(%arg0) {
     layerStats = dense<[[-1.0, 1.0]]> : tensor<1x2xf32>
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 func @invalidStatisticsMismatchedLayerShape(%arg0: tensor<8x4x3xf32>) ->
     tensor<8x4x3xf32> {
   // expected-error@+1 {{layerStats must have shape [2]}}
   %0 = "quant.stats"(%arg0) {
     layerStats = dense<[-1.0, 1.0, 2.0]> : tensor<3xf32>
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // CHECK-LABEL: validStatistics
 func @invalidStatisticsMismatchedAxisType(%arg0: tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
   // expected-error@+1 {{axisStats must have a floating point element type}}
   %0 = "quant.stats"(%0) {
     layerStats = dense<[-1.0, 1.0]> : tensor<2xf32>,
     axisStats = dense<[
       [-1, 1],
       [-8, 8],
       [-1, 0]
     ]> : tensor<3x2xi8>, axis = 3 : i64
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 func @invalidStatisticsMismatchedAxisSize(%arg0: tensor<8x4x3xf32>) ->
     tensor<8x4x3xf32> {
   // expected-error@+1 {{axisStats must have shape [N,2] where N = the slice size defined by the axis dim}}
   %0 = "quant.stats"(%arg0) {
     layerStats = dense<[-1.0, 1.0]> : tensor<2xf32>,
     axisStats = dense<[
       [-1.0, 1.0],
       [-8.0, 8.0],
       [-0.5, 0.5],
       [-2.0, 3.5]
     ]> : tensor<4x2xf32>, axis = 3 : i64
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 func @invalidStatisticsMismatchedAxisShape(%arg0: tensor<8x4x3xf32>) ->
     tensor<8x4x3xf32> {
   // expected-error@+1 {{axisStats must have shape [N,2] where N = the slice size defined by the axis dim}}
   %0 = "quant.stats"(%arg0) {
     layerStats = dense<[-1.0, 1.0]> : tensor<2xf32>,
     axisStats = dense<[
       [-1.0, 1.0, 1.0],
       [-8.0, 8.0, 1.0],
       [-0.5, 0.5, 1.0]
     ]> : tensor<3x3xf32>, axis = 3 : i64
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 func @axisIsRequiredForAxisStats(%arg0: tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
   // expected-error@+1 {{axis must be specified for axisStats}}
   %1 = "quant.stats"(%arg0) {
     layerStats = dense<[-1.0, 1.0]> : tensor<2xf32>,
     axisStats = dense<[
       [-1.0, 1.0],
       [-8.0, 8.0],
       [-0.5, 0.5]
     ]> : tensor<3x2xf32>
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %1 : tensor<8x4x3xf32>
 }
 
 // -----

mlir/test/Dialect/Quant/parse-ops.mlir

 // RUN: mlir-opt %s -split-input-file | FileCheck %s
 
 // -----
 // CHECK-LABEL: validConstFakeQuant
 func @validConstFakeQuant(%arg0: tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
   %0 = "quant.const_fake_quant"(%arg0) {
     min = 0.0 : f32, max = 1.0 : f32, num_bits = 8, narrow_range = true
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   %1 = "quant.const_fake_quant"(%0) {
     min = 0.0 : f32, max = 1.0 : f32, num_bits = 8, narrow_range = false
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   %2 = "quant.const_fake_quant"(%1) {
     min = 0.0 : f32, max = 1.0 : f32, num_bits = 8
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %2 : tensor<8x4x3xf32>
 }
 
 // -----
 // CHECK-LABEL: validConstFakeQuantPerAxis
 func @validConstFakeQuantPerAxis(%arg0: tensor<8x4x2xf32>) -> tensor<8x4x2xf32> {
   %0 = "quant.const_fake_quant_per_axis"(%arg0) {
     min = [0.0 : f32, 1.0 : f32], max = [2.0 : f32, 3.0 : f32], axis = 2, num_bits = 8, narrow_range = true
   } : (tensor<8x4x2xf32>) -> tensor<8x4x2xf32>
   %1 = "quant.const_fake_quant_per_axis"(%0) {
     min = [0.0 : f32, 1.0 : f32], max = [2.0 : f32, 3.0 : f32], axis = 2, num_bits = 8, narrow_range = false
   } : (tensor<8x4x2xf32>) -> tensor<8x4x2xf32>
   %2 = "quant.const_fake_quant_per_axis"(%1) {
     min = [0.0 : f32, 1.0 : f32], max = [2.0 : f32, 3.0 : f32], axis = 2, num_bits = 8
   } : (tensor<8x4x2xf32>) -> tensor<8x4x2xf32>
   return %2 : tensor<8x4x2xf32>
 }
 
 // -----
 // CHECK-LABEL: validStatisticsRef
 func @validStatisticsRef(%arg0: tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
   %0 = "quant.stats_ref"(%arg0) { statsKey = "foobar" } :
       (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }
 
 // -----
 // CHECK-LABEL: validStatistics
 func @validStatistics(%arg0: tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
   %0 = "quant.stats"(%arg0) {
     layerStats = dense<[-1.0, 1.0]> : tensor<2xf32>
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   %1 = "quant.stats"(%0) {
     layerStats = dense<[-1.0, 1.0]> : tensor<2xf32>,
     axisStats = dense<[
       [-1.0, 1.0],
       [-8.0, 8.0],
       [-0.5, 0.5]
     ]> : tensor<3x2xf32>, axis = 2 : i64
   } : (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %1 : tensor<8x4x3xf32>
 }
 
 // -----
 // CHECK-LABEL: validCoupledRef
 func @validCoupledRef(%arg0: tensor<8x4x3xf32>) -> tensor<8x4x3xf32> {
   %0 = "quant.coupled_ref"(%arg0) { coupledKey = "foobar" } :
       (tensor<8x4x3xf32>) -> tensor<8x4x3xf32>
   return %0 : tensor<8x4x3xf32>
 }

mlir/test/Dialect/Quant/parse-uniform-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // -----
 // Invalid type.
 // expected-error@+1 {{unknown quantized type foobar}}
 !qalias = type !quant.foobar
 
 // -----
 // Unrecognized token: illegal token
 // expected-error@+1 {{unknown quantized type __}}
 !qalias = type !quant.__
 
 // -----
 // Unrecognized token: trailing
 // expected-error@+1 {{expected '>'}}
 !qalias = type !quant.uniform<i8<-4:3>:f32, 0.99872:127 23>
 
 // -----
 // Unrecognized token: missing storage type maximum
 // expected-error@+1 {{expected ':'}}
 !qalias = type !quant.uniform<i8<16>:f32, 0.99872:127>
 
 // -----
 // Unrecognized token: missing closing angle bracket
 // expected-error@+1 {{expected '>'}}
 !qalias = type !quant<"uniform<i8<-4:3:f32, 0.99872:127>">
 
 // -----
 // Unrecognized token: missing type colon
 // expected-error@+1 {{expected ':'}}
 !qalias = type !quant.uniform<i8<-4:3>f32, 0.99872:127>
 
 // -----
 // Unrecognized token: missing comma
 // expected-error@+1 {{expected ','}}
 !qalias = type !quant.uniform<i8<-4:3>:f32 0.99872:127>
 
 // -----
 // Unrecognized storage type: illegal prefix
 // expected-error@+1 {{illegal storage type prefix}}
 !qalias = type !quant.uniform<int8<-4:3>:f32, 0.99872:127>
 
 // -----
 // Unrecognized storage type: no width
 // expected-error@+1 {{illegal storage type prefix}}
 !qalias = type !quant.uniform<i<-4:3>:f32, 0.99872:127>
 
 // -----
 // Unrecognized storage type: storage size > 32
 // expected-error@+1 {{illegal storage type size: 33}}
 !qalias = type !quant.uniform<i33:f32, 0.99872:127>
 
 // -----
 // Unrecognized storage type: storage size < 0
 // expected-error@+1 {{illegal storage type prefix}}
 !qalias = type !quant.uniform<i-1<-4:3>:f32, 0.99872:127>
 
 // -----
 // Unrecognized storage type: storage size == 0
 // expected-error@+1 {{invalid integer width}}
 !qalias = type !quant.uniform<i0<-4:3>:f32, 0.99872:127>
 
 // -----
 // Illegal storage min/max: max - min < 0
 // expected-error@+1 {{illegal storage min and storage max: (2:1)}}
 !qalias = type !quant.uniform<i8<2:1>:f32, 0.99872:127>
 
 // -----
 // Illegal storage min/max: max - min == 0
 // expected-error@+1 {{illegal storage min and storage max: (1:1)}}
 !qalias = type !quant.uniform<i8<1:1>:f32, 0.99872:127>
 
 // -----
 // Illegal storage min/max: max > defaultMax
 // expected-error@+1 {{illegal storage type maximum: 9}}
 !qalias = type !quant.uniform<i4<-1:9>:f32, 0.99872:127>
 
 // -----
 // Illegal storage min/max: min < defaultMin
 // expected-error@+1 {{illegal storage type minimum: -9}}
 !qalias = type !quant.uniform<i4<-9:1>:f32, 0.99872:127>
 
 // -----
 // Illegal uniform params: invalid scale
 // expected-error@+1 {{expected floating point literal}}
 !qalias = type !quant.uniform<i8<-4:3>:f32, abc:127>
 
 // -----
 // Illegal uniform params: invalid zero point separator
 // expected-error@+1 {{expected '>'}}
 !qalias = type !quant.uniform<i8<-4:3>:f32, 0.1abc>
 
 // -----
 // Illegal uniform params: missing zero point
 // expected-error@+1 {{expected integer value}}
 !qalias = type !quant.uniform<i8<-4:3>:f32, 0.1:>
 
 // -----
 // Illegal uniform params: invalid zero point
 // expected-error@+1 {{expected integer value}}
 !qalias = type !quant.uniform<i8<-4:3>:f32, 0.1:abc>
 
 // -----
 // Illegal expressed type: f33
 // expected-error@+1 {{expected non-function type}}
 !qalias = type !quant.uniform<i8<-4:3>:f33, 0.99872:127>
 
 // -----
 // Illegal scale: negative
 // expected-error@+1 {{illegal scale: -1.000000}}
 !qalias = type !quant.uniform<i8<-4:3>:f32, -1.0:127>
 
 // -----
 // Illegal uniform params: missing quantized dimension
 // expected-error@+1 {{expected integer value}}
 !qalias = type !quant.uniform<i8<-4:3>:f32:, {2.000000e+02:-19.987200e-01:1}>
 
 // -----
 // Illegal uniform params: unspecified quantized dimension, when multiple scales
 // provided.
 // expected-error@+1 {{expected floating point literal}}
 !qalias = type !quant.uniform<i8<-4:3>:f32, {2.000000e+02,-19.987200e-01:1}>

mlir/test/Dialect/Quant/parse-uniform.mlir

 // RUN: mlir-opt %s -split-input-file | FileCheck %s
 
 // -----
 // All per-layer params specified:
 //   [signed] storageType, storageTypeMin, storageTypeMax, expressedType, scale, zeroPoint
 // CHECK: !quant.uniform<i8<-8:7>:f32, 9.987200e-01:127>
 !qalias = type !quant.uniform<i8<-8:7>:f32, 0.99872:127>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Trailing whitespace.
 // CHECK: !quant.uniform<i8<-8:7>:f32, 9.987200e-01:127>
 !qalias = type !quant.uniform<i8<-8:7>:f32, 0.99872:127  >
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Required per-layer params specified:
 //   [unsigned] storageType, expressedType, scale
 // CHECK: !quant.uniform<u8:f32, 9.987200e-01>
 !qalias = type !quant.uniform<u8:f32, 0.99872>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Exponential scale (-)
 // CHECK: !quant.uniform<u8:f32, 2.000000e-02>
 !qalias = type !quant.uniform<u8:f32, 2.0e-2>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Exponential scale (+)
 // CHECK: !quant.uniform<u8:f32, 2.000000e+02>
 !qalias = type !quant.uniform<u8:f32, 2.0e+2>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Storage type: i16
 // CHECK: !quant.uniform<i16:f32, 2.000000e+02>
 !qalias = type !quant.uniform<i16:f32, 2.0e+2>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Storage type: u16
 // CHECK: !quant.uniform<u16:f32, 2.000000e+02>
 !qalias = type !quant.uniform<u16:f32, 2.0e+2>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Storage type: i32
 // CHECK: !quant.uniform<i32:f32, 2.000000e+02>
 !qalias = type !quant.uniform<i32:f32, 2.0e+2>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Storage type: u32
 // CHECK: !quant.uniform<u32:f32, 2.000000e+02>
 !qalias = type !quant.uniform<u32:f32, 2.0e+2>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Expressed type: f32
 // CHECK: !quant.uniform<u8:f32, 2.000000e+02>
 !qalias = type !quant.uniform<u8:f32, 2.0e+2>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Expressed type: f16
 // CHECK: !quant.uniform<u8:f16, 2.000000e+02>
 !qalias = type !quant.uniform<u8:f16, 2.0e+2>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Expressed type: f64
 // CHECK: !quant.uniform<u8:f64, 2.000000e+02>
 !qalias = type !quant.uniform<u8:f64, 2.0e+2>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Expressed type: bf16
 // CHECK: !quant.uniform<u8:bf16, 2.000000e+02>
 !qalias = type !quant.uniform<u8:bf16, 2.0e+2>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Per-axis scales and zero points (affine)
 // CHECK: !quant.uniform<u8:f32:1, {2.000000e+02:-120,9.987200e-01:127}>
 !qalias = type !quant.uniform<u8:f32:1, {2.0e+2:-120,0.99872:127}>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Per-axis scales and no zero points (fixedpoint)
 // CHECK: !quant.uniform<i8:f32:1, {2.000000e+02,9.987200e-01}>
 !qalias = type !quant.uniform<i8:f32:1, {2.0e+2,0.99872}>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Per-axis scales and zero points (mixed affine and fixedpoint)
 // CHECK: !quant.uniform<i8:f32:1, {2.000000e+02,9.987200e-01:120}>
 !qalias = type !quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>
 func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }

mlir/unittests/Dialect/Quant/QuantizationUtilsTest.cpp

 //===- QuantizationUtilsTest.cpp - unit tests for quantization utils ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/QuantOps/QuantOps.h"
-#include "mlir/Dialect/QuantOps/QuantizeUtils.h"
-#include "mlir/Dialect/QuantOps/UniformSupport.h"
+#include "mlir/Dialect/Quant/QuantizeUtils.h"
+#include "mlir/Dialect/Quant/QuantOps.h"
+#include "mlir/Dialect/Quant/UniformSupport.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/StandardTypes.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace mlir;
 using namespace mlir::quant;