[mlir][complex] Convert complex.conj to libm

[Lewuathe]

Summary

Add conversion for complex.conj to libm call

[bixia]

Nice! Thanks for your work!

mlir/lib/Conversion/ComplexToLibm/ComplexToLibm.cpp

void mlir::populateComplexToLibmConversionPatterns(RewritePatternSet &patterns,
   patterns.add<ScalarOpToLibmCall<complex::SqrtOp>>(patterns.getContext(),
                                                     "csqrtf", "csqrt", benefit);
   patterns.add<ScalarOpToLibmCall<complex::TanhOp>>(patterns.getContext(),
                                                     "ctanhf", "ctanh", benefit);
   patterns.add<ScalarOpToLibmCall<complex::CosOp>>(patterns.getContext(),
                                                    "ccosf", "ccos", benefit);
   patterns.add<ScalarOpToLibmCall<complex::SinOp>>(patterns.getContext(),
                                                    "csinf", "csin", benefit);
+  patterns.add<ScalarOpToLibmCall<complex::ConjOp>>(patterns.getContext(),
+                                                    "conjf", "conj", benefit);
 }
 
 namespace {
 struct ConvertComplexToLibmPass
     : public ConvertComplexToLibmBase<ConvertComplexToLibmPass> {
   void runOnOperation() override;
 };
 } // namespace

mlir/test/Conversion/ComplexToLibm/convert-to-libm.mlir

 // RUN: mlir-opt %s -convert-complex-to-libm -canonicalize | FileCheck %s
 
 // CHECK-DAG: @cpowf(complex<f32>, complex<f32>) -> complex<f32>
 // CHECK-DAG: @cpow(complex<f64>, complex<f64>) -> complex<f64>
 // CHECK-DAG: @csqrtf(complex<f32>) -> complex<f32>
 // CHECK-DAG: @csqrt(complex<f64>) -> complex<f64>
 // CHECK-DAG: @ctanhf(complex<f32>) -> complex<f32>
 // CHECK-DAG: @ctanh(complex<f64>) -> complex<f64>
 // CHECK-DAG: @ccos(complex<f64>) -> complex<f64>
 // CHECK-DAG: @csin(complex<f64>) -> complex<f64>
+// CHECK-DAG: @conj(complex<f64>) -> complex<f64>
 
 // CHECK-LABEL: func @cpow_caller
 // CHECK-SAME: %[[FLOAT:.*]]: complex<f32>
 // CHECK-SAME: %[[DOUBLE:.*]]: complex<f64>
 func.func @cpow_caller(%float: complex<f32>, %double: complex<f64>) -> (complex<f32>, complex<f64>)  {
   // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @cpowf(%[[FLOAT]], %[[FLOAT]]) : (complex<f32>, complex<f32>) -> complex<f32>
   %float_result = complex.pow %float, %float : complex<f32>
   // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @cpow(%[[DOUBLE]], %[[DOUBLE]]) : (complex<f64>, complex<f64>) -> complex<f64>

 // CHECK-SAME: %[[DOUBLE:.*]]: complex<f64>
 func.func @csin_caller(%float: complex<f32>, %double: complex<f64>) -> (complex<f32>, complex<f64>)  {
   // CHECK: %[[FLOAT_RESULT:.*]] = call @csinf(%[[FLOAT]])
   %float_result = complex.sin %float : complex<f32>
   // CHECK: %[[DOUBLE_RESULT:.*]] = call @csin(%[[DOUBLE]])
   %double_result = complex.sin %double : complex<f64>
   // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]
   return %float_result, %double_result : complex<f32>, complex<f64>
+}
+
+// CHECK-LABEL: func @conj_caller
+// CHECK-SAME: %[[FLOAT:.*]]: complex<f32>
+// CHECK-SAME: %[[DOUBLE:.*]]: complex<f64>
+func.func @conj_caller(%float: complex<f32>, %double: complex<f64>) -> (complex<f32>, complex<f64>)  {
+  // CHECK: %[[FLOAT_RESULT:.*]] = call @conjf(%[[FLOAT]])
+  %float_result = complex.conj %float : complex<f32>
+  // CHECK: %[[DOUBLE_RESULT:.*]] = call @conj(%[[DOUBLE]])
+  %double_result = complex.conj %double : complex<f64>
+  // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]
+  return %float_result, %double_result : complex<f32>, complex<f64>
 }
 No newline at end of file