[mlir][emitc] Add a cast op

[marbre]

Summary

This adds a cast operation that allows to perform an explicit type
conversion. The cast op is emitted as a C-style cast. It can be applied
to integer, float, index and EmitC types.

[jpienaar]

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

99

Why the restriction? E.g., it would seem that one can't know the safety or validity of conversions between EmitC types here, so this restriction doesn't seem to add anything additional here.

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

70

Is this possible with a valid op? Seems fr the op definition it can only have one operand and one result.

[marbre]

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

99

It depends. The restrictions actually forbids to cast from/to tensor types (which the emitter supports) and vector types (which the emitter doesn't supports at all). Since tensors can be only expressed as a more complex C++ datatype, allowing C-style casts seemed not useful to me. As additional types might be added in the future to MLIR, I explicitly listed the types that are supported instead of listing what isn't supported. However, it is correct that one can write unsafe/invalid conversions especially when using !emitc.opaque types. This would be up to the one implementing the conversions.

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

70

This is something done similar (ArithmeticOps.cpp#L824), or rather identical (MemRefOps.cpp#L566-L567 or Shape.cpp#L1688-L1689), through the code base, so I assume this should be fine.

[jpienaar]

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

70

The arith one makes sense to me as it is a standalone helper function, the other two are a bit weird. This is probably leftovers from when there wasn't a verification order enforced. With it enforced now these should never get triggered.

75

Just return book value directly.

Instead of "if (X) return true; return false;" just "return X;".

mlir/lib/Target/Cpp/TranslateToCpp.cpp

388

Why not just use castOp-> below where Operation is needed? (Not sure if it is actually needed looking at uses)

mlir/test/Target/Cpp/cast.mlir

8

Could you add an invalid test too?

[marbre]

Thanks for the review @jpienaar! I will address your comments before landing.

mlir/test/Target/Cpp/cast.mlir

8

There is

func @cast_tensor(%arg : tensor<f32>) {
    // expected-error @+1 {{'emitc.cast' op operand type 'tensor<f32>' and result type 'tensor<f32>' are cast incompatible}}
    %1 = emitc.cast %arg: tensor<f32> to tensor<f32>
    return
}

in invalid_ops.mlir which fails since tensors aren't supported. Or do you have something different in mind?

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

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_EMITC_IR_EMITC
 #define MLIR_DIALECT_EMITC_IR_EMITC
 
 include "mlir/Dialect/EmitC/IR/EmitCAttributes.td"
 include "mlir/Dialect/EmitC/IR/EmitCTypes.td"
 
+include "mlir/Interfaces/CastInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // EmitC op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for EmitC dialect ops.
 class EmitC_Op<string mnemonic, list<Trait> traits = []>
def EmitC_CallOp : EmitC_Op<"call", []> {
   );
   let results = (outs Variadic<AnyType>);
   let assemblyFormat = [{
     $callee `(` $operands `)` attr-dict `:` functional-type($operands, results)
   }];
   let hasVerifier = 1;
 }
 
+def EmitC_CastOp : EmitC_Op<"cast", [
+    DeclareOpInterfaceMethods<CastOpInterface>,
+    SameOperandsAndResultShape
+  ]> {
+  let summary = "Cast operation";
+  let description = [{
+    The `cast` operation performs an explicit type conversion and is emitted
+    as a C-style cast expression. It can be applied to integer, float, index
+    and EmitC types.
+
+    Example:
+
+    ```mlir
+    // Cast from `int32_t` to `float`
+    %0 = emitc.cast %arg0: i32 to f32
+
+    // Cast from `void` to `int32_t` pointer
+    %1 = emitc.cast %arg1 :
+        !emitc.ptr<!emitc.opaque<"void">> to !emitc.ptr<i32>
+    ```
+  }];
+
+  let arguments = (ins AnyType:$source);
+  let results = (outs AnyType:$dest);
+  let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
+}
+
 def EmitC_ConstantOp : EmitC_Op<"constant", [ConstantLike]> {
   let summary = "Constant operation";
   let description = [{
     The `constant` operation produces an SSA value equal to some constant
     specified by an attribute. This can be used to form simple integer and
     floating point constants, as well as more exotic things like tensor
     constants. The `constant` operation also supports the EmitC opaque
     attribute and the EmitC opaque type. Since folding is supported,

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

 add_mlir_dialect_library(MLIREmitC
   EmitC.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/EmitC
 
   DEPENDS
   MLIREmitCIncGen
   MLIREmitCAttributesIncGen
 
   LINK_LIBS PUBLIC
+  MLIRCastInterfaces
   MLIRIR
   MLIRSideEffectInterfaces
   )

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

LogicalResult ApplyOp::verify() {
   // Only `*` and `&` are supported.
   if (applicableOperatorStr != "&" && applicableOperatorStr != "*")
     return emitOpError("applicable operator is illegal");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// CastOp
+//===----------------------------------------------------------------------===//
+
+bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
+  Type input = inputs.front(), output = outputs.front();
+
+  return ((input.isa<IntegerType, FloatType, IndexType, emitc::OpaqueType,
+                     emitc::PointerType>()) &&
+          (output.isa<IntegerType, FloatType, IndexType, emitc::OpaqueType,
+                      emitc::PointerType>()));
+}
+
+//===----------------------------------------------------------------------===//
 // CallOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult emitc::CallOp::verify() {
   // Callee must not be empty.
   if (callee().empty())
     return emitOpError("callee must not be empty");
 

mlir/lib/Target/Cpp/TranslateToCpp.cpp

static LogicalResult printOperation(CppEmitter &emitter,
   if (failed(emitter.emitAssignPrefix(op)))
     return failure();
   os << applyOp.applicableOperator();
   os << emitter.getOrCreateName(applyOp.getOperand());
 
   return success();
 }
 
+static LogicalResult printOperation(CppEmitter &emitter, emitc::CastOp castOp) {
+  raw_ostream &os = emitter.ostream();
+  Operation &op = *castOp.getOperation();
+
+  if (failed(emitter.emitAssignPrefix(op)))
+    return failure();
+  os << "(";
+  if (failed(emitter.emitType(op.getLoc(), op.getResult(0).getType())))
+    return failure();
+  os << ") ";
+  os << emitter.getOrCreateName(castOp.getOperand());
+
+  return success();
+}
+
 static LogicalResult printOperation(CppEmitter &emitter,
                                     emitc::IncludeOp includeOp) {
   raw_ostream &os = emitter.ostream();
 
   os << "#include ";
   if (includeOp.is_standard_include())
     os << "<" << includeOp.include() << ">";
   else
LogicalResult CppEmitter::emitOperation(Operation &op, bool trailingSemicolon) {
   LogicalResult status =
       llvm::TypeSwitch<Operation *, LogicalResult>(&op)
           // Builtin ops.
           .Case<ModuleOp>([&](auto op) { return printOperation(*this, op); })
           // CF ops.
           .Case<cf::BranchOp, cf::CondBranchOp>(
               [&](auto op) { return printOperation(*this, op); })
           // EmitC ops.
-          .Case<emitc::ApplyOp, emitc::CallOp, emitc::ConstantOp,
+          .Case<emitc::ApplyOp, emitc::CallOp, emitc::CastOp, emitc::ConstantOp,
                 emitc::IncludeOp, emitc::VariableOp>(
               [&](auto op) { return printOperation(*this, op); })
           // Func ops.
           .Case<func::CallOp, func::ConstantOp, func::FuncOp, func::ReturnOp>(
               [&](auto op) { return printOperation(*this, op); })
           // SCF ops.
           .Case<scf::ForOp, scf::IfOp, scf::YieldOp>(
               [&](auto op) { return printOperation(*this, op); })

mlir/test/Dialect/EmitC/invalid_ops.mlir

 
 // -----
 
 func.func @var_attribute_return_type_2() {
     // expected-error @+1 {{'emitc.variable' op requires attribute's type ('!emitc.ptr<i64>') to match op's return type ('!emitc.ptr<i32>')}}
     %c0 = "emitc.variable"(){value = "nullptr" : !emitc.ptr<i64>} : () -> !emitc.ptr<i32>
     return
 }
+
+// -----
+
+func.func @cast_tensor(%arg : tensor<f32>) {
+    // expected-error @+1 {{'emitc.cast' op operand type 'tensor<f32>' and result type 'tensor<f32>' are cast incompatible}}
+    %1 = emitc.cast %arg: tensor<f32> to tensor<f32>
+    return
+}

mlir/test/Dialect/EmitC/ops.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
 emitc.include <"test.h">
 emitc.include "test.h"
 
 // CHECK-LABEL: func @f(%{{.*}}: i32, %{{.*}}: !emitc.opaque<"int32_t">) {
 func.func @f(%arg0: i32, %f: !emitc.opaque<"int32_t">) {
   %1 = "emitc.call"() {callee = "blah"} : () -> i64
   emitc.call "foo" (%1) {args = [
     0 : index, dense<[0, 1]> : tensor<2xi32>, 0 : index
   ]} : (i64) -> ()
   return
 }
 
+func.func @cast(%arg0: i32) {
+  %1 = emitc.cast %arg0: i32 to f32
+  return
+}
+
 func.func @c() {
   %1 = "emitc.constant"(){value = 42 : i32} : () -> i32
   return
 }
 
 func.func @a(%arg0: i32, %arg1: i32) {
   %1 = "emitc.apply"(%arg0) {applicableOperator = "&"} : (i32) -> !emitc.ptr<i32>
   %2 = emitc.apply "&"(%arg1) : (i32) -> !emitc.ptr<i32>
   return
 }

mlir/test/Target/Cpp/cast.mlir

+// RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s
+// CHECK-LABEL: void cast
+func.func @cast(%arg0 : i32) {
+  // CHECK-NEXT: uint32_t [[V1:[^ ]*]] = (uint32_t) [[V0:[^ ]*]]
+  %1 = emitc.cast %arg0: i32 to ui32
+
+  // CHECK-NEXT: int64_t [[V4:[^ ]*]] = (int64_t) [[V0:[^ ]*]]
+  %2 = emitc.cast %arg0: i32 to i64
+  // CHECK-NEXT: int64_t [[V5:[^ ]*]] = (uint64_t) [[V0:[^ ]*]]
+  %3 = emitc.cast %arg0: i32 to ui64
+
+  // CHECK-NEXT: float [[V4:[^ ]*]] = (float) [[V0:[^ ]*]]
+  %4 = emitc.cast %arg0: i32 to f32
+  // CHECK-NEXT: double [[V5:[^ ]*]] = (double) [[V0:[^ ]*]]
+  %5 = emitc.cast %arg0: i32 to f64
+
+  // CHECK-NEXT: bool [[V6:[^ ]*]] = (bool) [[V0:[^ ]*]]
+  %6 = emitc.cast %arg0: i32 to i1
+
+  // CHECK-NEXT: mytype [[V7:[^ ]*]] = (mytype) [[V0:[^ ]*]]
+  %7 = emitc.cast %arg0: i32 to !emitc.opaque<"mytype">
+  return
+}
+
+// CHECK-LABEL: void cast_ptr
+func.func @cast_ptr(%arg0 : !emitc.ptr<!emitc.opaque<"void">>) {
+  // CHECK-NEXT: int32_t* [[V1:[^ ]*]] = (int32_t*) [[V0:[^ ]*]]
+  %1 = emitc.cast %arg0 : !emitc.ptr<!emitc.opaque<"void">> to !emitc.ptr<i32>
+  return
+}