[mlir] Extend 1:N type conversion tests to decompose complex<T>.

[ingomueller-net]

Summary

This commit extends the test pass for 1:N type conversion to convert
complex<T> into T, T. This allows to convert complex numbers to built-in
types in function signatures, adding materializations to the beginning
and end of the function body where necessary. The commit also extends
the test cases of ComplexToStandard such that the function signatures
are converted either before that conversion or after. The additional
checks show that, with very few exceptions, both orders lead to the same
result, so the 1:N type conversion composes cleanly with other
transformations. (The few exceptions are due to foldings or
canonicalizations triggered in one order but not the other. This could
be avoided by implementing a dedicated pattern application driver in the
1:N type conversion pass, instead of using applyPatternsAndFoldGreedily.)

*Update:* This patch is conceptually related to
https://reviews.llvm.org/D144469, but, for the time being, should only
illustrate the capabilities of that patch. My limited understanding of
arc/Phabricator has also led me to create
https://reviews.llvm.org/D145500, which is probably just superfluous.

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

 // RUN: mlir-opt %s --convert-complex-to-standard --split-input-file |\
 // RUN: FileCheck %s --dump-input=always
 
+// Run Complex2Standard and structural conversion of func ops in both orders
+// with the same check prefix to check that they produce the same result.
+
+// RUN: mlir-opt %s -split-input-file \
+// RUN:   -convert-complex-to-standard -test-one-to-n-type-conversion="convert-func-ops" \
+// RUN: | FileCheck %s --dump-input=always --check-prefix=CHECK-FUNC
+
+// RUN: mlir-opt %s -split-input-file \
+// RUN:   -test-one-to-n-type-conversion="convert-func-ops" -convert-complex-to-standard \
+// RUN: | FileCheck %s --dump-input=always --check-prefix=CHECK-FUNC
+
 // CHECK-LABEL: func @complex_abs
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_abs(%arg: complex<f32>) -> f32 {
   %abs = complex.abs %arg: complex<f32>
   return %abs : f32
 }
 // CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
 // CHECK: %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
 // CHECK-DAG: %[[REAL_SQ:.*]] = arith.mulf %[[REAL]], %[[REAL]] : f32
 // CHECK-DAG: %[[IMAG_SQ:.*]] = arith.mulf %[[IMAG]], %[[IMAG]] : f32
 // CHECK: %[[SQ_NORM:.*]] = arith.addf %[[REAL_SQ]], %[[IMAG_SQ]] : f32
 // CHECK: %[[NORM:.*]] = math.sqrt %[[SQ_NORM]] : f32
 // CHECK: return %[[NORM]] : f32
 
+// CHECK-FUNC-LABEL: func @complex_abs(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> f32
+// CHECK-FUNC:         %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC:         %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[REAL_SQ:.*]] = arith.mulf %[[REAL]], %[[REAL]] : f32
+// CHECK-FUNC:         %[[IMAG_SQ:.*]] = arith.mulf %[[IMAG]], %[[IMAG]] : f32
+// CHECK-FUNC:         %[[SQ_NORM:.*]] = arith.addf %[[REAL_SQ]], %[[IMAG_SQ]] : f32
+// CHECK-FUNC:         %[[NORM:.*]] = math.sqrt %[[SQ_NORM]] : f32
+// CHECK-FUNC:         return %[[NORM]] : f32
+
 // -----
 
 // CHECK-LABEL: func @complex_atan2
 func.func @complex_atan2(%lhs: complex<f32>,
                          %rhs: complex<f32>) -> complex<f32> {
   %atan2 = complex.atan2 %lhs, %rhs : complex<f32>
   return %atan2 : complex<f32>
 }
 
+// CHECK-FUNC-LABEL: func @complex_atan2(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG2:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG3:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[V0:.*]] = complex.create %[[ARG2]], %[[ARG3]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[V1:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+
 // -----
 
 // CHECK-LABEL: func @complex_add
 // CHECK-SAME: (%[[LHS:.*]]: complex<f32>, %[[RHS:.*]]: complex<f32>)
 func.func @complex_add(%lhs: complex<f32>, %rhs: complex<f32>) -> complex<f32> {
   %add = complex.add %lhs, %rhs: complex<f32>
   return %add : complex<f32>
 }
 // CHECK: %[[REAL_LHS:.*]] = complex.re %[[LHS]] : complex<f32>
 // CHECK: %[[REAL_RHS:.*]] = complex.re %[[RHS]] : complex<f32>
 // CHECK: %[[RESULT_REAL:.*]] = arith.addf %[[REAL_LHS]], %[[REAL_RHS]] : f32
 // CHECK: %[[IMAG_LHS:.*]] = complex.im %[[LHS]] : complex<f32>
 // CHECK: %[[IMAG_RHS:.*]] = complex.im %[[RHS]] : complex<f32>
 // CHECK: %[[RESULT_IMAG:.*]] = arith.addf %[[IMAG_LHS]], %[[IMAG_RHS]] : f32
 // CHECK: %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_add(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG2:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG3:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[RHS:.*]] = complex.create %[[ARG2]], %[[ARG3]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[LHS:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC:         %[[REAL_LHS:.*]] = complex.re %[[LHS]] : complex<f32>
+// CHECK-FUNC:         %[[REAL_RHS:.*]] = complex.re %[[RHS]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_REAL:.*]] = arith.addf %[[REAL_LHS]], %[[REAL_RHS]] : f32
+// CHECK-FUNC:         %[[IMAG_LHS:.*]] = complex.im %[[LHS]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG_RHS:.*]] = complex.im %[[RHS]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IMAG:.*]] = arith.addf %[[IMAG_LHS]], %[[IMAG_RHS]] : f32
+// CHECK-FUNC:         %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_RE:.*]] = complex.re %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IM:.*]] = complex.im %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         return %[[RESULT_RE]], %[[RESULT_IM]] : f32, f32
+
 // -----
 
 // CHECK-LABEL: func @complex_cos
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_cos(%arg: complex<f32>) -> complex<f32> {
   %cos = complex.cos %arg : complex<f32>
   return %cos : complex<f32>
 }

 // CHECK: %[[RESULT_REAL_IS_NAN:.*]] = arith.cmpf uno, %[[RESULT_REAL]], %[[ZERO]] : f32
 // CHECK: %[[RESULT_IMAG_IS_NAN:.*]] = arith.cmpf uno, %[[RESULT_IMAG]], %[[ZERO]] : f32
 // CHECK: %[[RESULT_IS_NAN:.*]] = arith.andi %[[RESULT_REAL_IS_NAN]], %[[RESULT_IMAG_IS_NAN]] : i1
 // CHECK: %[[RESULT_REAL_WITH_SPECIAL_CASES:.*]] = arith.select %[[RESULT_IS_NAN]], %[[RESULT_REAL_SPECIAL_CASE_1]], %[[RESULT_REAL]] : f32
 // CHECK: %[[RESULT_IMAG_WITH_SPECIAL_CASES:.*]] = arith.select %[[RESULT_IS_NAN]], %[[RESULT_IMAG_SPECIAL_CASE_1]], %[[RESULT_IMAG]] : f32
 // CHECK: %[[RESULT:.*]] = complex.create %[[RESULT_REAL_WITH_SPECIAL_CASES]], %[[RESULT_IMAG_WITH_SPECIAL_CASES]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_div(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG2:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG3:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[RHS:.*]] = complex.create %[[ARG2]], %[[ARG3]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[LHS:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+
 // -----
 
 // CHECK-LABEL: func @complex_eq
 // CHECK-SAME: %[[LHS:.*]]: complex<f32>, %[[RHS:.*]]: complex<f32>
 func.func @complex_eq(%lhs: complex<f32>, %rhs: complex<f32>) -> i1 {
   %eq = complex.eq %lhs, %rhs: complex<f32>
   return %eq : i1
 }
 // 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_EQUAL:.*]] = arith.cmpf oeq, %[[REAL_LHS]], %[[REAL_RHS]] : f32
 // CHECK-DAG: %[[IMAG_EQUAL:.*]] = arith.cmpf oeq, %[[IMAG_LHS]], %[[IMAG_RHS]] : f32
 // CHECK: %[[EQUAL:.*]] = arith.andi %[[REAL_EQUAL]], %[[IMAG_EQUAL]] : i1
 // CHECK: return %[[EQUAL]] : i1
 
+// CHECK-FUNC-LABEL: func @complex_eq(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG2:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG3:[^:]*]]: f32) -> i1
+// CHECK-FUNC-DAG:     %[[RHS:.*]] = complex.create %[[ARG2]], %[[ARG3]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[LHS:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC:         %[[REAL_LHS:.*]] = complex.re %[[LHS]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG_LHS:.*]] = complex.im %[[LHS]] : complex<f32>
+// CHECK-FUNC:         %[[REAL_RHS:.*]] = complex.re %[[RHS]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG_RHS:.*]] = complex.im %[[RHS]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[REAL_EQUAL:.*]] = arith.cmpf oeq, %[[REAL_LHS]], %[[REAL_RHS]] : f32
+// CHECK-FUNC-DAG:     %[[IMAG_EQUAL:.*]] = arith.cmpf oeq, %[[IMAG_LHS]], %[[IMAG_RHS]] : f32
+// CHECK-FUNC:         %[[EQUAL:.*]] = arith.andi %[[REAL_EQUAL]], %[[IMAG_EQUAL]] : i1
+// CHECK-FUNC:         return %[[EQUAL]] : i1
+
 // -----
 
 // CHECK-LABEL: func @complex_exp
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_exp(%arg: complex<f32>) -> complex<f32> {
   %exp = complex.exp %arg: complex<f32>
   return %exp : complex<f32>
 }
 // CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
 // CHECK: %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
 // CHECK-DAG: %[[COS_IMAG:.*]] = math.cos %[[IMAG]] : f32
 // CHECK-DAG: %[[EXP_REAL:.*]] = math.exp %[[REAL]] : f32
 // CHECK-DAG: %[[RESULT_REAL:.]] = arith.mulf %[[EXP_REAL]], %[[COS_IMAG]] : f32
 // CHECK-DAG: %[[SIN_IMAG:.*]] = math.sin %[[IMAG]] : f32
 // CHECK-DAG: %[[RESULT_IMAG:.*]] = arith.mulf %[[EXP_REAL]], %[[SIN_IMAG]] : f32
 // CHECK: %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_exp(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-NEXT:    %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC:         %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[COS_IMAG:.*]] = math.cos %[[IMAG]] : f32
+// CHECK-FUNC-DAG:     %[[EXP_REAL:.*]] = math.exp %[[REAL]] : f32
+// CHECK-FUNC-DAG:     %[[RESULT_REAL:.]] = arith.mulf %[[EXP_REAL]], %[[COS_IMAG]] : f32
+// CHECK-FUNC-DAG:     %[[SIN_IMAG:.*]] = math.sin %[[IMAG]] : f32
+// CHECK-FUNC-DAG:     %[[RESULT_IMAG:.*]] = arith.mulf %[[EXP_REAL]], %[[SIN_IMAG]] : f32
+// CHECK-FUNC:         %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_RE:.*]] = complex.re %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IM:.*]] = complex.im %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         return %[[RESULT_RE]], %[[RESULT_IM]] : f32, f32
+
 // -----
 
 // CHECK-LABEL:   func.func @complex_expm1(
 // CHECK-SAME:                             %[[ARG:.*]]: complex<f32>) -> complex<f32> {
 func.func @complex_expm1(%arg: complex<f32>) -> complex<f32> {
   %expm1 = complex.expm1 %arg: complex<f32>
   return %expm1 : complex<f32>
 }
 // CHECK: %[[REAL_I:.*]] = complex.re %[[ARG]] : complex<f32>
 // CHECK: %[[IMAG_I:.*]] = complex.im %[[ARG]] : complex<f32>
 // CHECK: %[[EXP:.*]] = math.exp %[[REAL_I]] : f32
 // CHECK: %[[COS:.*]] = math.cos %[[IMAG_I]] : f32
 // CHECK: %[[RES_REAL:.*]] = arith.mulf %[[EXP]], %[[COS]] : f32
 // CHECK: %[[SIN:.*]] = math.sin %[[IMAG_I]] : f32
 // CHECK: %[[RES_IMAG:.*]] = arith.mulf %[[EXP]], %[[SIN]] : f32
 // CHECK: %[[RES_EXP:.*]] = complex.create %[[RES_REAL]], %[[RES_IMAG]] : complex<f32>
 // CHECK: %[[REAL:.*]] = complex.re %[[RES_EXP]] : complex<f32>
 // CHECK: %[[ONE:.*]] = arith.constant 1.000000e+00 : f32
 // CHECK: %[[REAL_M1:.*]] = arith.subf %[[REAL]], %[[ONE]] : f32
 // CHECK: %[[IMAG:.*]] = complex.im %[[RES_EXP]] : complex<f32>
 // CHECK: %[[RES:.*]] = complex.create %[[REAL_M1]], %[[IMAG]] : complex<f32>
 // CHECK: return %[[RES]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_expm1(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[REAL_I:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[IMAG_I:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[EXP:.*]] = math.exp %[[REAL_I]] : f32
+// CHECK-FUNC-DAG:     %[[COS:.*]] = math.cos %[[IMAG_I]] : f32
+// CHECK-FUNC-DAG:     %[[RES_REAL:.*]] = arith.mulf %[[EXP]], %[[COS]] : f32
+// CHECK-FUNC-DAG:     %[[SIN:.*]] = math.sin %[[IMAG_I]] : f32
+// CHECK-FUNC-DAG:     %[[RES_IMAG:.*]] = arith.mulf %[[EXP]], %[[SIN]] : f32
+// CHECK-FUNC-DAG:     %[[ONE:.*]] = arith.constant 1.000000e+00 : f32
+// XXX: If ComplexToStandard runs first, some ops are folded, so we leave some
+//      leeway for the matching...
+// CHECK-FUNC:         %[[REAL_M1:.*]] = arith.subf %[[RES_REAL:.*]], %[[ONE]] : f32
+// CHECK-FUNC:         %[[RES:.*]] = complex.create %[[REAL_M1]], %[[RES_IMAG:.*]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_RE:.*]] = complex.re %[[RES]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IM:.*]] = complex.im %[[RES]] : complex<f32>
+// CHECK-FUNC:         return %[[RESULT_RE]], %[[RESULT_IM]] : f32, f32
+
+
 // -----
 
 // CHECK-LABEL: func @complex_log
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_log(%arg: complex<f32>) -> complex<f32> {
   %log = complex.log %arg: complex<f32>
   return %log : complex<f32>
 }
 // CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
 // CHECK: %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
 // CHECK: %[[SQR_REAL:.*]] = arith.mulf %[[REAL]], %[[REAL]] : f32
 // CHECK: %[[SQR_IMAG:.*]] = arith.mulf %[[IMAG]], %[[IMAG]] : f32
 // CHECK: %[[SQ_NORM:.*]] = arith.addf %[[SQR_REAL]], %[[SQR_IMAG]] : f32
 // CHECK: %[[NORM:.*]] = math.sqrt %[[SQ_NORM]] : f32
 // CHECK: %[[RESULT_REAL:.*]] = math.log %[[NORM]] : f32
 // CHECK: %[[REAL2:.*]] = complex.re %[[ARG]] : complex<f32>
 // CHECK: %[[IMAG2:.*]] = complex.im %[[ARG]] : complex<f32>
 // CHECK: %[[RESULT_IMAG:.*]] = math.atan2 %[[IMAG2]], %[[REAL2]] : f32
 // CHECK: %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_log(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC:         %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC:         %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK-FUNC:         %[[SQR_REAL:.*]] = arith.mulf %[[REAL]], %[[REAL]] : f32
+// CHECK-FUNC:         %[[SQR_IMAG:.*]] = arith.mulf %[[IMAG]], %[[IMAG]] : f32
+// CHECK-FUNC:         %[[SQ_NORM:.*]] = arith.addf %[[SQR_REAL]], %[[SQR_IMAG]] : f32
+// CHECK-FUNC:         %[[NORM:.*]] = math.sqrt %[[SQ_NORM]] : f32
+// CHECK-FUNC:         %[[RESULT_REAL:.*]] = math.log %[[NORM]] : f32
+// CHECK-FUNC:         %[[REAL2:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG2:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IMAG:.*]] = math.atan2 %[[IMAG2]], %[[REAL2]] : f32
+// CHECK-FUNC:         %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_RE:.*]] = complex.re %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IM:.*]] = complex.im %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         return %[[RESULT_RE]], %[[RESULT_IM]] : f32, f32
+
 // -----
 
 // CHECK-LABEL: func @complex_log1p
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_log1p(%arg: complex<f32>) -> complex<f32> {
   %log1p = complex.log1p %arg: complex<f32>
   return %log1p : complex<f32>
 }

 // CHECK: %[[SQ_SUM_2:.*]] = arith.addf %[[SQ_SUM_1]], %[[SQ_IMAG]] : f32
 // CHECK: %[[LOG_SQ_SUM:.*]] = math.log1p %[[SQ_SUM_2]] : f32
 // CHECK: %[[RESULT_REAL:.*]] = arith.mulf %[[LOG_SQ_SUM]], %[[ONE_HALF]] : f32
 // CHECK: %[[REAL_PLUS_ONE:.*]] = arith.addf %[[REAL]], %[[ONE]] : f32
 // CHECK: %[[RESULT_IMAG:.*]] = math.atan2 %[[IMAG]], %[[REAL_PLUS_ONE]] : f32
 // CHECK: %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_log1p(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[ONE_HALF:.*]] = arith.constant 5.000000e-01 : f32
+// CHECK-FUNC-DAG:     %[[ONE:.*]] = arith.constant 1.000000e+00 : f32
+// CHECK-FUNC-DAG:     %[[TWO:.*]] = arith.constant 2.000000e+00 : f32
+// CHECK-FUNC-DAG:     %[[SQ_SUM_0:.*]] = arith.mulf %[[REAL]], %[[REAL]] : f32
+// CHECK-FUNC-DAG:     %[[TWO_REAL:.*]] = arith.mulf %[[REAL]], %[[TWO]] : f32
+// CHECK-FUNC-DAG:     %[[SQ_SUM_1:.*]] = arith.addf %[[SQ_SUM_0]], %[[TWO_REAL]] : f32
+// CHECK-FUNC-DAG:     %[[SQ_IMAG:.*]] = arith.mulf %[[IMAG]], %[[IMAG]] : f32
+// CHECK-FUNC-DAG:     %[[SQ_SUM_2:.*]] = arith.addf %[[SQ_SUM_1]], %[[SQ_IMAG]] : f32
+// CHECK-FUNC-DAG:     %[[LOG_SQ_SUM:.*]] = math.log1p %[[SQ_SUM_2]] : f32
+// CHECK-FUNC-DAG:     %[[RESULT_REAL:.*]] = arith.mulf %[[LOG_SQ_SUM]], %[[ONE_HALF]] : f32
+// CHECK-FUNC-DAG:     %[[REAL_PLUS_ONE:.*]] = arith.addf %[[REAL]], %[[ONE]] : f32
+// CHECK-FUNC:         %[[RESULT_IMAG:.*]] = math.atan2 %[[IMAG]], %[[REAL_PLUS_ONE]] : f32
+// CHECK-FUNC:         %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_RE:.*]] = complex.re %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IM:.*]] = complex.im %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         return %[[RESULT_RE]], %[[RESULT_IM]] : f32, f32
 // -----
 
 // CHECK-LABEL: func @complex_mul
 // CHECK-SAME: (%[[LHS:.*]]: complex<f32>, %[[RHS:.*]]: complex<f32>)
 func.func @complex_mul(%lhs: complex<f32>, %rhs: complex<f32>) -> complex<f32> {
   %mul = complex.mul %lhs, %rhs : complex<f32>
   return %mul : complex<f32>
 }

 // CHECK: %[[LHS_REAL_TIMES_RHS_IMAG:.*]] = arith.mulf %[[LHS_REAL3]], %[[RHS_IMAG3]] : f32
 // CHECK: %[[NEW_IMAG:.*]] = arith.addf %[[LHS_IMAG_TIMES_RHS_REAL]], %[[LHS_REAL_TIMES_RHS_IMAG]] : f32
 // CHECK: %[[NEW_IMAG_TIMES_INF:.*]] = arith.mulf %[[INF]], %[[NEW_IMAG]] : f32
 // CHECK: %[[FINAL_IMAG:.*]] = arith.select %[[RECALC3]], %[[NEW_IMAG_TIMES_INF]], %[[IMAG]] : f32
 
 // CHECK: %[[RESULT:.*]] = complex.create %[[FINAL_REAL]], %[[FINAL_IMAG]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_mul(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG2:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG3:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[RHS:.*]] = complex.create %[[ARG2]], %[[ARG3]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[LHS:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+
 // -----
 
 // CHECK-LABEL: func @complex_neg
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_neg(%arg: complex<f32>) -> complex<f32> {
   %neg = complex.neg %arg: complex<f32>
   return %neg : complex<f32>
 }
 // CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
 // CHECK: %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
 // CHECK-DAG: %[[NEG_REAL:.*]] = arith.negf %[[REAL]] : f32
 // CHECK-DAG: %[[NEG_IMAG:.*]] = arith.negf %[[IMAG]] : f32
 // CHECK: %[[RESULT:.*]] = complex.create %[[NEG_REAL]], %[[NEG_IMAG]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_neg(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC:         %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[NEG_REAL:.*]] = arith.negf %[[REAL]] : f32
+// CHECK-FUNC-DAG:     %[[NEG_IMAG:.*]] = arith.negf %[[IMAG]] : f32
+// CHECK-FUNC:         %[[RESULT:.*]] = complex.create %[[NEG_REAL]], %[[NEG_IMAG]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_RE:.*]] = complex.re %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IM:.*]] = complex.im %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         return %[[RESULT_RE]], %[[RESULT_IM]] : f32, f32
+
 // -----
 
 // CHECK-LABEL: func @complex_neq
 // CHECK-SAME: %[[LHS:.*]]: complex<f32>, %[[RHS:.*]]: complex<f32>
 func.func @complex_neq(%lhs: complex<f32>, %rhs: complex<f32>) -> i1 {
   %neq = complex.neq %lhs, %rhs: complex<f32>
   return %neq : i1
 }
 // 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:.*]] = arith.cmpf une, %[[REAL_LHS]], %[[REAL_RHS]] : f32
 // CHECK-DAG: %[[IMAG_NOT_EQUAL:.*]] = arith.cmpf une, %[[IMAG_LHS]], %[[IMAG_RHS]] : f32
 // CHECK: %[[NOT_EQUAL:.*]] = arith.ori %[[REAL_NOT_EQUAL]], %[[IMAG_NOT_EQUAL]] : i1
 // CHECK: return %[[NOT_EQUAL]] : i1
 
+// CHECK-FUNC-LABEL: func @complex_neq(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG2:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG3:[^:]*]]: f32) -> i1
+// CHECK-FUNC-DAG:     %[[RHS:.*]] = complex.create %[[ARG2]], %[[ARG3]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[LHS:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC:         %[[REAL_LHS:.*]] = complex.re %[[LHS]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG_LHS:.*]] = complex.im %[[LHS]] : complex<f32>
+// CHECK-FUNC:         %[[REAL_RHS:.*]] = complex.re %[[RHS]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG_RHS:.*]] = complex.im %[[RHS]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[REAL_NOT_EQUAL:.*]] = arith.cmpf une, %[[REAL_LHS]], %[[REAL_RHS]] : f32
+// CHECK-FUNC-DAG:     %[[IMAG_NOT_EQUAL:.*]] = arith.cmpf une, %[[IMAG_LHS]], %[[IMAG_RHS]] : f32
+// CHECK-FUNC:         %[[NOT_EQUAL:.*]] = arith.ori %[[REAL_NOT_EQUAL]], %[[IMAG_NOT_EQUAL]] : i1
+// CHECK-FUNC:         return %[[NOT_EQUAL]] : i1
 // -----
 
 // CHECK-LABEL: func @complex_sin
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_sin(%arg: complex<f32>) -> complex<f32> {
   %sin = complex.sin %arg : complex<f32>
   return %sin : complex<f32>
 }
 // CHECK-DAG: %[[REAL:.*]] = complex.re %[[ARG]]
 // CHECK-DAG: %[[IMAG:.*]] = complex.im %[[ARG]]
 // CHECK-DAG: %[[HALF:.*]] = arith.constant 5.000000e-01 : f32
 // CHECK-DAG: %[[EXP:.*]] = math.exp %[[IMAG]] : f32
 // CHECK-DAG: %[[HALF_EXP:.*]] = arith.mulf %[[HALF]], %[[EXP]]
 // CHECK-DAG: %[[HALF_REXP:.*]] = arith.divf %[[HALF]], %[[EXP]]
 // CHECK-DAG: %[[SIN:.*]] = math.sin %[[REAL]] : f32
 // CHECK-DAG: %[[COS:.*]] = math.cos %[[REAL]] : f32
 // CHECK-DAG: %[[EXP_SUM:.*]] = arith.addf %[[HALF_EXP]], %[[HALF_REXP]]
 // CHECK-DAG: %[[RESULT_REAL:.*]] = arith.mulf %[[EXP_SUM]], %[[SIN]]
 // CHECK-DAG: %[[EXP_DIFF:.*]] = arith.subf %[[HALF_EXP]], %[[HALF_REXP]]
 // CHECK-DAG: %[[RESULT_IMAG:.*]] = arith.mulf %[[EXP_DIFF]], %[[COS]]
 // CHECK-DAG: %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
 // CHECK:     return %[[RESULT]]
 
+// CHECK-FUNC-LABEL: func @complex_sin(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[REAL:.*]] = complex.re %[[ARG]]
+// CHECK-FUNC-DAG:     %[[IMAG:.*]] = complex.im %[[ARG]]
+// CHECK-FUNC-DAG:     %[[HALF:.*]] = arith.constant 5.000000e-01 : f32
+// CHECK-FUNC-DAG:     %[[EXP:.*]] = math.exp %[[IMAG]] : f32
+// XXX: If ComplexToStandard runs first, the order of the operands are inversed,
+//      so we leave some leeway for the matching...
+// CHECK-FUNC-DAG:     %[[HALF_EXP:.*]] = arith.mulf %{{.*}}, %{{.*}}
+// CHECK-FUNC-DAG:     %[[HALF_REXP:.*]] = arith.divf %[[HALF]], %[[EXP]]
+// CHECK-FUNC-DAG:     %[[SIN:.*]] = math.sin %[[REAL]] : f32
+// CHECK-FUNC-DAG:     %[[COS:.*]] = math.cos %[[REAL]] : f32
+// CHECK-FUNC-DAG:     %[[EXP_SUM:.*]] = arith.addf %[[HALF_EXP]], %[[HALF_REXP]]
+// CHECK-FUNC-DAG:     %[[RESULT_REAL:.*]] = arith.mulf %[[EXP_SUM]], %[[SIN]]
+// CHECK-FUNC-DAG:     %[[EXP_DIFF:.*]] = arith.subf %[[HALF_EXP]], %[[HALF_REXP]]
+// CHECK-FUNC-DAG:     %[[RESULT_IMAG:.*]] = arith.mulf %[[EXP_DIFF]], %[[COS]]
+// CHECK-FUNC-DAG:     %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_RE:.*]] = complex.re %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IM:.*]] = complex.im %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         return %[[RESULT_RE]], %[[RESULT_IM]] : f32, f32
 // -----
 
 // CHECK-LABEL: func @complex_sign
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_sign(%arg: complex<f32>) -> complex<f32> {
   %sign = complex.sign %arg: complex<f32>
   return %sign : complex<f32>
 }

 // CHECK: %[[SQ_NORM:.*]] = arith.addf %[[SQR_REAL]], %[[SQR_IMAG]] : f32
 // CHECK: %[[NORM:.*]] = math.sqrt %[[SQ_NORM]] : f32
 // CHECK: %[[REAL_SIGN:.*]] = arith.divf %[[REAL]], %[[NORM]] : f32
 // CHECK: %[[IMAG_SIGN:.*]] = arith.divf %[[IMAG]], %[[NORM]] : f32
 // CHECK: %[[SIGN:.*]] = complex.create %[[REAL_SIGN]], %[[IMAG_SIGN]] : complex<f32>
 // CHECK: %[[RESULT:.*]] = arith.select %[[IS_ZERO]], %[[ARG]], %[[SIGN]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_sign(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[ZERO:.*]] = arith.constant 0.000000e+00 : f32
+// CHECK-FUNC-DAG:     %[[REAL_IS_ZERO:.*]] = arith.cmpf oeq, %[[REAL]], %[[ZERO]] : f32
+// CHECK-FUNC-DAG:     %[[IMAG_IS_ZERO:.*]] = arith.cmpf oeq, %[[IMAG]], %[[ZERO]] : f32
+// CHECK-FUNC-DAG:     %[[IS_ZERO:.*]] = arith.andi %[[REAL_IS_ZERO]], %[[IMAG_IS_ZERO]] : i1
+// CHECK-FUNC-DAG:     %[[REAL2:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[IMAG2:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[SQR_REAL:.*]] = arith.mulf %[[REAL2]], %[[REAL2]] : f32
+// CHECK-FUNC-DAG:     %[[SQR_IMAG:.*]] = arith.mulf %[[IMAG2]], %[[IMAG2]] : f32
+// CHECK-FUNC-DAG:     %[[SQ_NORM:.*]] = arith.addf %[[SQR_REAL]], %[[SQR_IMAG]] : f32
+// CHECK-FUNC-DAG:     %[[NORM:.*]] = math.sqrt %[[SQ_NORM]] : f32
+// CHECK-FUNC-DAG:     %[[REAL_SIGN:.*]] = arith.divf %[[REAL]], %[[NORM]] : f32
+// CHECK-FUNC-DAG:     %[[IMAG_SIGN:.*]] = arith.divf %[[IMAG]], %[[NORM]] : f32
+// CHECK-FUNC-DAG:     %[[SIGN:.*]] = complex.create %[[REAL_SIGN]], %[[IMAG_SIGN]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[RESULT:.*]] = arith.select %[[IS_ZERO]], %[[ARG]], %[[SIGN]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_RE:.*]] = complex.re %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IM:.*]] = complex.im %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         return %[[RESULT_RE]], %[[RESULT_IM]] : f32, f32
+
 // -----
 
 // CHECK-LABEL: func @complex_sub
 // CHECK-SAME: (%[[LHS:.*]]: complex<f32>, %[[RHS:.*]]: complex<f32>)
 func.func @complex_sub(%lhs: complex<f32>, %rhs: complex<f32>) -> complex<f32> {
   %sub = complex.sub %lhs, %rhs: complex<f32>
   return %sub : complex<f32>
 }
 // CHECK: %[[REAL_LHS:.*]] = complex.re %[[LHS]] : complex<f32>
 // CHECK: %[[REAL_RHS:.*]] = complex.re %[[RHS]] : complex<f32>
 // CHECK: %[[RESULT_REAL:.*]] = arith.subf %[[REAL_LHS]], %[[REAL_RHS]] : f32
 // CHECK: %[[IMAG_LHS:.*]] = complex.im %[[LHS]] : complex<f32>
 // CHECK: %[[IMAG_RHS:.*]] = complex.im %[[RHS]] : complex<f32>
 // CHECK: %[[RESULT_IMAG:.*]] = arith.subf %[[IMAG_LHS]], %[[IMAG_RHS]] : f32
 // CHECK: %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_sub(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG2:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG3:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[RHS:.*]] = complex.create %[[ARG2]], %[[ARG3]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[LHS:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC:         %[[REAL_LHS:.*]] = complex.re %[[LHS]] : complex<f32>
+// CHECK-FUNC:         %[[REAL_RHS:.*]] = complex.re %[[RHS]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_REAL:.*]] = arith.subf %[[REAL_LHS]], %[[REAL_RHS]] : f32
+// CHECK-FUNC:         %[[IMAG_LHS:.*]] = complex.im %[[LHS]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG_RHS:.*]] = complex.im %[[RHS]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IMAG:.*]] = arith.subf %[[IMAG_LHS]], %[[IMAG_RHS]] : f32
+// CHECK-FUNC:         %[[RESULT:.*]] = complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_RE:.*]] = complex.re %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IM:.*]] = complex.im %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         return %[[RESULT_RE]], %[[RESULT_IM]] : f32, f32
+
 // -----
 
 // CHECK-LABEL: func @complex_tan
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_tan(%arg: complex<f32>) -> complex<f32> {
   %tan = complex.tan %arg: complex<f32>
   return %tan : complex<f32>
 }

 // CHECK: %[[RESULT_REAL_IS_NAN:.*]] = arith.cmpf uno, %[[RESULT_REAL]], %[[ZERO]] : f32
 // CHECK: %[[RESULT_IMAG_IS_NAN:.*]] = arith.cmpf uno, %[[RESULT_IMAG]], %[[ZERO]] : f32
 // CHECK: %[[RESULT_IS_NAN:.*]] = arith.andi %[[RESULT_REAL_IS_NAN]], %[[RESULT_IMAG_IS_NAN]] : i1
 // CHECK: %[[RESULT_REAL_WITH_SPECIAL_CASES:.*]] = arith.select %[[RESULT_IS_NAN]], %[[RESULT_REAL_SPECIAL_CASE_1]], %[[RESULT_REAL]] : f32
 // CHECK: %[[RESULT_IMAG_WITH_SPECIAL_CASES:.*]] = arith.select %[[RESULT_IS_NAN]], %[[RESULT_IMAG_SPECIAL_CASE_1]], %[[RESULT_IMAG]] : f32
 // CHECK: %[[RESULT:.*]] = complex.create %[[RESULT_REAL_WITH_SPECIAL_CASES]], %[[RESULT_IMAG_WITH_SPECIAL_CASES]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_tan(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
 // -----
 
 // CHECK-LABEL: func @complex_tanh
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_tanh(%arg: complex<f32>) -> complex<f32> {
   %tanh = complex.tanh %arg: complex<f32>
   return %tanh : complex<f32>
 }
 // CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
 // CHECK: %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
 // CHECK: %[[TANH_A:.*]] = math.tanh %[[REAL]] : f32
 // CHECK: %[[COS_B:.*]] = math.cos %[[IMAG]] : f32
 // CHECK: %[[SIN_B:.*]] = math.sin %[[IMAG]] : f32
 // CHECK: %[[TAN_B:.*]] = arith.divf %[[SIN_B]], %[[COS_B]] : f32
 // CHECK: %[[NUM:.*]] = complex.create %[[TANH_A]], %[[TAN_B]] : complex<f32>
 // CHECK: %[[ONE:.*]] = arith.constant 1.000000e+00 : f32
 // CHECK: %[[MUL:.*]] = arith.mulf %[[TANH_A]], %[[TAN_B]] : f32
 // CHECK: %[[DENOM:.*]] = complex.create %[[ONE]], %[[MUL]] : complex<f32>
 
+// CHECK-FUNC-LABEL: func @complex_tanh(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC:         %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+
 // -----
 
 // CHECK-LABEL: func @complex_sqrt
 func.func @complex_sqrt(%arg: complex<f32>) -> complex<f32> {
   %sqrt = complex.sqrt %arg : complex<f32>
   return %sqrt : complex<f32>
 }
 
+// CHECK-FUNC-LABEL: func @complex_sqrt(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC:         %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+
 // -----
 
 // CHECK-LABEL: func @complex_conj
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_conj(%arg: complex<f32>) -> complex<f32> {
   %conj = complex.conj %arg: complex<f32>
   return %conj : complex<f32>
 }
 // CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
 // CHECK: %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
 // CHECK: %[[NEG_IMAG:.*]] = arith.negf %[[IMAG]] : f32
 // CHECK: %[[RESULT:.*]] = complex.create %[[REAL]], %[[NEG_IMAG]] : complex<f32>
 // CHECK: return %[[RESULT]] : complex<f32>
 
+
+// CHECK-FUNC-LABEL: func @complex_conj(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+// CHECK-FUNC:         %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
+// CHECK-FUNC:         %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
+// CHECK-FUNC:         %[[NEG_IMAG:.*]] = arith.negf %[[IMAG]] : f32
+// CHECK-FUNC:         %[[RESULT:.*]] = complex.create %[[REAL]], %[[NEG_IMAG]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_RE:.*]] = complex.re %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         %[[RESULT_IM:.*]] = complex.im %[[RESULT]] : complex<f32>
+// CHECK-FUNC:         return %[[RESULT_RE]], %[[RESULT_IM]] : f32, f32
+
 // -----
 
 // CHECK-LABEL:   func.func @complex_pow
 func.func @complex_pow(%lhs: complex<f32>,
                          %rhs: complex<f32>) -> complex<f32> {
   %pow = complex.pow %lhs, %rhs : complex<f32>
   return %pow : complex<f32>
 }
 
+// CHECK-FUNC-LABEL: func @complex_pow(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG2:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG3:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[RHS:.*]] = complex.create %[[ARG2]], %[[ARG3]] : complex<f32>
+// CHECK-FUNC-DAG:     %[[LHS:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+
 // -----
 
 // CHECK-LABEL:   func.func @complex_rsqrt
 func.func @complex_rsqrt(%arg: complex<f32>) -> complex<f32> {
   %rsqrt = complex.rsqrt %arg : complex<f32>
   return %rsqrt : complex<f32>
 }
 
+// CHECK-FUNC-LABEL: func @complex_rsqrt(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> (f32, f32)
+// CHECK-FUNC-DAG:     %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>
+
 // -----
 
 // CHECK-LABEL:   func.func @complex_angle
 // CHECK-SAME: %[[ARG:.*]]: complex<f32>
 func.func @complex_angle(%arg: complex<f32>) -> f32 {
   %angle = complex.angle %arg : complex<f32>
   return %angle : f32
 }
 // CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
 // CHECK: %[[IMAG:.*]] = complex.im %[[ARG]] : complex<f32>
 // CHECK: %[[RESULT:.*]] = math.atan2 %[[IMAG]], %[[REAL]] : f32
 // CHECK: return %[[RESULT]] : f32
+
+// CHECK-FUNC-LABEL: func @complex_angle(
+// CHECK-FUNC-SAME:      %[[ARG0:[^:]*]]: f32,
+// CHECK-FUNC-SAME:      %[[ARG1:[^:]*]]: f32) -> f32
+// CHECK-FUNC:         %[[ARG:.*]] = complex.create %[[ARG0]], %[[ARG1]] : complex<f32>

mlir/test/lib/Conversion/OneToNTypeConversion/CMakeLists.txt

 add_mlir_library(MLIRTestOneToNTypeConversionPass
   OneToNTypeConversion.cpp
   OneToNTypeConversionFunc.cpp
   TestOneToNTypeConversionPass.cpp
 
   EXCLUDE_FROM_LIBMLIR
 
   LINK_LIBS PUBLIC
+  MLIRComplexDialect
   MLIRFuncDialect
   MLIRIR
   MLIRTestDialect
   MLIRTransformUtils
  )
 
 target_include_directories(MLIRTestOneToNTypeConversionPass
   PRIVATE
   ${CMAKE_CURRENT_SOURCE_DIR}/../../Dialect/Test
   ${CMAKE_CURRENT_BINARY_DIR}/../../Dialect/Test
   )

mlir/test/lib/Conversion/OneToNTypeConversion/TestOneToNTypeConversionPass.cpp

 //===- TestOneToNTypeConversion.cpp - Test 1:N type conversion utils ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "OneToNTypeConversion.h"
 #include "OneToNTypeConversionFunc.h"
 #include "TestDialect.h"
+#include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// Test pass that exercises the (poor-man's) 1:N type conversion mechanisms
 /// from this folder by converting built-in tuples to the elements they consist
 /// of as well as some dummy ops operating on these tuples.
if (auto nestedTupleType = elementType.dyn_cast<TupleType>()) {
       elements.push_back(*inputIt++);
     }
   }
 
   // Assemble the tuple from the elements.
   return builder.create<::test::MakeTupleOp>(loc, resultType, elements);
 }
 
+static std::optional<Value> buildCreateComplexOp(OpBuilder &builder,
+                                                 ComplexType resultType,
+                                                 ValueRange inputs,
+                                                 Location loc) {
+  assert(inputs.size() == 2 && "expected two inputs to create complex number");
+  Value re = inputs[0];
+  Value im = inputs[1];
+  return builder.create<complex::CreateOp>(loc, resultType, re, im);
+}
+
+static std::optional<SmallVector<Value>>
+buildComplexReImOps(OpBuilder &builder, TypeRange resultTypes, Value input,
+                    Location loc) {
+  auto re = builder.create<complex::ReOp>(loc, input);
+  auto im = builder.create<complex::ImOp>(loc, input);
+  SmallVector<Value> resultValues = {re, im};
+  return resultValues;
+}
+
 void TestOneToNTypeConversionPass::runOnOperation() {
   ModuleOp module = getOperation();
   auto *context = &getContext();
 
   // Assemble type converter.
   OneToNTypeConverter typeConverter;
-
   typeConverter.addConversion([](Type type) { return type; });
+
+  // Type conversion and materializations for tuples.
   typeConverter.addConversion(
       [](TupleType tupleType, SmallVectorImpl<Type> &types) {
         tupleType.getFlattenedTypes(types);
         return success();
       });
 
   typeConverter.addArgumentMaterialization(buildMakeTupleOp);
   typeConverter.addSourceMaterialization(buildMakeTupleOp);
   typeConverter.addTargetMaterialization(buildGetTupleElementOps);
 
+  // Type conversion and materializations for complex.
+  typeConverter.addConversion(
+      [](ComplexType complexType, SmallVectorImpl<Type> &types) {
+        Type elementType = complexType.getElementType();
+        types.append(2, elementType); // re and im
+        return success();
+      });
+
+  typeConverter.addArgumentMaterialization(buildCreateComplexOp);
+  typeConverter.addSourceMaterialization(buildCreateComplexOp);
+  typeConverter.addTargetMaterialization(buildComplexReImOps);
+
   // Assemble patterns.
   RewritePatternSet patterns(context);
   if (convertTupleOps)
     populateDecomposeTuplesTestPatterns(typeConverter, patterns);
   if (convertFuncOps)
     populateFuncTypeConversionPatterns(typeConverter, patterns);
 
   // Run conversion.
   if (failed(applyOneToNConversion(module, typeConverter, std::move(patterns))))
     return signalPassFailure();
 }