5550c82189
The MLIR classes Type/Attribute/Operation/Op/Value support cast/dyn_cast/isa/dyn_cast_or_null functionality through llvm's doCast functionality in addition to defining methods with the same name. This change begins the migration of uses of the method to the corresponding function call as has been decided as more consistent. Note that there still exist classes that only define methods directly, such as AffineExpr, and this does not include work currently to support a functional cast/isa call. Caveats include: - This clang-tidy script probably has more problems. - This only touches C++ code, so nothing that is being generated. Context: - https://mlir.llvm.org/deprecation/ at "Use the free function variants for dyn_cast/cast/isa/…" - Original discussion at https://discourse.llvm.org/t/preferred-casting-style-going-forward/68443 Implementation: This first patch was created with the following steps. The intention is to only do automated changes at first, so I waste less time if it's reverted, and so the first mass change is more clear as an example to other teams that will need to follow similar steps. Steps are described per line, as comments are removed by git: 0. Retrieve the change from the following to build clang-tidy with an additional check: https://github.com/llvm/llvm-project/compare/main...tpopp:llvm-project:tidy-cast-check 1. Build clang-tidy 2. Run clang-tidy over your entire codebase while disabling all checks and enabling the one relevant one. Run on all header files also. 3. Delete .inc files that were also modified, so the next build rebuilds them to a pure state. 4. Some changes have been deleted for the following reasons: - Some files had a variable also named cast - Some files had not included a header file that defines the cast functions - Some files are definitions of the classes that have the casting methods, so the code still refers to the method instead of the function without adding a prefix or removing the method declaration at the same time. ``` ninja -C $BUILD_DIR clang-tidy run-clang-tidy -clang-tidy-binary=$BUILD_DIR/bin/clang-tidy -checks='-*,misc-cast-functions'\ -header-filter=mlir/ mlir/* -fix rm -rf $BUILD_DIR/tools/mlir/**/*.inc git restore mlir/lib/IR mlir/lib/Dialect/DLTI/DLTI.cpp\ mlir/lib/Dialect/Complex/IR/ComplexDialect.cpp\ mlir/lib/**/IR/\ mlir/lib/Dialect/SparseTensor/Transforms/SparseVectorization.cpp\ mlir/lib/Dialect/Vector/Transforms/LowerVectorMultiReduction.cpp\ mlir/test/lib/Dialect/Test/TestTypes.cpp\ mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp\ mlir/test/lib/Dialect/Test/TestAttributes.cpp\ mlir/unittests/TableGen/EnumsGenTest.cpp\ mlir/test/python/lib/PythonTestCAPI.cpp\ mlir/include/mlir/IR/ ``` Differential Revision: https://reviews.llvm.org/D150123
218 lines
8.2 KiB
C++
218 lines
8.2 KiB
C++
//===- Quant.cpp - C Interface for Quant dialect --------------------------===//
|
|
//
|
|
// 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-c/Dialect/Quant.h"
|
|
#include "mlir/CAPI/Registration.h"
|
|
#include "mlir/Dialect/Quant/QuantOps.h"
|
|
#include "mlir/Dialect/Quant/QuantTypes.h"
|
|
|
|
using namespace mlir;
|
|
|
|
MLIR_DEFINE_CAPI_DIALECT_REGISTRATION(quant, quant, quant::QuantizationDialect)
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
// QuantizedType
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
bool mlirTypeIsAQuantizedType(MlirType type) {
|
|
return isa<quant::QuantizedType>(unwrap(type));
|
|
}
|
|
|
|
unsigned mlirQuantizedTypeGetSignedFlag() {
|
|
return quant::QuantizationFlags::Signed;
|
|
}
|
|
|
|
int64_t mlirQuantizedTypeGetDefaultMinimumForInteger(bool isSigned,
|
|
unsigned integralWidth) {
|
|
return quant::QuantizedType::getDefaultMinimumForInteger(isSigned,
|
|
integralWidth);
|
|
}
|
|
|
|
int64_t mlirQuantizedTypeGetDefaultMaximumForInteger(bool isSigned,
|
|
unsigned integralWidth) {
|
|
return quant::QuantizedType::getDefaultMaximumForInteger(isSigned,
|
|
integralWidth);
|
|
}
|
|
|
|
MlirType mlirQuantizedTypeGetExpressedType(MlirType type) {
|
|
return wrap(cast<quant::QuantizedType>(unwrap(type)).getExpressedType());
|
|
}
|
|
|
|
unsigned mlirQuantizedTypeGetFlags(MlirType type) {
|
|
return cast<quant::QuantizedType>(unwrap(type)).getFlags();
|
|
}
|
|
|
|
bool mlirQuantizedTypeIsSigned(MlirType type) {
|
|
return cast<quant::QuantizedType>(unwrap(type)).isSigned();
|
|
}
|
|
|
|
MlirType mlirQuantizedTypeGetStorageType(MlirType type) {
|
|
return wrap(cast<quant::QuantizedType>(unwrap(type)).getStorageType());
|
|
}
|
|
|
|
int64_t mlirQuantizedTypeGetStorageTypeMin(MlirType type) {
|
|
return cast<quant::QuantizedType>(unwrap(type)).getStorageTypeMin();
|
|
}
|
|
|
|
int64_t mlirQuantizedTypeGetStorageTypeMax(MlirType type) {
|
|
return cast<quant::QuantizedType>(unwrap(type)).getStorageTypeMax();
|
|
}
|
|
|
|
unsigned mlirQuantizedTypeGetStorageTypeIntegralWidth(MlirType type) {
|
|
return cast<quant::QuantizedType>(unwrap(type)).getStorageTypeIntegralWidth();
|
|
}
|
|
|
|
bool mlirQuantizedTypeIsCompatibleExpressedType(MlirType type,
|
|
MlirType candidate) {
|
|
return cast<quant::QuantizedType>(unwrap(type))
|
|
.isCompatibleExpressedType(unwrap(candidate));
|
|
}
|
|
|
|
MlirType mlirQuantizedTypeGetQuantizedElementType(MlirType type) {
|
|
return wrap(quant::QuantizedType::getQuantizedElementType(unwrap(type)));
|
|
}
|
|
|
|
MlirType mlirQuantizedTypeCastFromStorageType(MlirType type,
|
|
MlirType candidate) {
|
|
return wrap(cast<quant::QuantizedType>(unwrap(type))
|
|
.castFromStorageType(unwrap(candidate)));
|
|
}
|
|
|
|
MlirType mlirQuantizedTypeCastToStorageType(MlirType type) {
|
|
return wrap(quant::QuantizedType::castToStorageType(
|
|
cast<quant::QuantizedType>(unwrap(type))));
|
|
}
|
|
|
|
MlirType mlirQuantizedTypeCastFromExpressedType(MlirType type,
|
|
MlirType candidate) {
|
|
return wrap(cast<quant::QuantizedType>(unwrap(type))
|
|
.castFromExpressedType(unwrap(candidate)));
|
|
}
|
|
|
|
MlirType mlirQuantizedTypeCastToExpressedType(MlirType type) {
|
|
return wrap(quant::QuantizedType::castToExpressedType(unwrap(type)));
|
|
}
|
|
|
|
MlirType mlirQuantizedTypeCastExpressedToStorageType(MlirType type,
|
|
MlirType candidate) {
|
|
return wrap(cast<quant::QuantizedType>(unwrap(type))
|
|
.castExpressedToStorageType(unwrap(candidate)));
|
|
}
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
// AnyQuantizedType
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
bool mlirTypeIsAAnyQuantizedType(MlirType type) {
|
|
return isa<quant::AnyQuantizedType>(unwrap(type));
|
|
}
|
|
|
|
MlirType mlirAnyQuantizedTypeGet(unsigned flags, MlirType storageType,
|
|
MlirType expressedType, int64_t storageTypeMin,
|
|
int64_t storageTypeMax) {
|
|
return wrap(quant::AnyQuantizedType::get(flags, unwrap(storageType),
|
|
unwrap(expressedType),
|
|
storageTypeMin, storageTypeMax));
|
|
}
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
// UniformQuantizedType
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
bool mlirTypeIsAUniformQuantizedType(MlirType type) {
|
|
return isa<quant::UniformQuantizedType>(unwrap(type));
|
|
}
|
|
|
|
MlirType mlirUniformQuantizedTypeGet(unsigned flags, MlirType storageType,
|
|
MlirType expressedType, double scale,
|
|
int64_t zeroPoint, int64_t storageTypeMin,
|
|
int64_t storageTypeMax) {
|
|
return wrap(quant::UniformQuantizedType::get(
|
|
flags, unwrap(storageType), unwrap(expressedType), scale, zeroPoint,
|
|
storageTypeMin, storageTypeMax));
|
|
}
|
|
|
|
double mlirUniformQuantizedTypeGetScale(MlirType type) {
|
|
return cast<quant::UniformQuantizedType>(unwrap(type)).getScale();
|
|
}
|
|
|
|
int64_t mlirUniformQuantizedTypeGetZeroPoint(MlirType type) {
|
|
return cast<quant::UniformQuantizedType>(unwrap(type)).getZeroPoint();
|
|
}
|
|
|
|
bool mlirUniformQuantizedTypeIsFixedPoint(MlirType type) {
|
|
return cast<quant::UniformQuantizedType>(unwrap(type)).isFixedPoint();
|
|
}
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
// UniformQuantizedPerAxisType
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
bool mlirTypeIsAUniformQuantizedPerAxisType(MlirType type) {
|
|
return isa<quant::UniformQuantizedPerAxisType>(unwrap(type));
|
|
}
|
|
|
|
MlirType mlirUniformQuantizedPerAxisTypeGet(
|
|
unsigned flags, MlirType storageType, MlirType expressedType,
|
|
intptr_t nDims, double *scales, int64_t *zeroPoints,
|
|
int32_t quantizedDimension, int64_t storageTypeMin,
|
|
int64_t storageTypeMax) {
|
|
return wrap(quant::UniformQuantizedPerAxisType::get(
|
|
flags, unwrap(storageType), unwrap(expressedType),
|
|
llvm::ArrayRef(scales, nDims), llvm::ArrayRef(zeroPoints, nDims),
|
|
quantizedDimension, storageTypeMin, storageTypeMax));
|
|
}
|
|
|
|
intptr_t mlirUniformQuantizedPerAxisTypeGetNumDims(MlirType type) {
|
|
return cast<quant::UniformQuantizedPerAxisType>(unwrap(type))
|
|
.getScales()
|
|
.size();
|
|
}
|
|
|
|
double mlirUniformQuantizedPerAxisTypeGetScale(MlirType type, intptr_t pos) {
|
|
return cast<quant::UniformQuantizedPerAxisType>(unwrap(type))
|
|
.getScales()[pos];
|
|
}
|
|
|
|
int64_t mlirUniformQuantizedPerAxisTypeGetZeroPoint(MlirType type,
|
|
intptr_t pos) {
|
|
return cast<quant::UniformQuantizedPerAxisType>(unwrap(type))
|
|
.getZeroPoints()[pos];
|
|
}
|
|
|
|
int32_t mlirUniformQuantizedPerAxisTypeGetQuantizedDimension(MlirType type) {
|
|
return cast<quant::UniformQuantizedPerAxisType>(unwrap(type))
|
|
.getQuantizedDimension();
|
|
}
|
|
|
|
bool mlirUniformQuantizedPerAxisTypeIsFixedPoint(MlirType type) {
|
|
return cast<quant::UniformQuantizedPerAxisType>(unwrap(type)).isFixedPoint();
|
|
}
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
// CalibratedQuantizedType
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
bool mlirTypeIsACalibratedQuantizedType(MlirType type) {
|
|
return isa<quant::CalibratedQuantizedType>(unwrap(type));
|
|
}
|
|
|
|
MlirType mlirCalibratedQuantizedTypeGet(MlirType expressedType, double min,
|
|
double max) {
|
|
return wrap(
|
|
quant::CalibratedQuantizedType::get(unwrap(expressedType), min, max));
|
|
}
|
|
|
|
double mlirCalibratedQuantizedTypeGetMin(MlirType type) {
|
|
return cast<quant::CalibratedQuantizedType>(unwrap(type)).getMin();
|
|
}
|
|
|
|
double mlirCalibratedQuantizedTypeGetMax(MlirType type) {
|
|
return cast<quant::CalibratedQuantizedType>(unwrap(type)).getMax();
|
|
}
|