[FXML-4614] Add EmitC index types, lower arith.index_cast, arith.index_castui

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_SignedSizeType, EmitC_UnsignedSizeType, EmitC_OpaqueType]>;
 def FloatIntegerIndexOrOpaqueType : AnyTypeOf<[EmitCFloatType, IntegerIndexOrOpaqueType]>;
 
 def EmitC_AddOp : EmitC_BinaryOp<"add", [CExpression]> {
@@ -470,7 +471,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
@@ -1242,7 +1243,7 @@ def EmitC_SubscriptOp : EmitC_Op<"subscript", []> {
       EmitC_OpaqueType,
       EmitC_PointerType]>,
     "the value to subscript">:$value,
-    Variadic<EmitCType>:$indices);
+    Variadic<AnyTypeOf<[EmitCType, EmitC_SignedSizeType, EmitC_UnsignedSizeType]>>:$indices);
   let results = (outs EmitCType:$result);
 
   let builders = [

mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td

@@ -130,4 +130,16 @@ def EmitC_PointerType : EmitC_Type<"Pointer", "ptr"> {
   let assemblyFormat = "`<` qualified($pointee) `>`";
 }
 
+class EmitC_SizeType<string name, string typeMnemonic, list<Trait> traits = []> 
+  : EmitC_Type<name, typeMnemonic, traits> {
+}
+
+def EmitC_SignedSizeType : EmitC_SizeType<"SignedSize", "ssize_t"> {
+  let summary = "EmitC signed size type";
+}
+
+def EmitC_UnsignedSizeType : EmitC_SizeType<"UnsignedSize", "usize_t"> {
+  let summary = "EmitC unsigned size type";
+}
+
 #endif // MLIR_DIALECT_EMITC_IR_EMITCTYPES

mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h

@@ -0,0 +1,11 @@
+//===- 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"
+
+void populateEmitCSizeTypeConversionPatterns(mlir::TypeConverter &converter);

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"
@@ -284,7 +285,8 @@ class CastConversion : public OpConversionPattern<ArithOp> {
                   ConversionPatternRewriter &rewriter) const override {
 
     Type opReturnType = this->getTypeConverter()->convertType(op.getType());
-    if (!isa_and_nonnull<IntegerType>(opReturnType)) {
+    if (!isa_and_nonnull<IntegerType, emitc::SignedSizeType,
+                         emitc::UnsignedSizeType>(opReturnType)) {
       return rewriter.notifyMatchFailure(op, "expected integer result type");
     }
 
@@ -294,7 +296,8 @@ class CastConversion : public OpConversionPattern<ArithOp> {
     }
 
     Type operandType = adaptor.getIn().getType();
-    if (!isa_and_nonnull<IntegerType>(operandType)) {
+    if (!isa_and_nonnull<IntegerType, emitc::SignedSizeType,
+                         emitc::UnsignedSizeType>(operandType)) {
       return rewriter.notifyMatchFailure(op, "expected integer operand type");
     }
 
@@ -306,7 +309,8 @@ class CastConversion : public OpConversionPattern<ArithOp> {
     // 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) {
+    if ((isa<emitc::UnsignedSizeType>(castType) ||
+         castType.isUnsignedInteger()) != doUnsigned) {
       castType = rewriter.getIntegerType(opReturnType.getIntOrFloatBitWidth(),
                                          /*isSigned=*/!doUnsigned);
     }
@@ -535,6 +539,8 @@ void mlir::populateArithToEmitCPatterns(TypeConverter &typeConverter,
                                         RewritePatternSet &patterns) {
   MLIRContext *ctx = patterns.getContext();
 
+  // populateEmitCSizeTypeConversionPatterns(typeConverter);
+
   // clang-format off
   patterns.add<
     ArithConstantOpConversionPattern,

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

@@ -109,7 +109,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::SignedSizeType, emitc::UnsignedSizeType,
+                   emitc::OpaqueType>(type) ||
          isSupportedIntegerType(type);
 }
 

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

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 populateEmitCSizeTypeConversionPatterns(TypeConverter &converter) {
+  converter.addConversion(
+      [](IndexType type) { return emitc::UnsignedSizeType(); });
+}

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::UnsignedSizeType>(type))
+    return (os << "size_t"), success();
+  if (auto iType = dyn_cast<emitc::SignedSizeType>(type))
+    return (os << "ssize_t"), success();
   if (auto tType = dyn_cast<TensorType>(type)) {
     if (!tType.hasRank())
       return emitError(loc, "cannot emit unranked tensor type");

mlir/test/Dialect/EmitC/invalid_ops.mlir

@@ -170,31 +170,31 @@ 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
 }
 
 // -----
 
 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
 }
 
 // -----
 
 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
 }
 
 // -----
 
 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
 }

mlir/test/Dialect/EmitC/invalid_types.mlir

@@ -85,15 +85,15 @@ 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
 }
 
 // -----
 
 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
 }

mlir/test/Dialect/EmitC/type-conversions.mlir

@@ -0,0 +1,7 @@
+// RUN: mlir-opt -debug -verify-diagnostics -test-emitc-type-conversions %s | FileCheck %s
+
+// CHECK-LABEL: ssize_t
+func.func @ssize_t() {
+    %0 = "emitc.constant"(){value = 42 : index} : () -> index
+    return
+}

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.usize_t
+  emitc.call_opaque "f"() {template_args = [!emitc.usize_t]} : () -> ()
+
+  return
+}

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.usize_t]} : () -> ()
+
+  return
+}

mlir/test/lib/Dialect/CMakeLists.txt

@@ -4,6 +4,7 @@ add_subdirectory(ArmSME)
 add_subdirectory(Bufferization)
 add_subdirectory(ControlFlow)
 add_subdirectory(DLTI)
+add_subdirectory(EmitC)
 add_subdirectory(Func)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)

mlir/test/lib/Dialect/EmitC/CMakeLists.txt

@@ -0,0 +1,9 @@
+# Exclude tests from libMLIR.so
+add_mlir_library(MLIREmitCTransformsTest
+  TestTypeConversions.cpp
+
+  EXCLUDE_FROM_LIBMLIR
+
+  LINK_LIBS PUBLIC
+  MLIRPass
+  )

mlir/test/lib/Dialect/EmitC/TestTypeConversions.cpp

@@ -0,0 +1,88 @@
+//===- TestTypeConversions.cpp - Test EmitC type conversions --------------===//
+//
+// 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 contains a test pass to check EmitC type conversions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/EmitC/IR/EmitC.h"
+#include "mlir/Dialect/EmitC/Transforms/TypeConversions.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/IR/Value.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/DialectConversion.h"
+
+using namespace mlir;
+
+namespace {
+struct TestEmitCTypeConversions
+    : public PassWrapper<TestEmitCTypeConversions, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestEmitCTypeConversions)
+
+  void runOnOperation() override;
+  StringRef getArgument() const final { return "test-emitc-type-conversions"; }
+  void getDependentDialects(DialectRegistry &registry) const override {
+    registry.insert<emitc::EmitCDialect>();
+  }
+  StringRef getDescription() const final {
+    return "Test EmitC type conversions";
+  }
+};
+
+struct ConstantConverter : public OpConversionPattern<emitc::ConstantOp> {
+public:
+  using OpConversionPattern<emitc::ConstantOp>::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(emitc::ConstantOp constantOp, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+
+    // Get value attribute
+    auto valueAttr = ::cast<TypedAttr>(constantOp.getValue());
+    valueAttr.dump();
+
+    Type dstType = getTypeConverter()->convertType(valueAttr.getType());
+
+    if (!dstType)
+      return rewriter.notifyMatchFailure(constantOp, "type conversion failed");
+
+    // Invalid op since value should be an attribute but we'll get here at least
+    rewriter.replaceOpWithNewOp<emitc::ConstantOp>(constantOp, dstType,
+                                                   adaptor.getOperands());
+
+    return success();
+  }
+};
+
+} // namespace
+
+void TestEmitCTypeConversions::runOnOperation() {
+  MLIRContext *context = &getContext();
+  RewritePatternSet patterns(context);
+  TypeConverter typeConverter;
+  populateEmitCSizeTypeConversionPatterns(typeConverter);
+  // Add a default converter
+  // typeConverter.addConversion([](Type t) { t.dump(); return t; });
+  ConversionTarget target(getContext());
+  target.addLegalDialect<emitc::EmitCDialect>();
+  target.addDynamicallyLegalOp<emitc::ConstantOp>([](emitc::ConstantOp op) {
+    return isa<emitc::SignedSizeType, emitc::UnsignedSizeType>(op.getType());
+  });
+  patterns.insert<ConstantConverter>(typeConverter, context);
+  (void)applyPartialConversion(getOperation(), target, std::move(patterns));
+}
+
+namespace mlir {
+namespace test {
+void registerTestEmitCTypeConversions() {
+  PassRegistration<TestEmitCTypeConversions>();
+}
+} // namespace test
+} // namespace mlir

mlir/tools/mlir-opt/CMakeLists.txt

@@ -46,6 +46,7 @@ if(MLIR_INCLUDE_TESTS)
     MLIRVectorTestPasses
     MLIRTestVectorToSPIRV
     MLIRLLVMTestPasses
+    MLIREmitCTransformsTest
     )
   set(test_libs ${test_libs}
     MLIRTestPDLL

mlir/tools/mlir-opt/mlir-opt.cpp

@@ -88,6 +88,7 @@ void registerTestDecomposeCallGraphTypes();
 void registerTestDiagnosticsPass();
 void registerTestDominancePass();
 void registerTestDynamicPipelinePass();
+void registerTestEmitCTypeConversions();
 void registerTestEmulateNarrowTypePass();
 void registerTestExpandMathPass();
 void registerTestFooAnalysisPass();
@@ -213,6 +214,7 @@ void registerTestPasses() {
   mlir::test::registerTestDeadCodeAnalysisPass();
   mlir::test::registerTestDominancePass();
   mlir::test::registerTestDynamicPipelinePass();
+  mlir::test::registerTestEmitCTypeConversions();
   mlir::test::registerTestEmulateNarrowTypePass();
   mlir::test::registerTestExpandMathPass();
   mlir::test::registerTestFooAnalysisPass();