[mlir][emitc] Add add and sub operations

[marbre]

Summary

This adds operations for binary additive operators to EmitC. The input
arguments to these ops can be EmitC pointers and thus the operations can
be used for pointer arithmetic.

[marbre]

Updating D149963: [mlir][emitc] Add add and sub operations

Extend verifier to check emitc.sub result type.

[marbre]

Updating D149963: [mlir][emitc] Add add and sub operations

Adds a base class for binary arithmetic operations and a custom assembly format.

[marbre]

Updating D149963: [mlir][emitc] Add add and sub operations

Harmonize naming in the emitter.

[marbre]

Updating D149963: [mlir][emitc] Add add and sub operations

Fix examples.

[jpienaar]

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

40

Is this really an add? Meaning, this would also allow to represent "adding" two classes. Why not operator_plus op that correspond to the form without adding any connotation with arithmetic? (the verifier could still flag illegal pointer usage, but don't know if we need commutative or will be doing arithmetic level optimizations here).

51

I'd be more interested in seeing what the resultant output is rather than custom and generic.

[marbre]

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

40

Indeed, adding two !emitc.opaque types could result in adding two classes. According to https://en.cppreference.com/w/cpp/language/operator_arithmetic the operator name of + is addition. But we can rename to operator_plus, no strong feelings here.

Commutative could be skipped.

51

You mean the generated C/C++ code added as example here?

[jpienaar]

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

40

Good point (I was going off https://en.wikipedia.org/wiki/List_of_typographical_symbols_and_punctuation_marks and structural representation). Given C++ language already calls the operator that, I'd be fine with it (add, operator_add - probably doesn't make a difference as we'll never have both, so shorter is good). But yes lets drop commutative.

51

Yes, the generic form seems not specific to the op.

[marbre]

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

51

I've added the generated code accordingly.

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

 //===----------------------------------------------------------------------===//
 // EmitC op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for EmitC dialect ops.
 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;
+}
+
+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;
+    ```
+  }];
+}
+
 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.
 
     Example:
 
def EmitC_IncludeOp
   }];
   let arguments = (ins
     Arg<StrAttr, "source file to include">:$include,
     UnitAttr:$is_standard_include
   );
   let hasCustomAssemblyFormat = 1;
 }
 
+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;
+    ```
+  }];
+}
+
 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
     variables. The `variable` operation also supports the EmitC opaque
     attribute and the EmitC opaque type. If further supports the EmitC

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

 /// the desired resultant type.
 Operation *EmitCDialect::materializeConstant(OpBuilder &builder,
                                              Attribute value, Type type,
                                              Location loc) {
   return builder.create<emitc::ConstantOp>(loc, type, value);
 }
 
 //===----------------------------------------------------------------------===//
+// AddOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult AddOp::verify() {
+  Type lhsType = getLhs().getType();
+  Type rhsType = getRhs().getType();
+
+  if (lhsType.isa<emitc::PointerType>() && rhsType.isa<emitc::PointerType>())
+    return emitOpError("requires that at most one operand is a pointer");
+
+  if ((lhsType.isa<emitc::PointerType>() &&
+       !rhsType.isa<IntegerType, emitc::OpaqueType>()) ||
+      (rhsType.isa<emitc::PointerType>() &&
+       !lhsType.isa<IntegerType, emitc::OpaqueType>()))
+    return emitOpError("requires that one operand is an integer or of opaque "
+                       "type if the other is a pointer");
+
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // ApplyOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult ApplyOp::verify() {
   StringRef applicableOperatorStr = getApplicableOperator();
 
   // Applicable operator must not be empty.
   if (applicableOperatorStr.empty())
ParseResult IncludeOp::parse(OpAsmParser &parser, OperationState &result) {
   if (standardInclude)
     result.addAttribute("is_standard_include",
                         UnitAttr::get(parser.getContext()));
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// SubOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult SubOp::verify() {
+  Type lhsType = getLhs().getType();
+  Type rhsType = getRhs().getType();
+  Type resultType = getResult().getType();
+
+  if (rhsType.isa<emitc::PointerType>() && !lhsType.isa<emitc::PointerType>())
+    return emitOpError("rhs can only be a pointer if lhs is a pointer");
+
+  if (lhsType.isa<emitc::PointerType>() &&
+      !rhsType.isa<IntegerType, emitc::OpaqueType, emitc::PointerType>())
+    return emitOpError("requires that rhs is an integer, pointer or of opaque "
+                       "type if lhs is a pointer");
+
+  if (lhsType.isa<emitc::PointerType>() && rhsType.isa<emitc::PointerType>() &&
+      !resultType.isa<IntegerType, emitc::OpaqueType>())
+    return emitOpError("requires that the result is an integer or of opaque "
+                       "type if lhs and rhs are pointers");
+
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // VariableOp
 //===----------------------------------------------------------------------===//
 
 /// The variable op requires that the attribute's type matches the return type.
 LogicalResult emitc::VariableOp::verify() {
   if (llvm::isa<emitc::OpaqueAttr>(getValueAttr()))
     return success();
 

mlir/lib/Target/Cpp/TranslateToCpp.cpp

 static LogicalResult printOperation(CppEmitter &emitter,
                                     func::ConstantOp constantOp) {
   Operation *operation = constantOp.getOperation();
   Attribute value = constantOp.getValueAttr();
 
   return printConstantOp(emitter, operation, value);
 }
 
+static LogicalResult printBinaryArithOperation(CppEmitter &emitter,
+                                               Operation *operation,
+                                               StringRef binaryArithOperator) {
+  raw_ostream &os = emitter.ostream();
+
+  if (failed(emitter.emitAssignPrefix(*operation)))
+    return failure();
+  os << emitter.getOrCreateName(operation->getOperand(0));
+  os << " " << binaryArithOperator;
+  os << " " << emitter.getOrCreateName(operation->getOperand(1));
+
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, emitc::AddOp addOp) {
+  Operation *operation = addOp.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) {
   raw_ostream &os = emitter.ostream();
   Block &successor = *branchOp.getSuccessor();
 
   for (auto pair :
        llvm::zip(branchOp.getOperands(), successor.getArguments())) {
     Value &operand = std::get<0>(pair);
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::CastOp, emitc::ConstantOp,
-                emitc::IncludeOp, emitc::VariableOp>(
+          .Case<emitc::AddOp, emitc::ApplyOp, emitc::CallOp, emitc::CastOp,
+                emitc::ConstantOp, emitc::IncludeOp, 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 @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
 }
+
+// -----
+
+func.func @add_two_pointers(%arg0: !emitc.ptr<f32>, %arg1: !emitc.ptr<f32>) {
+    // expected-error @+1 {{'emitc.add' op requires that at most one operand is a pointer}}
+    %1 = "emitc.add" (%arg0, %arg1) : (!emitc.ptr<f32>, !emitc.ptr<f32>) -> !emitc.ptr<f32>
+    return
+}
+
+// -----
+
+func.func @add_pointer_float(%arg0: !emitc.ptr<f32>, %arg1: 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) : (!emitc.ptr<f32>, f32) -> !emitc.ptr<f32>
+    return
+}
+
+// -----
+
+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 @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
+}
+
+
+// -----
+
+func.func @sub_pointer_float(%arg0: !emitc.ptr<f32>, %arg1: f32) {
+    // expected-error @+1 {{'emitc.sub' op requires that rhs is an integer, pointer or of opaque type if lhs is a pointer}}
+    %1 = "emitc.sub" (%arg0, %arg1) : (!emitc.ptr<f32>, f32) -> !emitc.ptr<f32>
+    return
+}
+
+// -----
+
+func.func @sub_pointer_pointer(%arg0: !emitc.ptr<f32>, %arg1: !emitc.ptr<f32>) {
+    // expected-error @+1 {{'emitc.sub' op requires that the result is an integer or of opaque type if lhs and rhs are pointers}}
+    %1 = "emitc.sub" (%arg0, %arg1) : (!emitc.ptr<f32>, !emitc.ptr<f32>) -> !emitc.ptr<f32>
+    return
+}

mlir/test/Dialect/EmitC/ops.mlir

func.func @c() {
   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
 }
+
+func.func @add_int(%arg0: i32, %arg1: i32) {
+  %1 = "emitc.add" (%arg0, %arg1) : (i32, i32) -> i32
+  return
+}
+
+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 @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 @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:[^ ]*]]