[mlir] Add SignOp to complex dialect.

[akuegel]

Summary

Also add a conversion pattern from Complex Dialect to Standard/Math Dialect.

[ftynse]

mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp

347

Nit: have you considered ImplicitLocOpBuilder?

371

Nit: I'd suggest wrapping this in // clang-format off and //clang-format on and maintaining a list with one pattern per string to avoid churn.

[akuegel]

Address review comments.

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

let description = [{
     %a = complex.re %b : complex<f32>
     ```
   }];
 
   let results = (outs AnyFloat:$real);
   let hasFolder = 1;
 }
 
+//===----------------------------------------------------------------------===//
+// SignOp
+//===----------------------------------------------------------------------===//
+
+def SignOp : ComplexUnaryOp<"sign", [SameOperandsAndResultType]> {
+  let summary = "computes sign of a complex number";
+  let description = [{
+    The `sign` op takes a single complex number and computes the sign of
+    it, i.e. `y = sign(x) = x / |x|` if `x != 0`, otherwise `y = 0`.
+
+    Example:
+
+    ```mlir
+    %a = complex.sign %b : complex<f32>
+    ```
+  }];
+
+  let results = (outs Complex<AnyFloat>:$result);
+}
 
 //===----------------------------------------------------------------------===//
 // SubOp
 //===----------------------------------------------------------------------===//
 
 def SubOp : ComplexArithmeticOp<"sub"> {
   let summary = "complex subtraction";
   let description = [{

mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp

 
 #include <memory>
 #include <type_traits>
 
 #include "../PassDetail.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 
 namespace {
 struct AbsOpConversion : public OpConversionPattern<complex::AbsOp> {
   using OpConversionPattern<complex::AbsOp>::OpConversionPattern;
matchAndRewrite(complex::NegOp op, ArrayRef<Value> operands,
     Value imag =
         rewriter.create<complex::ImOp>(loc, elementType, transformed.complex());
     Value negReal = rewriter.create<NegFOp>(loc, real);
     Value negImag = rewriter.create<NegFOp>(loc, imag);
     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, negReal, negImag);
     return success();
   }
 };
+
+struct SignOpConversion : public OpConversionPattern<complex::SignOp> {
+  using OpConversionPattern<complex::SignOp>::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(complex::SignOp op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    complex::SignOp::Adaptor transformed(operands);
+    auto type = transformed.complex().getType().cast<ComplexType>();
+    auto elementType = type.getElementType().cast<FloatType>();
+    mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
+
+    Value real = b.create<complex::ReOp>(elementType, transformed.complex());
+    Value imag = b.create<complex::ImOp>(elementType, transformed.complex());
+    Value zero = b.create<ConstantOp>(elementType, b.getZeroAttr(elementType));
+    Value realIsZero = b.create<CmpFOp>(CmpFPredicate::OEQ, real, zero);
+    Value imagIsZero = b.create<CmpFOp>(CmpFPredicate::OEQ, imag, zero);
+    Value isZero = b.create<AndOp>(realIsZero, imagIsZero);
+    auto abs = b.create<complex::AbsOp>(elementType, transformed.complex());
+    Value realSign = b.create<DivFOp>(real, abs);
+    Value imagSign = b.create<DivFOp>(imag, abs);
+    Value sign = b.create<complex::CreateOp>(type, realSign, imagSign);
+    rewriter.replaceOpWithNewOp<SelectOp>(op, isZero, transformed.complex(),
+                                          sign);
+    return success();
+  }
+};
 } // namespace
 
 void mlir::populateComplexToStandardConversionPatterns(
     RewritePatternSet &patterns) {
-  patterns.add<AbsOpConversion,
-               ComparisonOpConversion<complex::EqualOp, CmpFPredicate::OEQ>,
-               ComparisonOpConversion<complex::NotEqualOp, CmpFPredicate::UNE>,
-               DivOpConversion, ExpOpConversion, NegOpConversion>(
-      patterns.getContext());
+  // clang-format off
+  patterns.add<
+      AbsOpConversion,
+      DivOpConversion,
+      ExpOpConversion,
+      NegOpConversion,
+      SignOpConversion>(patterns.getContext());
+  // clang-format on
 }
 
 namespace {
 struct ConvertComplexToStandardPass
     : public ConvertComplexToStandardBase<ConvertComplexToStandardPass> {
   void runOnFunction() override;
 };
 
 void ConvertComplexToStandardPass::runOnFunction() {
   auto function = getFunction();
 
   // Convert to the Standard dialect using the converter defined above.
   RewritePatternSet patterns(&getContext());
   populateComplexToStandardConversionPatterns(patterns);
 
   ConversionTarget target(getContext());
   target.addLegalDialect<StandardOpsDialect, math::MathDialect,
                          complex::ComplexDialect>();
   target.addIllegalOp<complex::AbsOp, complex::DivOp, complex::EqualOp,
-                      complex::ExpOp, complex::NotEqualOp, complex::NegOp>();
+                      complex::ExpOp, complex::NotEqualOp, complex::NegOp,
+                      complex::SignOp>();
   if (failed(applyPartialConversion(function, target, std::move(patterns))))
     signalPassFailure();
 }
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createConvertComplexToStandardPass() {
   return std::make_unique<ConvertComplexToStandardPass>();
 }

mlir/test/Conversion/ComplexToStandard/convert-to-standard.mlir

 // CHECK: %[[REAL_LHS:.*]] = complex.re %[[LHS]] : complex<f32>
 // CHECK: %[[IMAG_LHS:.*]] = complex.im %[[LHS]] : complex<f32>
 // CHECK: %[[REAL_RHS:.*]] = complex.re %[[RHS]] : complex<f32>
 // CHECK: %[[IMAG_RHS:.*]] = complex.im %[[RHS]] : complex<f32>
 // CHECK-DAG: %[[REAL_NOT_EQUAL:.*]] = cmpf une, %[[REAL_LHS]], %[[REAL_RHS]] : f32
 // CHECK-DAG: %[[IMAG_NOT_EQUAL:.*]] = cmpf une, %[[IMAG_LHS]], %[[IMAG_RHS]] : f32
 // CHECK: %[[NOT_EQUAL:.*]] = or %[[REAL_NOT_EQUAL]], %[[IMAG_NOT_EQUAL]] : i1
 // CHECK: return %[[NOT_EQUAL]] : i1
+
+// CHECK-LABEL: func @complex_sign
+// CHECK-SAME: %[[ARG:.*]]: complex<f32>
+func @complex_sign(%arg: complex<f32>) -> complex<f32> {
+  %sign = complex.sign %arg: complex<f32>
+  return %sign : complex<f32>
+}
+// CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK: %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK: %[[ZERO:.*]] = constant 0.000000e+00 : f32
+// CHECK: %[[REAL_IS_ZERO:.*]] = cmpf oeq, %[[REAL]], %[[ZERO]] : f32
+// CHECK: %[[IMAG_IS_ZERO:.*]] = cmpf oeq, %1, %cst : f32
+// CHECK: %[[IS_ZERO:.*]] = and %[[REAL_IS_ZERO]], %[[IMAG_IS_ZERO]] : i1
+// CHECK: %[[REAL2:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK: %[[IMAG2:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK: %[[SQR_REAL:.*]] = mulf %[[REAL2]], %[[REAL2]] : f32
+// CHECK: %[[SQR_IMAG:.*]] = mulf %[[IMAG2]], %[[IMAG2]] : f32
+// CHECK: %[[SQ_NORM:.*]] = addf %[[SQR_REAL]], %[[SQR_IMAG]] : f32
+// CHECK: %[[NORM:.*]] = math.sqrt %[[SQ_NORM]] : f32
+// CHECK: %[[REAL_SIGN:.*]] = divf %[[REAL]], %[[NORM]] : f32
+// CHECK: %[[IMAG_SIGN:.*]] = divf %[[IMAG]], %[[NORM]] : f32
+// CHECK: %[[SIGN:.*]] = complex.create %[[REAL_SIGN]], %[[IMAG_SIGN]] : complex<f32>
+// CHECK: %[[RESULT:.*]] = select %[[IS_ZERO]], %[[ARG]], %[[SIGN]] : complex<f32>
+// CHECK: return %[[RESULT]] : complex<f32>