[Mlir-commits] [mlir] f98b779 - [mlir] Refactor ComplexOps.td [NFC]

[Adrian Kuegel]

Author: Adrian Kuegel
Date: 2021-06-11T10:53:29+02:00
New Revision: f98b7796142d996861cbba824f3cacef0b446ef8

URL: https://github.com/llvm/llvm-project/commit/f98b7796142d996861cbba824f3cacef0b446ef8
DIFF: https://github.com/llvm/llvm-project/commit/f98b7796142d996861cbba824f3cacef0b446ef8.diff

LOG: [mlir] Refactor ComplexOps.td [NFC]

Create a ComplexUnaryOp base class and use it for AbsOp, ReOp and ImOp.
Sort all ops in lexicographic order.

Differential Revision: https://reviews.llvm.org/D104095

Added: 
    

Modified: 
    mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td

Removed: 
    


################################################################################
diff  --git a/mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td b/mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td
index 8b3ea0c84fb04..7e22ebfacfa05 100644
--- a/mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td
+++ b/mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td
@@ -29,47 +29,52 @@ class ComplexArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
   let verifier = ?;
 }
 
+// Base class for standard unary operations on complex numbers with a
+// floating-point element type. These operations take one operand and return
+// one result; the operand must be a complex number.
+class ComplexUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+    Complex_Op<mnemonic, traits # [NoSideEffect]> {
+  let arguments = (ins Complex<AnyFloat>:$complex);
+  let assemblyFormat = "$complex attr-dict `:` type($complex)";
+  let verifier = ?;
+}
+
 //===----------------------------------------------------------------------===//
-// AddOp
+// AbsOp
 //===----------------------------------------------------------------------===//
 
-def AddOp : ComplexArithmeticOp<"add"> {
-  let summary = "complex addition";
+def AbsOp : ComplexUnaryOp<"abs",
+    [TypesMatchWith<"complex element type matches result type",
+                    "complex", "result",
+                    "$_self.cast<ComplexType>().getElementType()">]> {
+  let summary = "computes absolute value of a complex number";
   let description = [{
-    The `add` operation takes two complex numbers and returns their sum.
+    The `abs` op takes a single complex number and computes its absolute value.
 
     Example:
 
     ```mlir
-    %a = complex.add %b, %c : complex<f32>
+    %a = complex.abs %b : complex<f32>
     ```
   }];
+  let results = (outs AnyFloat:$result);
 }
 
 //===----------------------------------------------------------------------===//
-// AbsOp
+// AddOp
 //===----------------------------------------------------------------------===//
 
-def AbsOp : Complex_Op<"abs",
-    [NoSideEffect,
-     TypesMatchWith<"complex element type matches result type",
-                    "complex", "result",
-                    "$_self.cast<ComplexType>().getElementType()">]> {
-  let summary = "computes absolute value of a complex number";
+def AddOp : ComplexArithmeticOp<"add"> {
+  let summary = "complex addition";
   let description = [{
-    The `abs` op takes a single complex number and computes its absolute value.
+    The `add` operation takes two complex numbers and returns their sum.
 
     Example:
 
     ```mlir
-    %a = complex.abs %b : complex<f32>
+    %a = complex.add %b, %c : complex<f32>
     ```
   }];
-
-  let arguments = (ins Complex<AnyFloat>:$complex);
-  let results = (outs AnyFloat:$result);
-
-  let assemblyFormat = "$complex attr-dict `:` type($complex)";
 }
 
 //===----------------------------------------------------------------------===//
@@ -121,33 +126,6 @@ def DivOp : ComplexArithmeticOp<"div"> {
   }];
 }
 
-//===----------------------------------------------------------------------===//
-// ImOp
-//===----------------------------------------------------------------------===//
-
-def ImOp : Complex_Op<"im",
-    [NoSideEffect,
-     TypesMatchWith<"complex element type matches result type",
-                    "complex", "imaginary",
-                    "$_self.cast<ComplexType>().getElementType()">]> {
-  let summary = "extracts the imaginary part of a complex number";
-  let description = [{
-    The `im` op takes a single complex number and extracts the imaginary part.
-
-    Example:
-
-    ```mlir
-    %a = complex.im %b : complex<f32>
-    ```
-  }];
-
-  let arguments = (ins Complex<AnyFloat>:$complex);
-  let results = (outs AnyFloat:$imaginary);
-
-  let assemblyFormat = "$complex attr-dict `:` type($complex)";
-  let hasFolder = 1;
-}
-
 //===----------------------------------------------------------------------===//
 // EqualOp
 //===----------------------------------------------------------------------===//
@@ -177,6 +155,29 @@ def EqualOp : Complex_Op<"eq",
   let assemblyFormat = "$lhs `,` $rhs  attr-dict `:` type($lhs)";
 }
 
+//===----------------------------------------------------------------------===//
+// ImOp
+//===----------------------------------------------------------------------===//
+
+def ImOp : ComplexUnaryOp<"im",
+    [TypesMatchWith<"complex element type matches result type",
+                    "complex", "imaginary",
+                    "$_self.cast<ComplexType>().getElementType()">]> {
+  let summary = "extracts the imaginary part of a complex number";
+  let description = [{
+    The `im` op takes a single complex number and extracts the imaginary part.
+
+    Example:
+
+    ```mlir
+    %a = complex.im %b : complex<f32>
+    ```
+  }];
+
+  let results = (outs AnyFloat:$imaginary);
+  let hasFolder = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
@@ -226,9 +227,8 @@ def NotEqualOp : Complex_Op<"neq",
 // ReOp
 //===----------------------------------------------------------------------===//
 
-def ReOp : Complex_Op<"re",
-    [NoSideEffect,
-     TypesMatchWith<"complex element type matches result type",
+def ReOp : ComplexUnaryOp<"re",
+    [TypesMatchWith<"complex element type matches result type",
                     "complex", "real",
                     "$_self.cast<ComplexType>().getElementType()">]> {
   let summary = "extracts the real part of a complex number";
@@ -242,10 +242,7 @@ def ReOp : Complex_Op<"re",
     ```
   }];
 
-  let arguments = (ins Complex<AnyFloat>:$complex);
   let results = (outs AnyFloat:$real);
-
-  let assemblyFormat = "$complex attr-dict `:` type($complex)";
   let hasFolder = 1;
 }