diff --git a/mlir/include/mlir/Dialect/EmitC/IR/EmitC.h b/mlir/include/mlir/Dialect/EmitC/IR/EmitC.h
index 5d9531cd12415..575b91516b919 100644
--- a/mlir/include/mlir/Dialect/EmitC/IR/EmitC.h
+++ b/mlir/include/mlir/Dialect/EmitC/IR/EmitC.h
@@ -43,6 +43,10 @@ bool isIntegerIndexOrOpaqueType(Type type);
/// Determines whether \p type is a valid floating-point type in EmitC.
bool isSupportedFloatType(mlir::Type type);
+
+/// Determines whether \p type is a emitc.size_t/ssize_t type.
+bool isAnySizeTType(mlir::Type type);
+
} // namespace emitc
} // namespace mlir
diff --git a/mlir/include/mlir/Dialect/EmitC/IR/EmitC.td b/mlir/include/mlir/Dialect/EmitC/IR/EmitC.td
index 5da8593f59563..e664a1749216d 100644
--- a/mlir/include/mlir/Dialect/EmitC/IR/EmitC.td
+++ b/mlir/include/mlir/Dialect/EmitC/IR/EmitC.td
@@ -51,7 +51,8 @@ class EmitC_BinaryOp<string mnemonic, list<Trait> traits = []> :
def CExpression : NativeOpTrait<"emitc::CExpression">;
// Types only used in binary arithmetic operations.
-def IntegerIndexOrOpaqueType : AnyTypeOf<[EmitCIntegerType, Index, EmitC_OpaqueType]>;
+def IntegerIndexOrOpaqueType : AnyTypeOf<[EmitCIntegerType, Index,
+ EmitC_SignedSizeT, EmitC_SizeT, EmitC_OpaqueType]>;
def FloatIntegerIndexOrOpaqueType : AnyTypeOf<[EmitCFloatType, IntegerIndexOrOpaqueType]>;
def EmitC_AddOp : EmitC_BinaryOp<"add", [CExpression]> {
@@ -287,6 +288,7 @@ def EmitC_CastOp : EmitC_Op<"cast",
let arguments = (ins EmitCType:$source);
let results = (outs EmitCType:$dest);
let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
+ let hasFolder = 1;
}
def EmitC_CmpOp : EmitC_BinaryOp<"cmp", [CExpression]> {
@@ -470,7 +472,7 @@ def EmitC_ForOp : EmitC_Op<"for",
upper bound and step respectively, and defines an SSA value for its
induction variable. It has one region capturing the loop body. The induction
variable is represented as an argument of this region. This SSA value is a
- signless integer or index. The step is a value of same type.
+ signless integer, or an index. The step is a value of same type.
This operation has no result. The body region must contain exactly one block
that terminates with `emitc.yield`. Calling ForOp::build will create such a
diff --git a/mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td b/mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td
index 444395b915e25..0f080ac443327 100644
--- a/mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td
+++ b/mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td
@@ -130,4 +130,12 @@ def EmitC_PointerType : EmitC_Type<"Pointer", "ptr"> {
let assemblyFormat = "`<` qualified($pointee) `>`";
}
+def EmitC_SignedSizeT : EmitC_Type<"SignedSizeT", "ssize_t"> {
+ let summary = "EmitC signed size type";
+}
+
+def EmitC_SizeT : EmitC_Type<"SizeT", "size_t"> {
+ let summary = "EmitC unsigned size type";
+}
+
#endif // MLIR_DIALECT_EMITC_IR_EMITCTYPES
diff --git a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h
new file mode 100644
index 0000000000000..da16b336b8bc3
--- /dev/null
+++ b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h
@@ -0,0 +1,13 @@
+//===- TypeConversions.h - Convert signless types into C/C++ 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Transforms/DialectConversion.h"
+
+namespace mlir {
+void populateEmitCSizeTypeConversionPatterns(mlir::TypeConverter &converter);
+} // namespace mlir
diff --git a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp
index 5fe4fc8695017..62067c5e25644 100644
--- a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp
+++ b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp
@@ -15,6 +15,7 @@
#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h"
+#include "mlir/Dialect/EmitC/Transforms/TypeConversions.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/Support/LogicalResult.h"
@@ -36,8 +37,11 @@ class ArithConstantOpConversionPattern
matchAndRewrite(arith::ConstantOp arithConst,
arith::ConstantOp::Adaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
- rewriter.replaceOpWithNewOp<emitc::ConstantOp>(
- arithConst, arithConst.getType(), adaptor.getValue());
+ Type newTy = this->getTypeConverter()->convertType(arithConst.getType());
+ if (!newTy)
+ return rewriter.notifyMatchFailure(arithConst, "type conversion failed");
+ rewriter.replaceOpWithNewOp<emitc::ConstantOp>(arithConst, newTy,
+ adaptor.getValue());
return success();
}
};
@@ -201,6 +205,35 @@ class CmpFOpConversion : public OpConversionPattern<arith::CmpFOp> {
}
};
+/// Check if the signedness of type \p ty matches the expected
+/// signedness, and issue a type with the correct signedness if
+/// necessary.
+Type adaptIntegralTypeSignedness(Type ty, bool needsUnsigned) {
+ if (isa<IntegerType>(ty)) {
+ // Turns signless integers into signed integers.
+ if (ty.isUnsignedInteger() != needsUnsigned) {
+ auto signedness = needsUnsigned
+ ? IntegerType::SignednessSemantics::Unsigned
+ : IntegerType::SignednessSemantics::Signed;
+ return IntegerType::get(ty.getContext(), ty.getIntOrFloatBitWidth(),
+ signedness);
+ }
+ } else if (emitc::isAnySizeTType(ty)) {
+ if (isa<emitc::SizeTType>(ty) != needsUnsigned) {
+ if (needsUnsigned)
+ return emitc::SizeTType::get(ty.getContext());
+ return emitc::SignedSizeTType::get(ty.getContext());
+ }
+ }
+ return ty;
+}
+
+/// Insert a cast operation to type \p ty if \p val
+/// does not have this type.
+Value adaptValueType(Value val, ConversionPatternRewriter &rewriter, Type ty) {
+ return rewriter.createOrFold<emitc::CastOp>(val.getLoc(), ty, val);
+}
+
class CmpIOpConversion : public OpConversionPattern<arith::CmpIOp> {
public:
using OpConversionPattern::OpConversionPattern;
@@ -250,31 +283,25 @@ class CmpIOpConversion : public OpConversionPattern<arith::CmpIOp> {
ConversionPatternRewriter &rewriter) const override {
Type type = adaptor.getLhs().getType();
- if (!isa_and_nonnull<IntegerType, IndexType>(type)) {
- return rewriter.notifyMatchFailure(op, "expected integer or index type");
+ if (!isa_and_nonnull<IntegerType, emitc::SignedSizeTType, emitc::SizeTType>(
+ type)) {
+ return rewriter.notifyMatchFailure(
+ op, "expected integer or size_t/ssize_t type");
}
bool needsUnsigned = needsUnsignedCmp(op.getPredicate());
emitc::CmpPredicate pred = toEmitCPred(op.getPredicate());
- Type arithmeticType = type;
- if (type.isUnsignedInteger() != needsUnsigned) {
- arithmeticType = rewriter.getIntegerType(type.getIntOrFloatBitWidth(),
- /*isSigned=*/!needsUnsigned);
- }
- Value lhs = adaptor.getLhs();
- Value rhs = adaptor.getRhs();
- if (arithmeticType != type) {
- lhs = rewriter.template create<emitc::CastOp>(op.getLoc(), arithmeticType,
- lhs);
- rhs = rewriter.template create<emitc::CastOp>(op.getLoc(), arithmeticType,
- rhs);
- }
+
+ Type arithmeticType = adaptIntegralTypeSignedness(type, needsUnsigned);
+ Value lhs = adaptValueType(adaptor.getLhs(), rewriter, arithmeticType);
+ Value rhs = adaptValueType(adaptor.getRhs(), rewriter, arithmeticType);
+
rewriter.replaceOpWithNewOp<emitc::CmpOp>(op, op.getType(), pred, lhs, rhs);
return success();
}
};
-template <typename ArithOp, bool needsUnsigned>
+template <typename ArithOp, bool castToUnsigned>
class CastConversion : public OpConversionPattern<ArithOp> {
public:
using OpConversionPattern<ArithOp>::OpConversionPattern;
@@ -284,9 +311,10 @@ class CastConversion : public OpConversionPattern<ArithOp> {
ConversionPatternRewriter &rewriter) const override {
Type opReturnType = this->getTypeConverter()->convertType(op.getType());
- if (!isa_and_nonnull<IntegerType>(opReturnType)) {
- return rewriter.notifyMatchFailure(op, "expected integer result type");
- }
+ if (!isa_and_nonnull<IntegerType, emitc::SignedSizeTType, emitc::SizeTType>(
+ opReturnType))
+ return rewriter.notifyMatchFailure(
+ op, "expected integer or size_t/ssize_t result type");
if (adaptor.getOperands().size() != 1) {
return rewriter.notifyMatchFailure(
@@ -294,42 +322,47 @@ class CastConversion : public OpConversionPattern<ArithOp> {
}
Type operandType = adaptor.getIn().getType();
- if (!isa_and_nonnull<IntegerType>(operandType)) {
- return rewriter.notifyMatchFailure(op, "expected integer operand type");
+ if (!isa_and_nonnull<IntegerType, emitc::SignedSizeTType, emitc::SizeTType>(
+ operandType))
+ return rewriter.notifyMatchFailure(
+ op, "expected integer or size_t/ssize_t operand type");
+
+ // to-i1 conversions: arith semantics want truncation, whereas (bool)(v) is
+ // equivalent to (v != 0). Implementing as (bool)(v & 0x01) gives
+ // truncation.
+ if (opReturnType.isInteger(1)) {
+ Type attrType = (emitc::isAnySizeTType(operandType))
+ ? rewriter.getIndexType()
+ : operandType;
+ auto constOne = rewriter.create<emitc::ConstantOp>(
+ op.getLoc(), operandType, rewriter.getIntegerAttr(attrType, 1));
+ auto oneAndOperand = rewriter.create<emitc::BitwiseAndOp>(
+ op.getLoc(), operandType, adaptor.getIn(), constOne);
+ rewriter.replaceOpWithNewOp<emitc::CastOp>(op, opReturnType,
+ oneAndOperand);
+ return success();
}
- bool isTruncation = operandType.getIntOrFloatBitWidth() >
- opReturnType.getIntOrFloatBitWidth();
- bool doUnsigned = needsUnsigned || isTruncation;
-
- Type castType = opReturnType;
- // For int conversions: if the op is a ui variant and the type wanted as
- // return type isn't unsigned, we need to issue an unsigned type to do
- // the conversion.
- if (castType.isUnsignedInteger() != doUnsigned) {
- castType = rewriter.getIntegerType(opReturnType.getIntOrFloatBitWidth(),
- /*isSigned=*/!doUnsigned);
- }
+ bool isTruncation =
+ (isa<IntegerType>(operandType) && isa<IntegerType>(opReturnType) &&
+ operandType.getIntOrFloatBitWidth() >
+ opReturnType.getIntOrFloatBitWidth());
+ bool doUnsigned = castToUnsigned || isTruncation;
- Value actualOp = adaptor.getIn();
- // Fix the signedness of the operand if necessary
- if (operandType.isUnsignedInteger() != doUnsigned) {
- Type correctSignednessType =
- rewriter.getIntegerType(operandType.getIntOrFloatBitWidth(),
- /*isSigned=*/!doUnsigned);
- actualOp = rewriter.template create<emitc::CastOp>(
- op.getLoc(), correctSignednessType, actualOp);
- }
+ // Adapt the signedness of the result (bitwidth-preserving cast)
+ // This is needed e.g., if the return type is signless.
+ Type castDestType = adaptIntegralTypeSignedness(opReturnType, doUnsigned);
- auto result = rewriter.template create<emitc::CastOp>(op.getLoc(), castType,
- actualOp);
+ // Adapt the signedness of the operand (bitwidth-preserving cast)
+ Type castSrcType = adaptIntegralTypeSignedness(operandType, doUnsigned);
+ Value actualOp = adaptValueType(adaptor.getIn(), rewriter, castSrcType);
- // Fix the signedness of what this operation returns (for integers,
- // the arith ops want signless results)
- if (castType != opReturnType) {
- result = rewriter.template create<emitc::CastOp>(op.getLoc(),
- opReturnType, result);
- }
+ // Actual cast (may change bitwidth)
+ auto cast = rewriter.template create<emitc::CastOp>(op.getLoc(),
+ castDestType, actualOp);
+
+ // Cast to the expected output type
+ auto result = adaptValueType(cast, rewriter, opReturnType);
rewriter.replaceOp(op, result);
return success();
@@ -355,7 +388,11 @@ class ArithOpConversion final : public OpConversionPattern<ArithOp> {
matchAndRewrite(ArithOp arithOp, typename ArithOp::Adaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
- rewriter.template replaceOpWithNewOp<EmitCOp>(arithOp, arithOp.getType(),
+ Type newTy = this->getTypeConverter()->convertType(arithOp.getType());
+ if (!newTy)
+ return rewriter.notifyMatchFailure(arithOp,
+ "converting result type failed");
+ rewriter.template replaceOpWithNewOp<EmitCOp>(arithOp, newTy,
adaptor.getOperands());
return success();
@@ -372,8 +409,10 @@ class IntegerOpConversion final : public OpConversionPattern<ArithOp> {
ConversionPatternRewriter &rewriter) const override {
Type type = this->getTypeConverter()->convertType(op.getType());
- if (!isa_and_nonnull<IntegerType, IndexType>(type)) {
- return rewriter.notifyMatchFailure(op, "expected integer type");
+ if (!isa_and_nonnull<IntegerType, emitc::SignedSizeTType, emitc::SizeTType>(
+ type)) {
+ return rewriter.notifyMatchFailure(
+ op, "expected integer or size_t/ssize_t type");
}
if (type.isInteger(1)) {
@@ -381,8 +420,6 @@ class IntegerOpConversion final : public OpConversionPattern<ArithOp> {
return rewriter.notifyMatchFailure(op, "i1 type is not implemented");
}
- Value lhs = adaptor.getLhs();
- Value rhs = adaptor.getRhs();
Type arithmeticType = type;
if ((type.isSignlessInteger() || type.isSignedInteger()) &&
!bitEnumContainsAll(op.getOverflowFlags(),
@@ -392,20 +429,15 @@ class IntegerOpConversion final : public OpConversionPattern<ArithOp> {
arithmeticType = rewriter.getIntegerType(type.getIntOrFloatBitWidth(),
/*isSigned=*/false);
}
- if (arithmeticType != type) {
- lhs = rewriter.template create<emitc::CastOp>(op.getLoc(), arithmeticType,
- lhs);
- rhs = rewriter.template create<emitc::CastOp>(op.getLoc(), arithmeticType,
- rhs);
- }
- Value result = rewriter.template create<EmitCOp>(op.getLoc(),
- arithmeticType, lhs, rhs);
+ Value lhs = adaptValueType(adaptor.getLhs(), rewriter, arithmeticType);
+ Value rhs = adaptValueType(adaptor.getRhs(), rewriter, arithmeticType);
+
+ Value arithmeticResult = rewriter.template create<EmitCOp>(
+ op.getLoc(), arithmeticType, lhs, rhs);
+
+ Value result = adaptValueType(arithmeticResult, rewriter, type);
- if (arithmeticType != type) {
- result =
- rewriter.template create<emitc::CastOp>(op.getLoc(), type, result);
- }
rewriter.replaceOp(op, result);
return success();
}
@@ -535,6 +567,8 @@ void mlir::populateArithToEmitCPatterns(TypeConverter &typeConverter,
RewritePatternSet &patterns) {
MLIRContext *ctx = patterns.getContext();
+ mlir::populateEmitCSizeTypeConversionPatterns(typeConverter);
+
// clang-format off
patterns.add<
ArithConstantOpConversionPattern,
@@ -554,6 +588,8 @@ void mlir::populateArithToEmitCPatterns(TypeConverter &typeConverter,
UnsignedCastConversion<arith::TruncIOp>,
SignedCastConversion<arith::ExtSIOp>,
UnsignedCastConversion<arith::ExtUIOp>,
+ SignedCastConversion<arith::IndexCastOp>,
+ UnsignedCastConversion<arith::IndexCastUIOp>,
ItoFCastOpConversion<arith::SIToFPOp>,
ItoFCastOpConversion<arith::UIToFPOp>,
FtoICastOpConversion<arith::FPToSIOp>,
diff --git a/mlir/lib/Conversion/ArithToEmitC/CMakeLists.txt b/mlir/lib/Conversion/ArithToEmitC/CMakeLists.txt
index a3784f47c3bc2..730a4b341673d 100644
--- a/mlir/lib/Conversion/ArithToEmitC/CMakeLists.txt
+++ b/mlir/lib/Conversion/ArithToEmitC/CMakeLists.txt
@@ -11,6 +11,7 @@ add_mlir_conversion_library(MLIRArithToEmitC
LINK_LIBS PUBLIC
MLIRArithDialect
MLIREmitCDialect
+ MLIREmitCTransforms
MLIRPass
MLIRTransformUtils
)
diff --git a/mlir/lib/Dialect/EmitC/IR/EmitC.cpp b/mlir/lib/Dialect/EmitC/IR/EmitC.cpp
index ef7b7a19489d4..71d354885a900 100644
--- a/mlir/lib/Dialect/EmitC/IR/EmitC.cpp
+++ b/mlir/lib/Dialect/EmitC/IR/EmitC.cpp
@@ -68,7 +68,8 @@ bool mlir::emitc::isSupportedEmitCType(Type type) {
return !llvm::isa<emitc::ArrayType>(elemType) &&
isSupportedEmitCType(elemType);
}
- if (type.isIndex())
+ if (type.isIndex() ||
+ llvm::isa<emitc::SignedSizeTType, emitc::SizeTType>(type))
return true;
if (llvm::isa<IntegerType>(type))
return isSupportedIntegerType(type);
@@ -109,7 +110,8 @@ bool mlir::emitc::isSupportedIntegerType(Type type) {
}
bool mlir::emitc::isIntegerIndexOrOpaqueType(Type type) {
- return llvm::isa<IndexType, emitc::OpaqueType>(type) ||
+ return llvm::isa<IndexType, emitc::SignedSizeTType, emitc::SizeTType,
+ emitc::OpaqueType>(type) ||
isSupportedIntegerType(type);
}
@@ -126,6 +128,10 @@ bool mlir::emitc::isSupportedFloatType(Type type) {
return false;
}
+bool mlir::emitc::isAnySizeTType(Type type) {
+ return isa<emitc::SignedSizeTType, emitc::SizeTType>(type);
+}
+
/// Check that the type of the initial value is compatible with the operations
/// result type.
static LogicalResult verifyInitializationAttribute(Operation *op,
@@ -142,6 +148,10 @@ static LogicalResult verifyInitializationAttribute(Operation *op,
Type resultType = op->getResult(0).getType();
Type attrType = cast<TypedAttr>(value).getType();
+ if (isa<emitc::SignedSizeTType, emitc::SizeTType>(resultType) &&
+ attrType.isIndex())
+ return success();
+
if (resultType != attrType)
return op->emitOpError()
<< "requires attribute to either be an #emitc.opaque attribute or "
@@ -226,10 +236,19 @@ LogicalResult emitc::AssignOp::verify() {
bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
Type input = inputs.front(), output = outputs.front();
- return ((llvm::isa<IntegerType, FloatType, IndexType, emitc::OpaqueType,
- emitc::PointerType>(input)) &&
- (llvm::isa<IntegerType, FloatType, IndexType, emitc::OpaqueType,
- emitc::PointerType>(output)));
+ return (
+ (llvm::isa<IntegerType, FloatType, IndexType, emitc::OpaqueType,
+ emitc::PointerType, emitc::SignedSizeTType, emitc::SizeTType>(
+ input)) &&
+ (llvm::isa<IntegerType, FloatType, IndexType, emitc::OpaqueType,
+ emitc::PointerType, emitc::SignedSizeTType, emitc::SizeTType>(
+ output)));
+}
+
+OpFoldResult emitc::CastOp::fold(FoldAdaptor adaptor) {
+ if (getOperand().getType() == getResult().getType())
+ return getOperand();
+ return nullptr;
}
//===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Dialect/EmitC/Transforms/CMakeLists.txt b/mlir/lib/Dialect/EmitC/Transforms/CMakeLists.txt
index 97f616f2ee31a..69e6ae1095e6e 100644
--- a/mlir/lib/Dialect/EmitC/Transforms/CMakeLists.txt
+++ b/mlir/lib/Dialect/EmitC/Transforms/CMakeLists.txt
@@ -2,6 +2,7 @@ add_mlir_dialect_library(MLIREmitCTransforms
Transforms.cpp
FormExpressions.cpp
EliminateLibm.cpp
+ TypeConversions.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/EmitC/Transforms
diff --git a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp
new file mode 100644
index 0000000000000..d896f95b0ab8f
--- /dev/null
+++ b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp
@@ -0,0 +1,18 @@
+//===- TypeConversions.cpp - Convert signless types into C/C++ 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/EmitC/Transforms/TypeConversions.h"
+#include "mlir/Dialect/EmitC/IR/EmitC.h"
+#include "mlir/IR/BuiltinTypes.h"
+
+using namespace mlir;
+
+void mlir::populateEmitCSizeTypeConversionPatterns(TypeConverter &converter) {
+ converter.addConversion(
+ [](IndexType type) { return emitc::SizeTType::get(type.getContext()); });
+}
diff --git a/mlir/lib/Target/Cpp/TranslateToCpp.cpp b/mlir/lib/Target/Cpp/TranslateToCpp.cpp
index 1bdb74cd8bf2e..39eb28300c0ca 100644
--- a/mlir/lib/Target/Cpp/TranslateToCpp.cpp
+++ b/mlir/lib/Target/Cpp/TranslateToCpp.cpp
@@ -1563,6 +1563,10 @@ LogicalResult CppEmitter::emitType(Location loc, Type type) {
}
if (auto iType = dyn_cast<IndexType>(type))
return (os << "size_t"), success();
+ if (auto iType = dyn_cast<emitc::SizeTType>(type))
+ return (os << "size_t"), success();
+ if (auto iType = dyn_cast<emitc::SignedSizeTType>(type))
+ return (os << "ssize_t"), success();
if (auto tType = dyn_cast<TensorType>(type)) {
if (!tType.hasRank())
return emitError(loc, "cannot emit unranked tensor type");
diff --git a/mlir/test/Conversion/ArithToEmitC/arith-to-emitc-unsupported.mlir b/mlir/test/Conversion/ArithToEmitC/arith-to-emitc-unsupported.mlir
index 5fcb2b3a553e5..6d52c73af37e4 100644
--- a/mlir/test/Conversion/ArithToEmitC/arith-to-emitc-unsupported.mlir
+++ b/mlir/test/Conversion/ArithToEmitC/arith-to-emitc-unsupported.mlir
@@ -78,23 +78,3 @@ func.func @arith_cast_fptoui_i1(%arg0: f32) -> i1 {
%t = arith.fptoui %arg0 : f32 to i1
return %t: i1
}
-
-// -----
-
-func.func @index_cast(%arg0: i32) -> i32 {
- // expected-error @+1 {{failed to legalize operation 'arith.index_cast'}}
- %idx = arith.index_cast %arg0 : i32 to index
- %int = arith.index_cast %idx : index to i32
-
- return %int : i32
-}
-
-// -----
-
-func.func @index_castui(%arg0: i32) -> i32 {
- // expected-error @+1 {{failed to legalize operation 'arith.index_castui'}}
- %idx = arith.index_castui %arg0 : i32 to index
- %int = arith.index_castui %idx : index to i32
-
- return %int : i32
-}
diff --git a/mlir/test/Conversion/ArithToEmitC/arith-to-emitc.mlir b/mlir/test/Conversion/ArithToEmitC/arith-to-emitc.mlir
index bda1180282142..d3f2dcafd180a 100644
--- a/mlir/test/Conversion/ArithToEmitC/arith-to-emitc.mlir
+++ b/mlir/test/Conversion/ArithToEmitC/arith-to-emitc.mlir
@@ -3,7 +3,8 @@
// CHECK-LABEL: arith_constants
func.func @arith_constants() {
// CHECK: emitc.constant
- // CHECK-SAME: value = 0 : index
+ // CHECK-SAME: value = 0
+ // CHECK-SAME: () -> !emitc.size_t
%c_index = arith.constant 0 : index
// CHECK: emitc.constant
// CHECK-SAME: value = 0 : i32
@@ -75,13 +76,18 @@ func.func @arith_integer_ops_signed_nsw(%arg0: i32, %arg1: i32) {
// -----
// CHECK-LABEL: arith_index
-func.func @arith_index(%arg0: index, %arg1: index) {
- // CHECK: emitc.add %arg0, %arg1 : (index, index) -> index
- %0 = arith.addi %arg0, %arg1 : index
- // CHECK: emitc.sub %arg0, %arg1 : (index, index) -> index
- %1 = arith.subi %arg0, %arg1 : index
- // CHECK: emitc.mul %arg0, %arg1 : (index, index) -> index
- %2 = arith.muli %arg0, %arg1 : index
+func.func @arith_index(%arg0: i32, %arg1: i32) {
+ // CHECK: %[[CST0:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t
+ %cst0 = arith.index_cast %arg0 : i32 to index
+ // CHECK: %[[CST1:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t
+ %cst1 = arith.index_cast %arg1 : i32 to index
+
+ // CHECK: emitc.add %[[CST0]], %[[CST1]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
+ %0 = arith.addi %cst0, %cst1 : index
+ // CHECK: emitc.sub %[[CST0]], %[[CST1]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
+ %1 = arith.subi %cst0, %cst1 : index
+ // CHECK: emitc.mul %[[CST0]], %[[CST1]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
+ %2 = arith.muli %cst0, %cst1 : index
return
}
@@ -355,6 +361,27 @@ func.func @arith_cmpi_predicates(%arg0: i32, %arg1: i32) {
return
}
+func.func @arith_cmpi_index(%arg0: i32, %arg1: i32) -> i1 {
+ // CHECK-LABEL: arith_cmpi_index
+
+ // CHECK: %[[Cst0:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t
+ %idx0 = arith.index_cast %arg0 : i32 to index
+ // CHECK: %[[Cst1:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t
+ %idx1 = arith.index_cast %arg0 : i32 to index
+
+ // CHECK-DAG: [[ULT:[^ ]*]] = emitc.cmp lt, %[[Cst0]], %[[Cst1]] : (!emitc.size_t, !emitc.size_t) -> i1
+ %ult = arith.cmpi ult, %idx0, %idx1 : index
+
+ // CHECK-DAG: %[[CastArg0:[^ ]*]] = emitc.cast %[[Cst0]] : !emitc.size_t to !emitc.ssize_t
+ // CHECK-DAG: %[[CastArg1:[^ ]*]] = emitc.cast %[[Cst1]] : !emitc.size_t to !emitc.ssize_t
+ // CHECK-DAG: %[[SLT:[^ ]*]] = emitc.cmp lt, %[[CastArg0]], %[[CastArg1]] : (!emitc.ssize_t, !emitc.ssize_t) -> i1
+ %slt = arith.cmpi slt, %idx0, %idx1 : index
+
+ // CHECK: return %[[SLT]]
+ return %slt: i1
+}
+
+
// -----
func.func @arith_float_to_int_cast_ops(%arg0: f32, %arg1: f64) {
@@ -393,24 +420,30 @@ func.func @arith_int_to_float_cast_ops(%arg0: i8, %arg1: i64) {
// -----
-func.func @trunci(%arg0: i32) -> i8 {
- // CHECK-LABEL: trunci
+func.func @arith_trunci(%arg0: i32) -> i8 {
+ // CHECK-LABEL: arith_trunci
// CHECK-SAME: (%[[Arg0:[^ ]*]]: i32)
// CHECK: %[[CastUI:.*]] = emitc.cast %[[Arg0]] : i32 to ui32
// CHECK: %[[Trunc:.*]] = emitc.cast %[[CastUI]] : ui32 to ui8
// CHECK: emitc.cast %[[Trunc]] : ui8 to i8
%truncd = arith.trunci %arg0 : i32 to i8
+ // CHECK: %[[Const:.*]] = "emitc.constant"
+ // CHECK-SAME: value = 1
+ // CHECK-SAME: () -> i32
+ // CHECK: %[[AndOne:.*]] = emitc.bitwise_and %[[Arg0]], %[[Const]] : (i32, i32) -> i32
+ // CHECK: %[[Conv:.*]] = emitc.cast %[[AndOne]] : i32 to i1
+ %bool = arith.trunci %arg0 : i32 to i1
+
return %truncd : i8
}
// -----
-func.func @extsi(%arg0: i32) {
- // CHECK-LABEL: extsi
+func.func @arith_extsi(%arg0: i32) {
+ // CHECK-LABEL: arith_extsi
// CHECK-SAME: ([[Arg0:[^ ]*]]: i32)
// CHECK: emitc.cast [[Arg0]] : i32 to i64
-
%extd = arith.extsi %arg0 : i32 to i64
return
@@ -418,14 +451,57 @@ func.func @extsi(%arg0: i32) {
// -----
-func.func @extui(%arg0: i32) {
- // CHECK-LABEL: extui
+func.func @arith_extui(%arg0: i32) {
+ // CHECK-LABEL: arith_extui
// CHECK-SAME: (%[[Arg0:[^ ]*]]: i32)
// CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to ui32
// CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : ui32 to ui64
// CHECK: emitc.cast %[[Conv1]] : ui64 to i64
-
%extd = arith.extui %arg0 : i32 to i64
return
}
+
+// -----
+
+func.func @arith_index_cast(%arg0: i32) -> i32 {
+ // CHECK-LABEL: arith_index_cast
+ // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32)
+ // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to !emitc.ssize_t
+ // CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : !emitc.ssize_t to !emitc.size_t
+ %idx = arith.index_cast %arg0 : i32 to index
+ // CHECK: %[[Conv2:.*]] = emitc.cast %[[Conv1]] : !emitc.size_t to !emitc.ssize_t
+ // CHECK: %[[Conv3:.*]] = emitc.cast %[[Conv2]] : !emitc.ssize_t to i32
+ %int = arith.index_cast %idx : index to i32
+
+ // CHECK: %[[Const:.*]] = "emitc.constant"
+ // CHECK-SAME: value = 1
+ // CHECK-SAME: () -> !emitc.size_t
+ // CHECK: %[[AndOne:.*]] = emitc.bitwise_and %[[Conv1]], %[[Const]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
+ // CHECK: %[[Conv4:.*]] = emitc.cast %[[AndOne]] : !emitc.size_t to i1
+ %bool = arith.index_cast %idx : index to i1
+
+ return %int : i32
+}
+
+// -----
+
+func.func @arith_index_castui(%arg0: i32) -> i32 {
+ // CHECK-LABEL: arith_index_castui
+ // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32)
+ // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to ui32
+ // CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : ui32 to !emitc.size_t
+ %idx = arith.index_castui %arg0 : i32 to index
+ // CHECK: %[[Conv2:.*]] = emitc.cast %[[Conv1]] : !emitc.size_t to ui32
+ // CHECK: %[[Conv3:.*]] = emitc.cast %[[Conv2]] : ui32 to i32
+ %int = arith.index_castui %idx : index to i32
+
+ // CHECK: %[[Const:.*]] = "emitc.constant"
+ // CHECK-SAME: value = 1
+ // CHECK-SAME: () -> !emitc.size_t
+ // CHECK: %[[AndOne:.*]] = emitc.bitwise_and %[[Conv1]], %[[Const]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
+ // CHECK: %[[Conv4:.*]] = emitc.cast %[[AndOne]] : !emitc.size_t to i1
+ %bool = arith.index_castui %idx : index to i1
+
+ return %int : i32
+}
diff --git a/mlir/test/Dialect/EmitC/invalid_ops.mlir b/mlir/test/Dialect/EmitC/invalid_ops.mlir
index 21ea6a5df91b9..3eede2c72dca4 100644
--- a/mlir/test/Dialect/EmitC/invalid_ops.mlir
+++ b/mlir/test/Dialect/EmitC/invalid_ops.mlir
@@ -170,7 +170,7 @@ func.func @add_float_pointer(%arg0: f32, %arg1: !emitc.ptr<f32>) {
// -----
func.func @div_tensor(%arg0: tensor<i32>, %arg1: tensor<i32>) {
- // expected-error @+1 {{'emitc.div' op operand #0 must be floating-point type supported by EmitC or integer type supported by EmitC or index or EmitC opaque type, but got 'tensor<i32>'}}
+ // expected-error @+1 {{'emitc.div' op operand #0 must be floating-point type supported by EmitC or integer type supported by EmitC or index or EmitC signed size type or EmitC unsigned size type or EmitC opaque type, but got 'tensor<i32>'}}
%1 = "emitc.div" (%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
return
}
@@ -178,7 +178,7 @@ func.func @div_tensor(%arg0: tensor<i32>, %arg1: tensor<i32>) {
// -----
func.func @mul_tensor(%arg0: tensor<i32>, %arg1: tensor<i32>) {
- // expected-error @+1 {{'emitc.mul' op operand #0 must be floating-point type supported by EmitC or integer type supported by EmitC or index or EmitC opaque type, but got 'tensor<i32>'}}
+ // expected-error @+1 {{'emitc.mul' op operand #0 must be floating-point type supported by EmitC or integer type supported by EmitC or index or EmitC signed size type or EmitC unsigned size type or EmitC opaque type, but got 'tensor<i32>'}}
%1 = "emitc.mul" (%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
return
}
@@ -186,7 +186,7 @@ func.func @mul_tensor(%arg0: tensor<i32>, %arg1: tensor<i32>) {
// -----
func.func @rem_tensor(%arg0: tensor<i32>, %arg1: tensor<i32>) {
- // expected-error @+1 {{'emitc.rem' op operand #0 must be integer type supported by EmitC or index or EmitC opaque type, but got 'tensor<i32>'}}
+ // expected-error @+1 {{'emitc.rem' op operand #0 must be integer type supported by EmitC or index or EmitC signed size type or EmitC unsigned size type or EmitC opaque type, but got 'tensor<i32>'}}
%1 = "emitc.rem" (%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
return
}
@@ -194,7 +194,7 @@ func.func @rem_tensor(%arg0: tensor<i32>, %arg1: tensor<i32>) {
// -----
func.func @rem_float(%arg0: f32, %arg1: f32) {
- // expected-error @+1 {{'emitc.rem' op operand #0 must be integer type supported by EmitC or index or EmitC opaque type, but got 'f32'}}
+ // expected-error @+1 {{'emitc.rem' op operand #0 must be integer type supported by EmitC or index or EmitC signed size type or EmitC unsigned size type or EmitC opaque type, but got 'f32'}}
%1 = "emitc.rem" (%arg0, %arg1) : (f32, f32) -> f32
return
}
diff --git a/mlir/test/Dialect/EmitC/invalid_types.mlir b/mlir/test/Dialect/EmitC/invalid_types.mlir
index 0ad8d4eabe6b8..111fbc7de640b 100644
--- a/mlir/test/Dialect/EmitC/invalid_types.mlir
+++ b/mlir/test/Dialect/EmitC/invalid_types.mlir
@@ -85,7 +85,7 @@ func.func @illegal_array_with_tensor_element_type(
// -----
func.func @illegal_integer_type(%arg0: i11, %arg1: i11) -> i11 {
- // expected-error @+1 {{'emitc.mul' op operand #0 must be floating-point type supported by EmitC or integer type supported by EmitC or index or EmitC opaque type, but got 'i11'}}
+ // expected-error @+1 {{'emitc.mul' op operand #0 must be floating-point type supported by EmitC or integer type supported by EmitC or index or EmitC signed size type or EmitC unsigned size type or EmitC opaque type, but got 'i11'}}
%mul = "emitc.mul" (%arg0, %arg1) : (i11, i11) -> i11
return
}
@@ -93,7 +93,7 @@ func.func @illegal_integer_type(%arg0: i11, %arg1: i11) -> i11 {
// -----
func.func @illegal_float_type(%arg0: f80, %arg1: f80) {
- // expected-error @+1 {{'emitc.mul' op operand #0 must be floating-point type supported by EmitC or integer type supported by EmitC or index or EmitC opaque type, but got 'f80'}}
+ // expected-error @+1 {{'emitc.mul' op operand #0 must be floating-point type supported by EmitC or integer type supported by EmitC or index or EmitC signed size type or EmitC unsigned size type or EmitC opaque type, but got 'f80'}}
%mul = "emitc.mul" (%arg0, %arg1) : (f80, f80) -> f80
return
}
diff --git a/mlir/test/Dialect/EmitC/types.mlir b/mlir/test/Dialect/EmitC/types.mlir
index 752f2c10c17be..8b630d5a320f4 100644
--- a/mlir/test/Dialect/EmitC/types.mlir
+++ b/mlir/test/Dialect/EmitC/types.mlir
@@ -53,3 +53,13 @@ func.func @pointer_types() {
return
}
+
+// CHECK-LABEL: func @index_types()
+func.func @index_types() {
+ // CHECK-NEXT: !emitc.ssize_t
+ emitc.call_opaque "f"() {template_args = [!emitc.ssize_t]} : () -> ()
+ // CHECK-NEXT: !emitc.size_t
+ emitc.call_opaque "f"() {template_args = [!emitc.size_t]} : () -> ()
+
+ return
+}
diff --git a/mlir/test/Target/Cpp/types.mlir b/mlir/test/Target/Cpp/types.mlir
index 0585b27eb6c22..647777c8ac718 100644
--- a/mlir/test/Target/Cpp/types.mlir
+++ b/mlir/test/Target/Cpp/types.mlir
@@ -35,3 +35,13 @@ func.func @ptr_types() {
return
}
+
+// CHECK-LABEL: void size_types() {
+func.func @size_types() {
+ // CHECK-NEXT: f<ssize_t>();
+ emitc.call_opaque "f"() {template_args = [!emitc.ssize_t]} : () -> ()
+ // CHECK-NEXT: f<size_t>();
+ emitc.call_opaque "f"() {template_args = [!emitc.size_t]} : () -> ()
+
+ return
+}