[mlir][emitc] Add comparison operation

[simon-camp]

Summary

This adds a comparison operation to EmitC which supports ==, !=, <=, <, >=, >, <=>.

[simon-camp]

Updating D158180: [mlir][emitc] Add comparison operation

[jpienaar]

Overall looks good

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

181

It may read better without this comma, else the predicate looks like an operand to me. WDYT?

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

39

I see three-way most commonly used - but didn't check spec.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

321

Errors follow convention of being sentence fragments (start lower case, no trailing punctuation)

[simon-camp]

Updating D158180: [mlir][emitc] Add comparison operation

Address review comments.

[simon-camp]

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

181

I have no strong opinion on this. I just copied what was in the arith dialect and that one has the comma.

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

39

A hyphen won't work as this name is also used as an enum member in the ODS generated code. So I've gone with an underscore.

[simon-camp]

Updating D158180: [mlir][emitc] Add comparison operation

Code formatting

[jpienaar]

Thanks, makes sense to keep consistent with arith

mlir/test/Target/Cpp/comparison_operators.mlir

6

Mixed types are supported, how about mixing these a bit? i32 compare with f32, f32 with i64, i64 with unsigned, ... with custom? The number of compares remain the same as you are testing the enums, but contrary to arith dialect these can be mixed.

16

Shouldn't the second V0 here not be captured?

[simon-camp]

Updating D158180: [mlir][emitc] Add comparison operation

Mix up operand types and don't capture arguments multiple times.

[simon-camp]

mlir/test/Target/Cpp/comparison_operators.mlir

6

I shuffled some arguments around and varied the return type as well.

16

Yes, changed this to capture only the first occurence of an argument.

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

 add_mlir_dialect(EmitC emitc)
 add_mlir_doc(EmitC EmitC Dialects/ -gen-dialect-doc)
 
 set(LLVM_TARGET_DEFINITIONS EmitCAttributes.td)
+mlir_tablegen(EmitCEnums.h.inc -gen-enum-decls)
+mlir_tablegen(EmitCEnums.cpp.inc -gen-enum-defs)
 mlir_tablegen(EmitCAttributes.h.inc -gen-attrdef-decls)
 mlir_tablegen(EmitCAttributes.cpp.inc -gen-attrdef-defs)
 add_public_tablegen_target(MLIREmitCAttributesIncGen)

mlir/include/mlir/Dialect/EmitC/IR/EmitC.h

 #include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 #include "mlir/Dialect/EmitC/IR/EmitCDialect.h.inc"
+#include "mlir/Dialect/EmitC/IR/EmitCEnums.h.inc"
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCAttributes.h.inc"
 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCTypes.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitC.h.inc"
 
 #endif // MLIR_DIALECT_EMITC_IR_EMITC_H

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 = []> :
+// Base class for binary operations.
+class EmitC_BinaryOp<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)";
 }
 
 // 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", []> {
+def EmitC_AddOp : EmitC_BinaryOp<"add", []> {
   let summary = "Addition operation";
   let description = [{
     With the `add` operation the arithmetic operator + (addition) can
     be applied.
 
     Example:
 
     ```mlir
let description = [{
     ```
   }];
 
   let arguments = (ins AnyType:$source);
   let results = (outs AnyType:$dest);
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
 }
 
+def EmitC_CmpOp : EmitC_BinaryOp<"cmp", []> {
+  let summary = "Comparison operation";
+  let description = [{
+    With the `cmp` operation the comparison operators ==, !=, <, <=, >, >=, <=> 
+    can be applied.
+
+    Example:
+    ```mlir
+    // Custom form of the cmp operation.
+    %0 = emitc.cmp eq, %arg0, %arg1 : (i32, i32) -> i1
+    %1 = emitc.cmp lt, %arg2, %arg3 : 
+        (
+          !emitc.opaque<"std::valarray<float>">,
+          !emitc.opaque<"std::valarray<float>">
+        ) -> !emitc.opaque<"std::valarray<bool>">
+    ```
+    ```c++
+    // Code emitted for the operations above.
+    bool v5 = v1 == v2;
+    std::valarray<bool> v6 = v3 < v4;
+    ```
+  }];
+
+  let arguments = (ins EmitC_CmpPredicateAttr:$predicate,
+                       AnyType:$lhs,
+                       AnyType:$rhs);
+  let results = (outs AnyType);
+
+  let assemblyFormat = "$predicate `,` operands attr-dict `:` functional-type(operands, results)";
+}
+
 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,
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", []> {
+def EmitC_DivOp : EmitC_BinaryOp<"div", []> {
   let summary = "Division operation";
   let description = [{
     With the `div` operation the arithmetic operator / (division) can
     be applied.
 
     Example:
 
     ```mlir
def EmitC_LiteralOp : EmitC_Op<"literal", [Pure]> {
 
   let arguments = (ins StrAttr:$value);
   let results = (outs AnyType:$result);
 
   let hasVerifier = 1;
   let assemblyFormat = "$value attr-dict `:` type($result)";
 }
 
-def EmitC_MulOp : EmitC_BinaryArithOp<"mul", []> {
+def EmitC_MulOp : EmitC_BinaryOp<"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", []> {
+def EmitC_RemOp : EmitC_BinaryOp<"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", []> {
+def EmitC_SubOp : EmitC_BinaryOp<"sub", []> {
   let summary = "Subtraction operation";
   let description = [{
     With the `sub` operation the arithmetic operator - (subtraction) can
     be applied.
 
     Example:
 
     ```mlir

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_EMITC_IR_EMITCATTRIBUTES
 #define MLIR_DIALECT_EMITC_IR_EMITCATTRIBUTES
 
 include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/BuiltinAttributeInterfaces.td"
+include "mlir/IR/EnumAttr.td"
 include "mlir/Dialect/EmitC/IR/EmitCBase.td"
 
 //===----------------------------------------------------------------------===//
 // EmitC attribute definitions
 //===----------------------------------------------------------------------===//
 
 class EmitC_Attr<string name, string attrMnemonic, list<Trait> traits = []>
     : AttrDef<EmitC_Dialect, name, traits> {
   let mnemonic = attrMnemonic;
 }
 
+def EmitC_CmpPredicateAttr : I64EnumAttr<
+    "CmpPredicate", "",
+    [
+      I64EnumAttrCase<"eq", 0>,
+      I64EnumAttrCase<"ne", 1>,
+      I64EnumAttrCase<"lt", 2>,
+      I64EnumAttrCase<"le", 3>,
+      I64EnumAttrCase<"gt", 4>,
+      I64EnumAttrCase<"ge", 5>,
+      I64EnumAttrCase<"three_way", 6>,
+    ]> {
+  let cppNamespace = "::mlir::emitc";
+}
+
 def EmitC_OpaqueAttr : EmitC_Attr<"Opaque", "opaque"> {
   let summary = "An opaque attribute";
 
   let description = [{
     An opaque attribute of which the value gets emitted as is.
 
     Example:
 

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

 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitC.cpp.inc"
 
+
+//===----------------------------------------------------------------------===//
+// EmitC Enums
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/EmitC/IR/EmitCEnums.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // EmitC Attributes
 //===----------------------------------------------------------------------===//
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCAttributes.cpp.inc"
 
 Attribute emitc::OpaqueAttr::parse(AsmParser &parser, Type type) {

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) {
+static LogicalResult printBinaryOperation(CppEmitter &emitter,
+                                          StringRef binaryOperator) {
   raw_ostream &os = emitter.ostream();
 
   if (failed(emitter.emitAssignPrefix(*operation)))
     return failure();
   os << emitter.getOrCreateName(operation->getOperand(0));
-  os << " " << binaryArithOperator;
+  os << " " << binaryOperator;
   os << " " << emitter.getOrCreateName(operation->getOperand(1));
 
   return success();
 }
 
 static LogicalResult printOperation(CppEmitter &emitter, emitc::AddOp addOp) {
   Operation *operation = addOp.getOperation();
 
-  return printBinaryArithOperation(emitter, operation, "+");
+  return printBinaryOperation(emitter, operation, "+");
 }
 
 static LogicalResult printOperation(CppEmitter &emitter, emitc::DivOp divOp) {
   Operation *operation = divOp.getOperation();
 
-  return printBinaryArithOperation(emitter, operation, "/");
+  return printBinaryOperation(emitter, operation, "/");
 }
 
 static LogicalResult printOperation(CppEmitter &emitter, emitc::MulOp mulOp) {
   Operation *operation = mulOp.getOperation();
 
-  return printBinaryArithOperation(emitter, operation, "*");
+  return printBinaryOperation(emitter, operation, "*");
 }
 
 static LogicalResult printOperation(CppEmitter &emitter, emitc::RemOp remOp) {
   Operation *operation = remOp.getOperation();
 
-  return printBinaryArithOperation(emitter, operation, "%");
+  return printBinaryOperation(emitter, operation, "%");
 }
 
 static LogicalResult printOperation(CppEmitter &emitter, emitc::SubOp subOp) {
   Operation *operation = subOp.getOperation();
 
-  return printBinaryArithOperation(emitter, operation, "-");
+  return printBinaryOperation(emitter, operation, "-");
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, emitc::CmpOp cmpOp) {
+  Operation *operation = cmpOp.getOperation();
+
+  StringRef binaryOperator;
+
+  switch (cmpOp.getPredicate()) {
+  case emitc::CmpPredicate::eq:
+    binaryOperator = "==";
+    break;
+  case emitc::CmpPredicate::ne:
+    binaryOperator = "!=";
+    break;
+  case emitc::CmpPredicate::lt:
+    binaryOperator = "<";
+    break;
+  case emitc::CmpPredicate::le:
+    binaryOperator = "<=";
+    break;
+  case emitc::CmpPredicate::gt:
+    binaryOperator = ">";
+    break;
+  case emitc::CmpPredicate::ge:
+    binaryOperator = ">=";
+    break;
+  case emitc::CmpPredicate::three_way:
+    binaryOperator = "<=>";
+    break;
+  default:
+    return cmpOp.emitError("unhandled comparison predicate");
+  }
+
+  return printBinaryOperation(emitter, operation, binaryOperator);
 }
 
 static LogicalResult printOperation(CppEmitter &emitter,
                                     cf::BranchOp branchOp) {
   raw_ostream &os = emitter.ostream();
   Block &successor = *branchOp.getSuccessor();
 
   for (auto pair :
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::DivOp, emitc::IncludeOp, emitc::MulOp,
-                emitc::RemOp, emitc::SubOp, emitc::VariableOp>(
+                emitc::CmpOp, 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/ops.mlir

 
 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
 }
+
+func.func @cmp(%arg0 : i32, %arg1 : f32, %arg2 : i64, %arg3 : f64, %arg4 : !emitc.opaque<"unsigned">, %arg5 : !emitc.opaque<"std::valarray<int>">, %arg6 : !emitc.opaque<"custom">) {
+  %1 = "emitc.cmp" (%arg0, %arg0) {predicate = 0} : (i32, i32) -> i1
+  %2 = emitc.cmp eq, %arg0, %arg0 : (i32, i32) -> i1
+  %3 = "emitc.cmp" (%arg1, %arg1) {predicate = 1} : (f32, f32) -> i1
+  %4 = emitc.cmp ne, %arg1, %arg1 : (f32, f32) -> i1
+  %5 = "emitc.cmp" (%arg2, %arg2) {predicate = 2} : (i64, i64) -> i1
+  %6 = emitc.cmp lt, %arg2, %arg2 : (i64, i64) -> i1
+  %7 = "emitc.cmp" (%arg3, %arg3) {predicate = 3} : (f64, f64) -> i1
+  %8 = emitc.cmp le, %arg3, %arg3 : (f64, f64) -> i1
+  %9 = "emitc.cmp" (%arg4, %arg4) {predicate = 4} : (!emitc.opaque<"unsigned">, !emitc.opaque<"unsigned">) -> i1
+  %10 = emitc.cmp gt, %arg4, %arg4 : (!emitc.opaque<"unsigned">, !emitc.opaque<"unsigned">) -> i1
+  %11 = "emitc.cmp" (%arg5, %arg5) {predicate = 5} : (!emitc.opaque<"std::valarray<int>">, !emitc.opaque<"std::valarray<int>">) -> !emitc.opaque<"std::valarray<bool>">
+  %12 = emitc.cmp ge, %arg5, %arg5 : (!emitc.opaque<"std::valarray<int>">, !emitc.opaque<"std::valarray<int>">) -> !emitc.opaque<"std::valarray<bool>">
+  %13 = "emitc.cmp" (%arg6, %arg6) {predicate = 6} : (!emitc.opaque<"custom">, !emitc.opaque<"custom">) -> !emitc.opaque<"custom">
+  %14 = emitc.cmp three_way, %arg6, %arg6 : (!emitc.opaque<"custom">, !emitc.opaque<"custom">) -> !emitc.opaque<"custom">
+  return
+}

mlir/test/Target/Cpp/comparison_operators.mlir

+// RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s
+
+func.func @cmp(%arg0 : i32, %arg1 : f32, %arg2 : i64, %arg3 : f64, %arg4 : !emitc.opaque<"unsigned">, %arg5 : !emitc.opaque<"std::valarray<int>">, %arg6 : !emitc.opaque<"custom">) {
+  %1 = emitc.cmp eq, %arg0, %arg0 : (i32, i32) -> i1
+  %2 = emitc.cmp ne, %arg1, %arg1 : (f32, f32) -> i1
+  %3 = emitc.cmp lt, %arg2, %arg2 : (i64, i64) -> i1
+  %4 = emitc.cmp le, %arg3, %arg3 : (f64, f64) -> i1
+  %5 = emitc.cmp gt, %arg4, %arg4 : (!emitc.opaque<"unsigned">, !emitc.opaque<"unsigned">) -> i1
+  %6 = emitc.cmp ge, %arg5, %arg5 : (!emitc.opaque<"std::valarray<int>">, !emitc.opaque<"std::valarray<int>">) -> !emitc.opaque<"std::valarray<bool>">
+  %7 = emitc.cmp three_way, %arg6, %arg6 : (!emitc.opaque<"custom">, !emitc.opaque<"custom">) -> !emitc.opaque<"custom">
+  
+  return
+}
+// CHECK-LABEL: void cmp
+// CHECK-NEXT:  bool [[V7:[^ ]*]] = [[V0:[^ ]*]] == [[V0:[^ ]*]]
+// CHECK-NEXT:  bool [[V8:[^ ]*]] = [[V1:[^ ]*]] != [[V1:[^ ]*]]
+// CHECK-NEXT:  bool [[V9:[^ ]*]] = [[V2:[^ ]*]] < [[V2:[^ ]*]]
+// CHECK-NEXT:  bool [[V10:[^ ]*]] = [[V3:[^ ]*]] <= [[V3:[^ ]*]]
+// CHECK-NEXT:  bool [[V11:[^ ]*]] = [[V4:[^ ]*]] > [[V4:[^ ]*]]
+// CHECK-NEXT:  std::valarray<bool> [[V12:[^ ]*]] = [[V5:[^ ]*]] >= [[V5:[^ ]*]]
+// CHECK-NEXT:  custom [[V13:[^ ]*]] = [[V6:[^ ]*]] <=> [[V6:[^ ]*]]