[flang] Use libm over pgmath for complex number intrinsics

[DavidTruby]

Summary

This patch changes the handling of complex number intrinsics that
have C libm equivalents to call into those instead of calling the
external pgmath library.

Currently complex numbers to integer powers are excluded as libm
has no powi equivalent function.

[vzakhari]

Mostly looks good to me. And thank you for doing this!

I have minor concern about abs and conjg: it probably does not make sense to add entries that cannot be triggered.
Can you please also add LIT tests for entries that are not covered by existing tests (e.g. acos*, asin*)?

flang/lib/Lower/IntrinsicCall.cpp

1312

This is a no-op change, since IntrinsicLibrary::genAbs() lowers abs for complex into a call to libm's hypot.

1366

Same here because of IntrinsicLibrary::genConjg().

[DavidTruby]

Thanks for the review!
Why do we call hypot instead of cabs already? Wouldn't it be better to use the direct libm function?

[jeanPerier]

In D134655#3816025, @DavidTruby wrote:

Thanks for the review!
Why do we call hypot instead of cabs already? Wouldn't it be better to use the direct libm function?

No deep reason. I used hypot because we already needed it to implement HYPOT, so it avoided adding and maintaining another runtime entry point. But I am not particularly attached to using one or the other (it may have consequences in LLVM, I have not tested). I agree with Slava though that the entries should only be added if you modify the related code to trigger them.

Otherwise LGTM.

[DavidTruby]

Changed lowering of abs to use cabs instead of direct calls to hypot.
Added missing tests.

[DavidTruby]

I've changed the abs lowering to go direct to cabs as I think this will make experimenting with/switching to the MLIR complex dialect simpler in future

[jeanPerier]

LGTM, thanks

[vzakhari]

Thanks!

flang/lib/Lower/IntrinsicCall.cpp

 }
 
 template <int Bits>
 static mlir::FunctionType genIntIntIntFuncType(mlir::MLIRContext *context) {
   auto itype = mlir::IntegerType::get(context, Bits);
   return mlir::FunctionType::get(context, {itype, itype}, {itype});
 }
 
+template <int Kind>
+static mlir::FunctionType
+genComplexComplexFuncType(mlir::MLIRContext *context) {
+  auto ctype = fir::ComplexType::get(context, Kind);
+  return mlir::FunctionType::get(context, {ctype}, {ctype});
+}
+
+template <int Kind>
+static mlir::FunctionType
+genComplexComplexComplexFuncType(mlir::MLIRContext *context) {
+  auto ctype = fir::ComplexType::get(context, Kind);
+  return mlir::FunctionType::get(context, {ctype, ctype}, {ctype});
+}
+
+static mlir::FunctionType genF32ComplexFuncType(mlir::MLIRContext *context) {
+  auto ctype = fir::ComplexType::get(context, 4);
+  auto ftype = mlir::FloatType::getF32(context);
+  return mlir::FunctionType::get(context, {ctype}, {ftype});
+}
+
+static mlir::FunctionType genF64ComplexFuncType(mlir::MLIRContext *context) {
+  auto ctype = fir::ComplexType::get(context, 8);
+  auto ftype = mlir::FloatType::getF64(context);
+  return mlir::FunctionType::get(context, {ctype}, {ftype});
+}
+
 /// Callback type for generating lowering for a math operation.
 using MathGeneratorTy = mlir::Value (*)(fir::FirOpBuilder &, mlir::Location,
                                         llvm::StringRef, mlir::FunctionType,
                                         llvm::ArrayRef<mlir::Value>);
 
 struct MathOperation {
   // llvm::StringRef comparison operator are not constexpr, so use string_view.
   using Key = std::string_view;

 /// TODO: support remaining Fortran math intrinsics.
 ///       See https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gfortran/\
 ///       Intrinsic-Procedures.html for a reference.
 static constexpr MathOperation mathOperations[] = {
     {"abs", "fabsf", genF32F32FuncType, genMathOp<mlir::math::AbsFOp>},
     {"abs", "fabs", genF64F64FuncType, genMathOp<mlir::math::AbsFOp>},
     {"abs", "llvm.fabs.f128", genF128F128FuncType,
      genMathOp<mlir::math::AbsFOp>},
+    {"abs", "cabsf", genF32ComplexFuncType, genLibCall},
+    {"abs", "cabs", genF64ComplexFuncType, genLibCall},
     {"acos", "acosf", genF32F32FuncType, genLibCall},
     {"acos", "acos", genF64F64FuncType, genLibCall},
+    {"acos", "cacosf", genComplexComplexFuncType<4>, genLibCall},
+    {"acos", "cacos", genComplexComplexFuncType<8>, genLibCall},
     {"acosh", "acoshf", genF32F32FuncType, genLibCall},
     {"acosh", "acosh", genF64F64FuncType, genLibCall},
+    {"acosh", "cacoshf", genComplexComplexFuncType<4>, genLibCall},
+    {"acosh", "cacosh", genComplexComplexFuncType<8>, genLibCall},
     // llvm.trunc behaves the same way as libm's trunc.
     {"aint", "llvm.trunc.f32", genF32F32FuncType, genLibCall},
     {"aint", "llvm.trunc.f64", genF64F64FuncType, genLibCall},
     {"aint", "llvm.trunc.f80", genF80F80FuncType, genLibCall},
     // llvm.round behaves the same way as libm's round.
     {"anint", "llvm.round.f32", genF32F32FuncType,
      genMathOp<mlir::LLVM::RoundOp>},
     {"anint", "llvm.round.f64", genF64F64FuncType,
      genMathOp<mlir::LLVM::RoundOp>},
     {"anint", "llvm.round.f80", genF80F80FuncType,
      genMathOp<mlir::LLVM::RoundOp>},
     {"asin", "asinf", genF32F32FuncType, genLibCall},
     {"asin", "asin", genF64F64FuncType, genLibCall},
+    {"asin", "casinf", genComplexComplexFuncType<4>, genLibCall},
+    {"asin", "casin", genComplexComplexFuncType<8>, genLibCall},
     {"asinh", "asinhf", genF32F32FuncType, genLibCall},
     {"asinh", "asinh", genF64F64FuncType, genLibCall},
+    {"asinh", "casinhf", genComplexComplexFuncType<4>, genLibCall},
+    {"asinh", "casinh", genComplexComplexFuncType<8>, genLibCall},
     {"atan", "atanf", genF32F32FuncType, genMathOp<mlir::math::AtanOp>},
     {"atan", "atan", genF64F64FuncType, genMathOp<mlir::math::AtanOp>},
+    {"atan", "catanf", genComplexComplexFuncType<4>, genLibCall},
+    {"atan", "catan", genComplexComplexFuncType<8>, genLibCall},
     {"atan2", "atan2f", genF32F32F32FuncType, genMathOp<mlir::math::Atan2Op>},
     {"atan2", "atan2", genF64F64F64FuncType, genMathOp<mlir::math::Atan2Op>},
     {"atanh", "atanhf", genF32F32FuncType, genLibCall},
     {"atanh", "atanh", genF64F64FuncType, genLibCall},
+    {"atanh", "catanhf", genComplexComplexFuncType<4>, genLibCall},
+    {"atanh", "catanh", genComplexComplexFuncType<8>, genLibCall},
     {"bessel_j0", "j0f", genF32F32FuncType, genLibCall},
     {"bessel_j0", "j0", genF64F64FuncType, genLibCall},
     {"bessel_j1", "j1f", genF32F32FuncType, genLibCall},
     {"bessel_j1", "j1", genF64F64FuncType, genLibCall},
     {"bessel_jn", "jnf", genF32IntF32FuncType<32>, genLibCall},
     {"bessel_jn", "jn", genF64IntF64FuncType<32>, genLibCall},
     {"bessel_y0", "y0f", genF32F32FuncType, genLibCall},
     {"bessel_y0", "y0", genF64F64FuncType, genLibCall},
     {"bessel_y1", "y1f", genF32F32FuncType, genLibCall},
     {"bessel_y1", "y1", genF64F64FuncType, genLibCall},
     {"bessel_yn", "ynf", genF32IntF32FuncType<32>, genLibCall},
     {"bessel_yn", "yn", genF64IntF64FuncType<32>, genLibCall},
     // math::CeilOp returns a real, while Fortran CEILING returns integer.
     {"ceil", "ceilf", genF32F32FuncType, genMathOp<mlir::math::CeilOp>},
     {"ceil", "ceil", genF64F64FuncType, genMathOp<mlir::math::CeilOp>},
     {"cos", "cosf", genF32F32FuncType, genMathOp<mlir::math::CosOp>},
     {"cos", "cos", genF64F64FuncType, genMathOp<mlir::math::CosOp>},
+    {"cos", "ccosf", genComplexComplexFuncType<4>, genLibCall},
+    {"cos", "ccos", genComplexComplexFuncType<8>, genLibCall},
     {"cosh", "coshf", genF32F32FuncType, genLibCall},
     {"cosh", "cosh", genF64F64FuncType, genLibCall},
+    {"cosh", "ccoshf", genComplexComplexFuncType<4>, genLibCall},
+    {"cosh", "ccosh", genComplexComplexFuncType<8>, genLibCall},
     {"erf", "erff", genF32F32FuncType, genMathOp<mlir::math::ErfOp>},
     {"erf", "erf", genF64F64FuncType, genMathOp<mlir::math::ErfOp>},
     {"erfc", "erfcf", genF32F32FuncType, genLibCall},
     {"erfc", "erfc", genF64F64FuncType, genLibCall},
     {"exp", "expf", genF32F32FuncType, genMathOp<mlir::math::ExpOp>},
     {"exp", "exp", genF64F64FuncType, genMathOp<mlir::math::ExpOp>},
+    {"exp", "cexpf", genComplexComplexFuncType<4>, genLibCall},
+    {"exp", "cexp", genComplexComplexFuncType<8>, genLibCall},
     // math::FloorOp returns a real, while Fortran FLOOR returns integer.
     {"floor", "floorf", genF32F32FuncType, genMathOp<mlir::math::FloorOp>},
     {"floor", "floor", genF64F64FuncType, genMathOp<mlir::math::FloorOp>},
     {"gamma", "tgammaf", genF32F32FuncType, genLibCall},
     {"gamma", "tgamma", genF64F64FuncType, genLibCall},
     {"hypot", "hypotf", genF32F32F32FuncType, genLibCall},
     {"hypot", "hypot", genF64F64F64FuncType, genLibCall},
     {"log", "logf", genF32F32FuncType, genMathOp<mlir::math::LogOp>},
     {"log", "log", genF64F64FuncType, genMathOp<mlir::math::LogOp>},
+    {"log", "clogf", genComplexComplexFuncType<4>, genLibCall},
+    {"log", "clog", genComplexComplexFuncType<8>, genLibCall},
     {"log10", "log10f", genF32F32FuncType, genMathOp<mlir::math::Log10Op>},
     {"log10", "log10", genF64F64FuncType, genMathOp<mlir::math::Log10Op>},
     {"log_gamma", "lgammaf", genF32F32FuncType, genLibCall},
     {"log_gamma", "lgamma", genF64F64FuncType, genLibCall},
     // llvm.lround behaves the same way as libm's lround.
     {"nint", "llvm.lround.i64.f64", genIntF64FuncType<64>, genLibCall},
     {"nint", "llvm.lround.i64.f32", genIntF32FuncType<64>, genLibCall},
     {"nint", "llvm.lround.i32.f64", genIntF64FuncType<32>, genLibCall},
     {"nint", "llvm.lround.i32.f32", genIntF32FuncType<32>, genLibCall},
     {"pow", {}, genIntIntIntFuncType<8>, genMathOp<mlir::math::IPowIOp>},
     {"pow", {}, genIntIntIntFuncType<16>, genMathOp<mlir::math::IPowIOp>},
     {"pow", {}, genIntIntIntFuncType<32>, genMathOp<mlir::math::IPowIOp>},
     {"pow", {}, genIntIntIntFuncType<64>, genMathOp<mlir::math::IPowIOp>},
     {"pow", "powf", genF32F32F32FuncType, genMathOp<mlir::math::PowFOp>},
     {"pow", "pow", genF64F64F64FuncType, genMathOp<mlir::math::PowFOp>},
+    {"pow", "cpowf", genComplexComplexComplexFuncType<4>, genLibCall},
+    {"pow", "cpow", genComplexComplexComplexFuncType<8>, genLibCall},
     // TODO: add PowIOp in math and complex dialects.
     {"pow", "llvm.powi.f32.i32", genF32F32IntFuncType<32>, genLibCall},
     {"pow", "llvm.powi.f64.i32", genF64F64IntFuncType<32>, genLibCall},
     {"sign", "copysignf", genF32F32F32FuncType,
      genMathOp<mlir::math::CopySignOp>},
     {"sign", "copysign", genF64F64F64FuncType,
      genMathOp<mlir::math::CopySignOp>},
     {"sign", "copysignl", genF80F80F80FuncType,
      genMathOp<mlir::math::CopySignOp>},
     {"sign", "llvm.copysign.f128", genF128F128F128FuncType,
      genMathOp<mlir::math::CopySignOp>},
     {"sin", "sinf", genF32F32FuncType, genMathOp<mlir::math::SinOp>},
     {"sin", "sin", genF64F64FuncType, genMathOp<mlir::math::SinOp>},
+    {"sin", "csinf", genComplexComplexFuncType<4>, genLibCall},
+    {"sin", "csin", genComplexComplexFuncType<8>, genLibCall},
     {"sinh", "sinhf", genF32F32FuncType, genLibCall},
     {"sinh", "sinh", genF64F64FuncType, genLibCall},
+    {"sinh", "csinhf", genComplexComplexFuncType<4>, genLibCall},
+    {"sinh", "csinh", genComplexComplexFuncType<8>, genLibCall},
     {"sqrt", "sqrtf", genF32F32FuncType, genMathOp<mlir::math::SqrtOp>},
     {"sqrt", "sqrt", genF64F64FuncType, genMathOp<mlir::math::SqrtOp>},
+    {"sqrt", "csqrtf", genComplexComplexFuncType<4>, genLibCall},
+    {"sqrt", "csqrt", genComplexComplexFuncType<8>, genLibCall},
     {"tan", "tanf", genF32F32FuncType, genMathOp<mlir::math::TanOp>},
     {"tan", "tan", genF64F64FuncType, genMathOp<mlir::math::TanOp>},
+    {"tan", "ctanf", genComplexComplexFuncType<4>, genLibCall},
+    {"tan", "ctan", genComplexComplexFuncType<8>, genLibCall},
     {"tanh", "tanhf", genF32F32FuncType, genMathOp<mlir::math::TanhOp>},
     {"tanh", "tanh", genF64F64FuncType, genMathOp<mlir::math::TanhOp>},
+    {"tanh", "ctanhf", genComplexComplexFuncType<4>, genLibCall},
+    {"tanh", "ctanh", genComplexComplexFuncType<8>, genLibCall},
 };
 
 // This helper class computes a "distance" between two function types.
 // The distance measures how many narrowing conversions of actual arguments
 // and result of "from" must be made in order to use "to" instead of "from".
 // For instance, the distance between ACOS(REAL(10)) and ACOS(REAL(8)) is
 // greater than the one between ACOS(REAL(10)) and ACOS(REAL(16)). This means
 // if no implementation of ACOS(REAL(10)) is available, it is better to use

 }
 
 // ABS
 mlir::Value IntrinsicLibrary::genAbs(mlir::Type resultType,
                                      llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() == 1);
   mlir::Value arg = args[0];
   mlir::Type type = arg.getType();
-  if (fir::isa_real(type)) {
+  if (fir::isa_real(type) || fir::isa_complex(type)) {
     // Runtime call to fp abs. An alternative would be to use mlir
     // math::AbsFOp but it does not support all fir floating point types.
     return genRuntimeCall("abs", resultType, args);
   }
   if (auto intType = type.dyn_cast<mlir::IntegerType>()) {
     // At the time of this implementation there is no abs op in mlir.
     // So, implement abs here without branching.
     mlir::Value shift =
         builder.createIntegerConstant(loc, intType, intType.getWidth() - 1);
     auto mask = builder.create<mlir::arith::ShRSIOp>(loc, arg, shift);
     auto xored = builder.create<mlir::arith::XOrIOp>(loc, arg, mask);
     return builder.create<mlir::arith::SubIOp>(loc, xored, mask);
   }
-  if (fir::isa_complex(type)) {
-    // Use HYPOT to fulfill the no underflow/overflow requirement.
-    auto parts = fir::factory::Complex{builder, loc}.extractParts(arg);
-    llvm::SmallVector<mlir::Value> args = {parts.first, parts.second};
-    return genRuntimeCall("hypot", resultType, args);
-  }
   llvm_unreachable("unexpected type in ABS argument");
 }
 
 // ADJUSTL & ADJUSTR
 template <void (*CallRuntime)(fir::FirOpBuilder &, mlir::Location loc,
                               mlir::Value, mlir::Value)>
 fir::ExtendedValue
 IntrinsicLibrary::genAdjustRtCall(mlir::Type resultType,

flang/test/Lower/Intrinsics/abs.f90

! CHECK: return
   real(kind=16) :: a, b
   b = abs(a)
 end subroutine
 
 ! CHECK-LABEL: func @_QPabs_testzr(
 ! CHECK-SAME:  %[[VAL_0:.*]]: !fir.ref<!fir.complex<4>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<f32>{{.*}}) {
 subroutine abs_testzr(a, b)
 ! CHECK:  %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.complex<4>>
-! CHECK:  %[[VAL_3:.*]] = fir.extract_value %[[VAL_2]], [0 : index] : (!fir.complex<4>) -> f32
-! CHECK:  %[[VAL_4:.*]] = fir.extract_value %[[VAL_2]], [1 : index] : (!fir.complex<4>) -> f32
-! CHECK:  %[[VAL_5:.*]] = fir.call @hypotf(%[[VAL_3]], %[[VAL_4]]) : (f32, f32) -> f32
-! CHECK:  fir.store %[[VAL_5]] to %[[VAL_1]] : !fir.ref<f32>
+! CHECK:  %[[VAL_3:.*]] = fir.call @cabsf(%[[VAL_2]]) : (!fir.complex<4>) -> f32
+! CHECK:  fir.store %[[VAL_3]] to %[[VAL_1]] : !fir.ref<f32>
 ! CHECK:  return
   complex :: a
   real :: b
   b = abs(a)
 end subroutine abs_testzr
 
 ! CHECK-LABEL: func @_QPabs_testzd(
 ! CHECK-SAME:  %[[VAL_0:.*]]: !fir.ref<!fir.complex<8>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<f64>{{.*}}) {
 subroutine abs_testzd(a, b)
 ! CHECK:  %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.complex<8>>
-! CHECK:  %[[VAL_3:.*]] = fir.extract_value %[[VAL_2]], [0 : index] : (!fir.complex<8>) -> f64
-! CHECK:  %[[VAL_4:.*]] = fir.extract_value %[[VAL_2]], [1 : index] : (!fir.complex<8>) -> f64
-! CHECK:  %[[VAL_5:.*]] = fir.call @hypot(%[[VAL_3]], %[[VAL_4]]) : (f64, f64) -> f64
-! CHECK:  fir.store %[[VAL_5]] to %[[VAL_1]] : !fir.ref<f64>
+! CHECK:  %[[VAL_3:.*]] = fir.call @cabs(%[[VAL_2]]) : (!fir.complex<8>) -> f64
+! CHECK:  fir.store %[[VAL_3]] to %[[VAL_1]] : !fir.ref<f64>
 ! CHECK:  return
   complex(kind=8) :: a
   real(kind=8) :: b
   b = abs(a)
 end subroutine abs_testzd

flang/test/Lower/Intrinsics/acos.f90

 
 function test_real8(x)
   real(8) :: x, test_real8
   test_real8 = acos(x)
 end function
 
 ! ALL-LABEL: @_QPtest_real8
 ! ALL: {{%[A-Za-z0-9._]+}} = fir.call @acos({{%[A-Za-z0-9._]+}}) : (f64) -> f64
+
+function test_complex4(x)
+  complex :: x, test_complex4
+  test_complex4 = acos(x)
+end function
+
+! ALL-LABEL: @_QPtest_complex4
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @cacosf({{%[A-Za-z0-9._]+}}) : (!fir.complex<4>) -> !fir.complex<4>
+
+function test_complex8(x)
+  complex(kind=8) :: x, test_complex8
+  test_complex8 = acos(x)
+end function
+
+! ALL-LABEL: @_QPtest_complex8
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @cacos({{%[A-Za-z0-9._]+}}) : (!fir.complex<8>) -> !fir.complex<8>
+

flang/test/Lower/Intrinsics/acosh.f90

 
 function test_real8(x)
   real(8) :: x, test_real8
   test_real8 = acosh(x)
 end function
 
 ! ALL-LABEL: @_QPtest_real8
 ! ALL: {{%[A-Za-z0-9._]+}} = fir.call @acosh({{%[A-Za-z0-9._]+}}) : (f64) -> f64
+
+function test_complex4(x)
+  complex :: x, test_complex4
+  test_complex4 = acosh(x)
+end function
+
+! ALL-LABEL: @_QPtest_complex4
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @cacoshf({{%[A-Za-z0-9._]+}}) : (!fir.complex<4>) -> !fir.complex<4>
+
+function test_complex8(x)
+  complex(kind=8) :: x, test_complex8
+  test_complex8 = acosh(x)
+end function
+
+! ALL-LABEL: @_QPtest_complex8
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @cacosh({{%[A-Za-z0-9._]+}}) : (!fir.complex<8>) -> !fir.complex<8>
+

flang/test/Lower/Intrinsics/asin.f90

 
 function test_real8(x)
   real(8) :: x, test_real8
   test_real8 = asin(x)
 end function
 
 ! ALL-LABEL: @_QPtest_real8
 ! ALL: {{%[A-Za-z0-9._]+}} = fir.call @asin({{%[A-Za-z0-9._]+}}) : (f64) -> f64
+
+function test_complex4(x)
+  complex :: x, test_complex4
+  test_complex4 = asin(x)
+end function
+
+! ALL-LABEL: @_QPtest_complex4
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @casinf({{%[A-Za-z0-9._]+}}) : (!fir.complex<4>) -> !fir.complex<4>
+
+function test_complex8(x)
+  complex(kind=8) :: x, test_complex8
+  test_complex8 = asin(x)
+end function
+
+! ALL-LABEL: @_QPtest_complex8
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @casin({{%[A-Za-z0-9._]+}}) : (!fir.complex<8>) -> !fir.complex<8>
+

flang/test/Lower/Intrinsics/asinh.f90

 
 function test_real8(x)
   real(8) :: x, test_real8
   test_real8 = asinh(x)
 end function
 
 ! ALL-LABEL: @_QPtest_real8
 ! ALL: {{%[A-Za-z0-9._]+}} = fir.call @asinh({{%[A-Za-z0-9._]+}}) : (f64) -> f64
+
+function test_complex4(x)
+  complex :: x, test_complex4
+  test_complex4 = asinh(x)
+end function
+
+! ALL-LABEL: @_QPtest_complex4
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @casinhf({{%[A-Za-z0-9._]+}}) : (!fir.complex<4>) -> !fir.complex<4>
+
+function test_complex8(x)
+  complex(kind=8) :: x, test_complex8
+  test_complex8 = asinh(x)
+end function
+
+! ALL-LABEL: @_QPtest_complex8
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @casinh({{%[A-Za-z0-9._]+}}) : (!fir.complex<8>) -> !fir.complex<8>
+

flang/test/Lower/Intrinsics/atanh.f90

 
 function test_real8(x)
   real(8) :: x, test_real8
   test_real8 = atanh(x)
 end function
 
 ! ALL-LABEL: @_QPtest_real8
 ! ALL: {{%[A-Za-z0-9._]+}} = fir.call @atanh({{%[A-Za-z0-9._]+}}) : (f64) -> f64
+
+function test_complex4(x)
+  complex :: x, test_complex4
+  test_complex4 = atanh(x)
+end function
+
+! ALL-LABEL: @_QPtest_complex4
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @catanhf({{%[A-Za-z0-9._]+}}) : (!fir.complex<4>) -> !fir.complex<4>
+
+function test_complex8(x)
+  complex(kind=8) :: x, test_real8
+  test_complex8 = atanh(x)
+end function
+
+! ALL-LABEL: @_QPtest_complex8
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @catanh({{%[A-Za-z0-9._]+}}) : (!fir.complex<8>) -> !fir.complex<8>

flang/test/Lower/Intrinsics/exp.f90

 
 ! CHECK-LABEL: private @fir.exp.f64.f64
 ! CHECK-SAME: (%[[ARG64_OUTLINE:.*]]: f64) -> f64
 ! CHECK: %[[RESULT64_OUTLINE:.*]] = math.exp %[[ARG64_OUTLINE]] : f64
 ! CHECK: return %[[RESULT64_OUTLINE]] : f64
 
 ! CHECK-LABEL: private @fir.exp.z4.z4
 ! CHECK-SAME: (%[[ARG32_OUTLINE]]: !fir.complex<4>) -> !fir.complex<4>
-! CHECK: %[[RESULT32_OUTLINE]] = fir.call @__fc_exp_1(%[[ARG32_OUTLINE]]) : (!fir.complex<4>) -> !fir.complex<4>
+! CHECK: %[[RESULT32_OUTLINE]] = fir.call @cexpf(%[[ARG32_OUTLINE]]) : (!fir.complex<4>) -> !fir.complex<4>
 ! CHECK: return %[[RESULT32_OUTLINE]] : !fir.complex<4>
 
 ! CHECK-LABEL: private @fir.exp.z8.z8
 ! CHECK-SAME: (%[[ARG64_OUTLINE]]: !fir.complex<8>) -> !fir.complex<8>
-! CHECK: %[[RESULT64_OUTLINE]] = fir.call @__fz_exp_1(%[[ARG64_OUTLINE]]) : (!fir.complex<8>) -> !fir.complex<8>
+! CHECK: %[[RESULT64_OUTLINE]] = fir.call @cexp(%[[ARG64_OUTLINE]]) : (!fir.complex<8>) -> !fir.complex<8>
 ! CHECK: return %[[RESULT64_OUTLINE]] : !fir.complex<8>

flang/test/Lower/Intrinsics/log.f90

 
 ! CHECK-LABEL: private @fir.log.f64.f64
 ! CHECK-SAME: (%[[ARG64_OUTLINE:.*]]: f64) -> f64
 ! CHECK: %[[RESULT64_OUTLINE:.*]] = math.log %[[ARG64_OUTLINE]] : f64
 ! CHECK: return %[[RESULT64_OUTLINE]] : f64
 
 ! CHECK-LABEL: private @fir.log.z4.z4
 ! CHECK-SAME: (%[[ARG32_OUTLINE]]: !fir.complex<4>) -> !fir.complex<4>
-! CHECK: %[[RESULT32_OUTLINE]] = fir.call @__fc_log_1(%[[ARG32_OUTLINE]]) : (!fir.complex<4>) -> !fir.complex<4>
+! CHECK: %[[RESULT32_OUTLINE]] = fir.call @clogf(%[[ARG32_OUTLINE]]) : (!fir.complex<4>) -> !fir.complex<4>
 ! CHECK: return %[[RESULT32_OUTLINE]] : !fir.complex<4>
 
 ! CHECK-LABEL: private @fir.log.z8.z8
 ! CHECK-SAME: (%[[ARG64_OUTLINE]]: !fir.complex<8>) -> !fir.complex<8>
-! CHECK: %[[RESULT64_OUTLINE]] = fir.call @__fz_log_1(%[[ARG64_OUTLINE]]) : (!fir.complex<8>) -> !fir.complex<8>
+! CHECK: %[[RESULT64_OUTLINE]] = fir.call @clog(%[[ARG64_OUTLINE]]) : (!fir.complex<8>) -> !fir.complex<8>
 ! CHECK: return %[[RESULT64_OUTLINE]] : !fir.complex<8>
 
 ! CHECK-LABEL: private @fir.log10.f32.f32
 ! CHECK-SAME: (%[[ARG32_OUTLINE:.*]]: f32) -> f32
 ! CHECK: %[[RESULT32_OUTLINE:.*]] = math.log10 %[[ARG32_OUTLINE]] : f32
 ! CHECK: return %[[RESULT32_OUTLINE]] : f32
 
 ! CHECK-LABEL: private @fir.log10.f64.f64
 ! CHECK-SAME: (%[[ARG64_OUTLINE:.*]]: f64) -> f64
 ! CHECK: %[[RESULT64_OUTLINE:.*]] = math.log10 %[[ARG64_OUTLINE]] : f64
 ! CHECK: return %[[RESULT64_OUTLINE]] : f64

flang/test/Lower/Intrinsics/missing-math-runtime.f90

 ! There is no quad math runtime available in lowering
 ! for now. Test that the TODO are emitted correctly.
 ! RUN: bbc -emit-fir %s -o /dev/null 2>&1 | FileCheck %s
 
  complex(16) :: a
  real(16) :: b
-! CHECK: not yet implemented: no math runtime available for 'hypot(f128, f128)'
+! CHECK: not yet implemented: no math runtime available for 'abs(!fir.complex<16>)'
  b = abs(a)
 end
 

flang/test/Lower/math-lowering.f90

 ! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @llvm.fabs.f128({{%[A-Za-z0-9._]+}}) : (f128) -> f128
 
 function test_complex4(c)
   complex(4) :: c, test_complex4
   test_complex4 = abs(c)
 end function
 
 ! ALL-LABEL: @_QPtest_complex4
-! ALL: {{%[A-Za-z0-9._]+}} = fir.call @hypotf({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) : (f32, f32) -> f32
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @cabsf({{%[A-Za-z0-9._]+}}) : (!fir.complex<4>) -> f32
 
 function test_complex8(c)
   complex(8) :: c, test_complex8
   test_complex8 = abs(c)
 end function
 
 ! ALL-LABEL: @_QPtest_complex8
-! ALL: {{%[A-Za-z0-9._]+}} = fir.call @hypot({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) : (f64, f64) -> f64
+! ALL: {{%[A-Za-z0-9._]+}} = fir.call @cabs({{%[A-Za-z0-9._]+}}) : (!fir.complex<8>) -> f64
 
 //--- aint.f90
 ! RUN: bbc -emit-fir %t/aint.f90 -o - --math-runtime=fast | FileCheck --check-prefixes=ALL %t/aint.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=fast %t/aint.f90 -o - | FileCheck --check-prefixes=ALL %t/aint.f90
 ! RUN: bbc -emit-fir %t/aint.f90 -o - --math-runtime=relaxed | FileCheck --check-prefixes=ALL %t/aint.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=relaxed %t/aint.f90 -o - | FileCheck --check-prefixes=ALL %t/aint.f90
 ! RUN: bbc -emit-fir %t/aint.f90 -o - --math-runtime=precise | FileCheck --check-prefixes=ALL %t/aint.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=precise %t/aint.f90 -o - | FileCheck --check-prefixes=ALL %t/aint.f90

flang/test/Lower/power-operator.f90

 
 ! CHECK-LABEL: pow_c8_i8
 subroutine pow_c8_i8(x, y, z)
   complex(8) :: x, z
   integer(8) :: y
   z = x ** y
   ! CHECK: call @__fz_powk_1
 end subroutine
+
+! CHECK-LABEL: pow_c4_c4
+subroutine pow_c4_c4(x, y, z)
+  complex :: x, y, z
+  z = x ** y
+  ! CHECK: call @cpowf
+end subroutine
+
+! CHECK-LABEL: pow_c8_c8
+subroutine pow_c8_c8(x, y, z)
+  complex(8) :: x, y, z
+  z = x ** y
+  ! CHECK: call @cpow
+end subroutine
+

flang/test/Lower/sqrt.f90

 
 ! CHECK-LABEL: @fir.sqrt.f32.f32
 ! CHECK: math.sqrt %{{.*}} : f32
 
 ! CHECK-LABEL: @fir.sqrt.f64.f64
 ! CHECK: math.sqrt %{{.*}} : f64
 
 ! CHECK-LABEL: func private @fir.sqrt.z4.z4
-! CHECK: fir.call {{.*}}fc_sqrt
+! CHECK: fir.call @csqrtf
 
 ! CHECK-LABEL: @fir.sqrt.z8.z8
-! CHECK: fir.call {{.*}}fz_sqrt
+! CHECK: fir.call @csqrt

flang/test/Lower/trigonometric-intrinsics.f90

 ! RUN: bbc -emit-fir -outline-intrinsics %s -o - | FileCheck %s
 ! RUN: %flang_fc1 -emit-fir -mllvm -outline-intrinsics %s -o - | FileCheck %s
 
+! CHECK-LABEL: tan_testr
+subroutine tan_testr(a, b)
+  real :: a, b
+! CHECK: fir.call @fir.tan.f32.f32
+  b = tan(a)
+end subroutine
+
+! CHECK-LABEL: tan_testd
+subroutine tan_testd(a, b)
+  real(kind=8) :: a, b
+! CHECK: fir.call @fir.tan.f64.f64
+  b = tan(a)
+end subroutine
+
+! CHECK-LABEL: tan_testc
+subroutine tan_testc(z)
+  complex :: z
+! CHECK: fir.call @fir.tan.z4.z4
+  z = tan(z)
+end subroutine
+
+! CHECK-LABEL: tan_testcd
+subroutine tan_testcd(z)
+  complex(kind=8) :: z
+! CHECK: fir.call @fir.tan.z8.z8
+  z = tan(z)
+end subroutine
+
 ! CHECK-LABEL: atan_testr
 subroutine atan_testr(a, b)
   real :: a, b
 ! CHECK: fir.call @fir.atan.f32.f32
   b = atan(a)
 end subroutine
 
 ! CHECK-LABEL: atan_testd

 
 ! CHECK-LABEL: sinh_testcd
 subroutine sinh_testcd(z)
   complex(kind=8) :: z
 ! CHECK: fir.call @fir.sinh.z8.z8
   z = sinh(z)
 end subroutine
 
+! CHECK-LABEL: @fir.tan.f32.f32
+! CHECK: math.tan %{{.*}} : f32
+
+! CHECK-LABEL: @fir.tan.f64.f64
+! CHECK: math.tan %{{.*}} : f64
+
+! CHECK-LABEL: @fir.tan.z4.z4
+! CHECK: fir.call @ctanf
+
+! CHECK-LABEL: @fir.tan.z8.z8
+! CHECK: fir.call @ctan
+
 ! CHECK-LABEL: @fir.atan.f32.f32
 ! CHECK: math.atan %{{.*}} : f32
 
 ! CHECK-LABEL: @fir.atan.f64.f64
 ! CHECK: math.atan %{{.*}} : f64
 
 ! CHECK-LABEL: @fir.atan.z4.z4
-! CHECK: fir.call {{.*}}atan
+! CHECK: fir.call @catanf
 
 ! CHECK-LABEL: @fir.atan.z8.z8
-! CHECK: fir.call {{.*}}atan
+! CHECK: fir.call @catan
 
 ! CHECK-LABEL: @fir.cos.f32.f32
 ! CHECK: math.cos %{{.*}} : f32
 
 ! CHECK-LABEL: @fir.cos.f64.f64
 ! CHECK: math.cos %{{.*}} : f64
 
 ! CHECK-LABEL: @fir.cos.z4.z4
-! CHECK: fir.call {{.*}}cos
+! CHECK: fir.call @ccosf
 
 ! CHECK-LABEL: @fir.cos.z8.z8
-! CHECK: fir.call {{.*}}cos
+! CHECK: fir.call @ccos
 
 ! CHECK-LABEL: @fir.cosh.f32.f32
 ! CHECK: fir.call {{.*}}cosh
 
 ! CHECK-LABEL: @fir.cosh.f64.f64
 ! CHECK: fir.call {{.*}}cosh
 
 ! CHECK-LABEL: @fir.cosh.z4.z4
-! CHECK: fir.call {{.*}}cosh
+! CHECK: fir.call @ccoshf
 
 ! CHECK-LABEL: @fir.cosh.z8.z8
-! CHECK: fir.call {{.*}}cosh
+! CHECK: fir.call @ccosh
 
 ! CHECK-LABEL: @fir.sin.f32.f32
 ! CHECK: math.sin %{{.*}} : f32
 
 ! CHECK-LABEL: @fir.sin.f64.f64
 ! CHECK: math.sin %{{.*}} : f64
 
 ! CHECK-LABEL: @fir.sin.z4.z4
-! CHECK: fir.call {{.*}}sin
+! CHECK: fir.call @csinf
 
 ! CHECK-LABEL: @fir.sin.z8.z8
-! CHECK: fir.call {{.*}}sin
+! CHECK: fir.call @csin
 
 ! CHECK-LABEL: @fir.sinh.f32.f32
 ! CHECK: fir.call {{.*}}sinh
 
 ! CHECK-LABEL: @fir.sinh.f64.f64
 ! CHECK: fir.call {{.*}}sinh
 
 ! CHECK-LABEL: @fir.sinh.z4.z4
-! CHECK: fir.call {{.*}}sinh
+! CHECK: fir.call @csinhf
 
 ! CHECK-LABEL: @fir.sinh.z8.z8
-! CHECK: fir.call {{.*}}sinh
+! CHECK: fir.call @csinh