[mlir][emitc] Add div, mul and rem operators

[marbre]

Summary

This adds operations for binary multiplicative arithmetic operators to
EmitC. The input and output arguments for the remainder operator are
restricted to index (emitted as size_t), integers and the EmitC opaque
types (as the operator can be overloaded for a custom type). The
multiplication and division operator further support floating point
numbers.

[jpienaar]

Looks good, similar to add .

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

195

Nit: new line in between else I think markdown rendering won't work correctly.

[marbre]

Thanks for your review @jpienaar!

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

195

I just checked the already landed add op. There is no new line in between as well and markdown rendering works as expected.

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

class EmitC_Op<string mnemonic, list<Trait> traits = []>
     : Op<EmitC_Dialect, mnemonic, traits>;
 
 // Base class for binary arithmetic operations.
 class EmitC_BinaryArithOp<string mnemonic, list<Trait> traits = []> :
     EmitC_Op<mnemonic, traits> {
   let arguments = (ins AnyType:$lhs, AnyType:$rhs);
   let results = (outs AnyType);
   let assemblyFormat = "operands attr-dict `:` functional-type(operands, results)";
-
-  let hasVerifier = 1;
 }
 
+// Types only used in binary arithmetic operations.
+def IntegerIndexOrOpaqueType : AnyTypeOf<[AnyInteger, Index, EmitC_OpaqueType]>;
+def FloatIntegerIndexOrOpaqueType : AnyTypeOf<[AnyFloat, IntegerIndexOrOpaqueType]>;
+
 def EmitC_AddOp : EmitC_BinaryArithOp<"add", []> {
   let summary = "Addition operation";
   let description = [{
     With the `add` operation the arithmetic operator + (addition) can
     be applied.
 
     Example:
 
     ```mlir
     // Custom form of the addition operation.
     %0 = emitc.add %arg0, %arg1 : (i32, i32) -> i32
     %1 = emitc.add %arg2, %arg3 : (!emitc.ptr<f32>, i32) -> !emitc.ptr<f32>
     ```
     ```c++
     // Code emitted for the operations above.
     int32_t v5 = v1 + v2;
     float* v6 = v3 + v4;
     ```
   }];
+
+  let hasVerifier = 1;
 }
 
 def EmitC_ApplyOp : EmitC_Op<"apply", []> {
   let summary = "Apply operation";
   let description = [{
     With the `apply` operation the operators & (address of) and * (contents of)
     can be applied to a single operand.
 
def EmitC_ConstantOp : EmitC_Op<"constant", [ConstantLike]> {
 
   let arguments = (ins EmitC_OpaqueOrTypedAttr:$value);
   let results = (outs AnyType);
 
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
+def EmitC_DivOp : EmitC_BinaryArithOp<"div", []> {
+  let summary = "Division operation";
+  let description = [{
+    With the `div` operation the arithmetic operator / (division) can
+    be applied.
+
+    Example:
+
+    ```mlir
+    // Custom form of the division operation.
+    %0 = emitc.div %arg0, %arg1 : (i32, i32) -> i32
+    %1 = emitc.div %arg2, %arg3 : (f32, f32) -> f32
+    ```
+    ```c++
+    // Code emitted for the operations above.
+    int32_t v5 = v1 / v2;
+    float v6 = v3 / v4;
+    ```
+  }];
+
+  let arguments = (ins FloatIntegerIndexOrOpaqueType, FloatIntegerIndexOrOpaqueType);
+  let results = (outs FloatIntegerIndexOrOpaqueType);
+}
+
 def EmitC_IncludeOp
     : EmitC_Op<"include", [HasParent<"ModuleOp">]> {
   let summary = "Include operation";
   let description = [{
     The `include` operation allows to define a source file inclusion via the
     `#include` directive.
 
     Example:
def EmitC_IncludeOp
   }];
   let arguments = (ins
     Arg<StrAttr, "source file to include">:$include,
     UnitAttr:$is_standard_include
   );
   let hasCustomAssemblyFormat = 1;
 }
 
+def EmitC_MulOp : EmitC_BinaryArithOp<"mul", []> {
+  let summary = "Multiplication operation";
+  let description = [{
+    With the `mul` operation the arithmetic operator * (multiplication) can
+    be applied.
+
+    Example:
+
+    ```mlir
+    // Custom form of the multiplication operation.
+    %0 = emitc.mul %arg0, %arg1 : (i32, i32) -> i32
+    %1 = emitc.mul %arg2, %arg3 : (f32, f32) -> f32
+    ```
+    ```c++
+    // Code emitted for the operations above.
+    int32_t v5 = v1 * v2;
+    float v6 = v3 * v4;
+    ```
+  }];
+
+  let arguments = (ins FloatIntegerIndexOrOpaqueType, FloatIntegerIndexOrOpaqueType);
+  let results = (outs FloatIntegerIndexOrOpaqueType);
+}
+
+def EmitC_RemOp : EmitC_BinaryArithOp<"rem", []> {
+  let summary = "Remainder operation";
+  let description = [{
+    With the `rem` operation the arithmetic operator % (remainder) can
+    be applied.
+
+    Example:
+
+    ```mlir
+    // Custom form of the remainder operation.
+    %0 = emitc.rem %arg0, %arg1 : (i32, i32) -> i32
+    ```
+    ```c++
+    // Code emitted for the operation above.
+    int32_t v5 = v1 % v2;
+    ```
+  }];
+
+  let arguments = (ins IntegerIndexOrOpaqueType, IntegerIndexOrOpaqueType);
+  let results = (outs IntegerIndexOrOpaqueType);
+}
+
 def EmitC_SubOp : EmitC_BinaryArithOp<"sub", []> {
   let summary = "Subtraction operation";
   let description = [{
     With the `sub` operation the arithmetic operator - (subtraction) can
     be applied.
 
     Example:
 
     ```mlir
     // Custom form of the substraction operation.
     %0 = emitc.sub %arg0, %arg1 : (i32, i32) -> i32
     %1 = emitc.sub %arg2, %arg3 : (!emitc.ptr<f32>, i32) -> !emitc.ptr<f32>
     %2 = emitc.sub %arg4, %arg5 : (!emitc.ptr<i32>, !emitc.ptr<i32>)
         -> !emitc.opaque<"ptrdiff_t">
     ```
     ```c++
     // Code emitted for the operations above.
     int32_t v7 = v1 - v2;
     float* v8 = v3 - v4;
     ptrdiff_t v9 = v5 - v6;
     ```
   }];
+
+  let hasVerifier = 1;
 }
 
 def EmitC_VariableOp : EmitC_Op<"variable", []> {
   let summary = "Variable operation";
   let description = [{
     The `variable` operation produces an SSA value equal to some value
     specified by an attribute. This can be used to form simple integer and
     floating point variables, as well as more exotic things like tensor

mlir/lib/Target/Cpp/TranslateToCpp.cpp

 }
 
 static LogicalResult printOperation(CppEmitter &emitter, emitc::AddOp addOp) {
   Operation *operation = addOp.getOperation();
 
   return printBinaryArithOperation(emitter, operation, "+");
 }
 
+static LogicalResult printOperation(CppEmitter &emitter, emitc::DivOp divOp) {
+  Operation *operation = divOp.getOperation();
+
+  return printBinaryArithOperation(emitter, operation, "/");
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, emitc::MulOp mulOp) {
+  Operation *operation = mulOp.getOperation();
+
+  return printBinaryArithOperation(emitter, operation, "*");
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, emitc::RemOp remOp) {
+  Operation *operation = remOp.getOperation();
+
+  return printBinaryArithOperation(emitter, operation, "%");
+}
+
 static LogicalResult printOperation(CppEmitter &emitter, emitc::SubOp subOp) {
   Operation *operation = subOp.getOperation();
 
   return printBinaryArithOperation(emitter, operation, "-");
 }
 
 static LogicalResult printOperation(CppEmitter &emitter,
                                     cf::BranchOp branchOp) {
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::AddOp, emitc::ApplyOp, emitc::CallOp, emitc::CastOp,
-                emitc::ConstantOp, emitc::IncludeOp, emitc::SubOp,
-                emitc::VariableOp>(
+                emitc::ConstantOp, emitc::DivOp, emitc::IncludeOp, emitc::MulOp,
+                emitc::RemOp, emitc::SubOp, 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); })
           // Arithmetic ops.

mlir/test/Dialect/EmitC/invalid_ops.mlir

 func.func @add_float_pointer(%arg0: f32, %arg1: !emitc.ptr<f32>) {
     // expected-error @+1 {{'emitc.add' op requires that one operand is an integer or of opaque type if the other is a pointer}}
     %1 = "emitc.add" (%arg0, %arg1) : (f32, !emitc.ptr<f32>) -> !emitc.ptr<f32>
     return
 }
 
 // -----
 
+func.func @div_tensor(%arg0: tensor<i32>, %arg1: tensor<i32>) {
+    // expected-error @+1 {{'emitc.div' op operand #0 must be floating-point or integer or index 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 or integer or index 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 or index 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 or index or EmitC opaque type, but got 'f32'}}
+    %1 = "emitc.rem" (%arg0, %arg1) : (f32, f32) -> f32
+    return
+}
+
+// -----
+
 func.func @sub_int_pointer(%arg0: i32, %arg1: !emitc.ptr<f32>) {
     // expected-error @+1 {{'emitc.sub' op rhs can only be a pointer if lhs is a pointer}}
     %1 = "emitc.sub" (%arg0, %arg1) : (i32, !emitc.ptr<f32>) -> !emitc.ptr<f32>
     return
 }
 
 
 // -----

mlir/test/Dialect/EmitC/ops.mlir

 }
 
 func.func @add_pointer(%arg0: !emitc.ptr<f32>, %arg1: i32, %arg2: !emitc.opaque<"unsigned int">) {
   %1 = "emitc.add" (%arg0, %arg1) : (!emitc.ptr<f32>, i32) -> !emitc.ptr<f32>
   %2 = "emitc.add" (%arg0, %arg2) : (!emitc.ptr<f32>, !emitc.opaque<"unsigned int">) -> !emitc.ptr<f32>
   return
 }
 
+func.func @div_int(%arg0: i32, %arg1: i32) {
+  %1 = "emitc.div" (%arg0, %arg1) : (i32, i32) -> i32
+  return
+}
+
+func.func @div_float(%arg0: f32, %arg1: f32) {
+  %1 = "emitc.div" (%arg0, %arg1) : (f32, f32) -> f32
+  return
+}
+
+func.func @mul_int(%arg0: i32, %arg1: i32) {
+  %1 = "emitc.mul" (%arg0, %arg1) : (i32, i32) -> i32
+  return
+}
+
+func.func @mul_float(%arg0: f32, %arg1: f32) {
+  %1 = "emitc.mul" (%arg0, %arg1) : (f32, f32) -> f32
+  return
+}
+
+func.func @rem(%arg0: i32, %arg1: i32) {
+  %1 = "emitc.rem" (%arg0, %arg1) : (i32, i32) -> i32
+  return
+}
+
 func.func @sub_int(%arg0: i32, %arg1: i32) {
   %1 = "emitc.sub" (%arg0, %arg1) : (i32, i32) -> i32
   return
 }
 
 func.func @sub_pointer(%arg0: !emitc.ptr<f32>, %arg1: i32, %arg2: !emitc.opaque<"unsigned int">, %arg3: !emitc.ptr<f32>) {
   %1 = "emitc.sub" (%arg0, %arg1) : (!emitc.ptr<f32>, i32) -> !emitc.ptr<f32>
   %2 = "emitc.sub" (%arg0, %arg2) : (!emitc.ptr<f32>, !emitc.opaque<"unsigned int">) -> !emitc.ptr<f32>
   %3 = "emitc.sub" (%arg0, %arg3) : (!emitc.ptr<f32>, !emitc.ptr<f32>) -> !emitc.opaque<"ptrdiff_t">
   %4 = "emitc.sub" (%arg0, %arg3) : (!emitc.ptr<f32>, !emitc.ptr<f32>) -> i32
   return
 }

mlir/test/Target/Cpp/arithmetic_operators.mlir

 // RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s
 
 func.func @add_int(%arg0: i32, %arg1: i32) {
   %1 = "emitc.add" (%arg0, %arg1) : (i32, i32) -> i32
   return
 }
 // CHECK-LABEL: void add_int
 // CHECK-NEXT:  int32_t [[V2:[^ ]*]] = [[V0:[^ ]*]] + [[V1:[^ ]*]]
 
 func.func @add_pointer(%arg0: !emitc.ptr<f32>, %arg1: i32) {
   %1 = "emitc.add" (%arg0, %arg1) : (!emitc.ptr<f32>, i32) -> !emitc.ptr<f32>
   return
 }
 // CHECK-LABEL: void add_pointer
 // CHECK-NEXT:  float* [[V2:[^ ]*]] = [[V0:[^ ]*]] + [[V1:[^ ]*]]
 
+func.func @div_int(%arg0: i32, %arg1: i32) {
+  %1 = "emitc.div" (%arg0, %arg1) : (i32, i32) -> i32
+  return
+}
+// CHECK-LABEL: void div_int
+// CHECK-NEXT:  int32_t [[V2:[^ ]*]] = [[V0:[^ ]*]] / [[V1:[^ ]*]]
+
+func.func @mul_int(%arg0: i32, %arg1: i32) {
+  %1 = "emitc.mul" (%arg0, %arg1) : (i32, i32) -> i32
+  return
+}
+// CHECK-LABEL: void mul_int
+// CHECK-NEXT:  int32_t [[V2:[^ ]*]] = [[V0:[^ ]*]] * [[V1:[^ ]*]]
+
+func.func @rem(%arg0: i32, %arg1: i32) {
+  %1 = "emitc.rem" (%arg0, %arg1) : (i32, i32) -> i32
+  return
+}
+// CHECK-LABEL: void rem
+// CHECK-NEXT:  int32_t [[V2:[^ ]*]] = [[V0:[^ ]*]] % [[V1:[^ ]*]]
+
 func.func @sub_int(%arg0: i32, %arg1: i32) {
   %1 = "emitc.sub" (%arg0, %arg1) : (i32, i32) -> i32
   return
 }
 // CHECK-LABEL: void sub_int
 // CHECK-NEXT:  int32_t [[V2:[^ ]*]] = [[V0:[^ ]*]] - [[V1:[^ ]*]]
 
 func.func @sub_pointer(%arg0: !emitc.ptr<f32>, %arg1: !emitc.ptr<f32>) {
   %1 = "emitc.sub" (%arg0, %arg1) : (!emitc.ptr<f32>, !emitc.ptr<f32>) -> !emitc.opaque<"ptrdiff_t">
   return
 }
 // CHECK-LABEL: void sub_pointer
 // CHECK-NEXT:  ptrdiff_t [[V2:[^ ]*]] = [[V0:[^ ]*]] - [[V1:[^ ]*]]