[flang] Lower exponentiation without using pgmath.

[vzakhari]

Summary

Exponentiation is lowered to either math::FPowI or Fortran runtime
call (in case of --math-runtime=precise).

MathToFuncs convertor will convert math::FPowI operations with
exponent width >32 to calls of outlined implementations and otherwise
will leave the operation to MathToLLVM convertor.

Depends on D129812, D139804

[jeanPerier]

Looks great, thanks !

[vzakhari]

Thank you for the review, Jean!

This change-set fixes an issue in the unit test.

[vzakhari]

Fixed #if checks for real10/real16.

[vzakhari]

Conflict resolution for CodeGen.cpp due to changes in D139804.

flang/include/flang/Runtime/numeric.h

 CppTypeFor<TypeCategory::Real, 10> RTNAME(Spacing10)(
     CppTypeFor<TypeCategory::Real, 10>);
 #endif
 #if LDBL_MANT_DIG == 113 || HAS_FLOAT128
 CppTypeFor<TypeCategory::Real, 16> RTNAME(Spacing16)(
     CppTypeFor<TypeCategory::Real, 16>);
 #endif
 
+CppTypeFor<TypeCategory::Real, 4> RTNAME(FPow4i)(
+    CppTypeFor<TypeCategory::Real, 4> b,
+    CppTypeFor<TypeCategory::Integer, 4> e);
+CppTypeFor<TypeCategory::Real, 8> RTNAME(FPow8i)(
+    CppTypeFor<TypeCategory::Real, 8> b,
+    CppTypeFor<TypeCategory::Integer, 4> e);
+#if LDBL_MANT_DIG == 64
+CppTypeFor<TypeCategory::Real, 10> RTNAME(FPow10i)(
+    CppTypeFor<TypeCategory::Real, 10> b,
+    CppTypeFor<TypeCategory::Integer, 4> e);
+#endif
+#if LDBL_MANT_DIG == 113 || HAS_FLOAT128
+CppTypeFor<TypeCategory::Real, 16> RTNAME(FPow16i)(
+    CppTypeFor<TypeCategory::Real, 16> b,
+    CppTypeFor<TypeCategory::Integer, 4> e);
+#endif
+
+CppTypeFor<TypeCategory::Real, 4> RTNAME(FPow4k)(
+    CppTypeFor<TypeCategory::Real, 4> b,
+    CppTypeFor<TypeCategory::Integer, 8> e);
+CppTypeFor<TypeCategory::Real, 8> RTNAME(FPow8k)(
+    CppTypeFor<TypeCategory::Real, 8> b,
+    CppTypeFor<TypeCategory::Integer, 8> e);
+#if LDBL_MANT_DIG == 64
+CppTypeFor<TypeCategory::Real, 10> RTNAME(FPow10k)(
+    CppTypeFor<TypeCategory::Real, 10> b,
+    CppTypeFor<TypeCategory::Integer, 8> e);
+#endif
+#if LDBL_MANT_DIG == 113 || HAS_FLOAT128
+CppTypeFor<TypeCategory::Real, 16> RTNAME(FPow16k)(
+    CppTypeFor<TypeCategory::Real, 16> b,
+    CppTypeFor<TypeCategory::Integer, 8> e);
+#endif
+
 } // extern "C"
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_NUMERIC_H_

flang/lib/Lower/IntrinsicCall.cpp

static constexpr MathOperation mathOperations[] = {
     {"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>,
      genComplexMathOp<mlir::complex::PowOp>},
     {"pow", "cpow", genComplexComplexComplexFuncType<8>,
      genComplexMathOp<mlir::complex::PowOp>},
-    // TODO: add PowIOp in math and complex dialects.
-    {"pow", "llvm.powi.f32.i32", genF32F32IntFuncType<32>, genLibCall},
-    {"pow", "llvm.powi.f64.i32", genF64F64IntFuncType<32>, genLibCall},
+    {"pow", RTNAME_STRING(FPow4i), genF32F32IntFuncType<32>,
+     genMathOp<mlir::math::FPowIOp>},
+    {"pow", RTNAME_STRING(FPow8i), genF64F64IntFuncType<32>,
+     genMathOp<mlir::math::FPowIOp>},
+    {"pow", RTNAME_STRING(FPow4k), genF32F32IntFuncType<64>,
+     genMathOp<mlir::math::FPowIOp>},
+    {"pow", RTNAME_STRING(FPow8k), genF64F64IntFuncType<64>,
+     genMathOp<mlir::math::FPowIOp>},
     {"pow", RTNAME_STRING(cpowi), genComplexComplexIntFuncType<4, 32>,
      genLibCall},
     {"pow", RTNAME_STRING(zpowi), genComplexComplexIntFuncType<8, 32>,
      genLibCall},
     {"pow", RTNAME_STRING(cpowk), genComplexComplexIntFuncType<4, 64>,
      genLibCall},
     {"pow", RTNAME_STRING(zpowk), genComplexComplexIntFuncType<8, 64>,
      genLibCall},

flang/lib/Optimizer/CodeGen/CodeGen.cpp

void runOnOperation() override final {
     // Run dynamic pass pipeline for converting Math dialect
     // operations into other dialects (llvm, func, etc.).
     // Some conversions of Math operations cannot be done
     // by just using conversion patterns. This is true for
     // conversions that affect the ModuleOp, e.g. create new
     // function operations in it. We have to run such conversions
     // as passes here.
     mlir::OpPassManager mathConvertionPM("builtin.module");
-    mathConvertionPM.addPass(mlir::createConvertMathToFuncs());
+
+    // Convert math::FPowI operations to inline implementation
+    // only if the exponent's width is greater than 32, otherwise,
+    // it will be lowered to LLVM intrinsic operation by a later conversion.
+    mlir::ConvertMathToFuncsOptions mathToFuncsOptions{};
+    mathToFuncsOptions.minWidthOfFPowIExponent = 33;
+    mathConvertionPM.addPass(
+        mlir::createConvertMathToFuncs(mathToFuncsOptions));
     mathConvertionPM.addPass(mlir::createConvertComplexToStandardPass());
     if (mlir::failed(runPipeline(mathConvertionPM, mod)))
       return signalPassFailure();
 
     // Reconstruct binding tables for dynamic dispatch. The binding tables
     // are defined in FIR from lowering as fir.dispatch_table operation.
     // Go through each binding tables and store the procedure name
     // and binding index for later use by the fir.dispatch conversion pattern.

flang/runtime/numeric.cpp

template <int PREC, typename T> inline T Nearest(T x, bool positive) {
   if (x == 0) {
     auto least{std::numeric_limits<T>::denorm_min()};
     return positive ? least : -least;
   } else {
     return positive ? x + spacing : x - spacing;
   }
 }
 
+// Exponentiation operator for (Real ** Integer) cases (10.1.5.2.1).
+template <typename BTy, typename ETy> BTy FPowI(BTy base, ETy exp) {
+  if (exp == ETy{0})
+    return BTy{1};
+  bool isNegativePower{exp < ETy{0}};
+  bool isMinPower{exp == std::numeric_limits<ETy>::min()};
+  if (isMinPower) {
+    exp = std::numeric_limits<ETy>::max();
+  } else if (isNegativePower) {
+    exp = -exp;
+  }
+  BTy result{1};
+  BTy origBase{base};
+  while (true) {
+    if (exp & ETy{1}) {
+      result *= base;
+    }
+    exp >>= 1;
+    if (exp == ETy{0}) {
+      break;
+    }
+    base *= base;
+  }
+  if (isMinPower) {
+    result *= origBase;
+  }
+  if (isNegativePower) {
+    result = BTy{1} / result;
+  }
+  return result;
+}
+
 extern "C" {
 
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Ceiling4_1)(
     CppTypeFor<TypeCategory::Real, 4> x) {
   return Ceiling<CppTypeFor<TypeCategory::Integer, 1>>(x);
 }
 CppTypeFor<TypeCategory::Integer, 2> RTNAME(Ceiling4_2)(
     CppTypeFor<TypeCategory::Real, 4> x) {
CppTypeFor<TypeCategory::Real, 10> RTNAME(Spacing10)(
   return Spacing<64>(x);
 }
 #elif LDBL_MANT_DIG == 113
 CppTypeFor<TypeCategory::Real, 16> RTNAME(Spacing16)(
     CppTypeFor<TypeCategory::Real, 16> x) {
   return Spacing<113>(x);
 }
 #endif
+
+CppTypeFor<TypeCategory::Real, 4> RTNAME(FPow4i)(
+    CppTypeFor<TypeCategory::Real, 4> b,
+    CppTypeFor<TypeCategory::Integer, 4> e) {
+  return FPowI(b, e);
+}
+CppTypeFor<TypeCategory::Real, 8> RTNAME(FPow8i)(
+    CppTypeFor<TypeCategory::Real, 8> b,
+    CppTypeFor<TypeCategory::Integer, 4> e) {
+  return FPowI(b, e);
+}
+#if LDBL_MANT_DIG == 64
+CppTypeFor<TypeCategory::Real, 10> RTNAME(FPow10i)(
+    CppTypeFor<TypeCategory::Real, 10> b,
+    CppTypeFor<TypeCategory::Integer, 4> e) {
+  return FPowI(b, e);
+}
+#endif
+#if LDBL_MANT_DIG == 113 || HAS_FLOAT128
+CppTypeFor<TypeCategory::Real, 16> RTNAME(FPow16i)(
+    CppTypeFor<TypeCategory::Real, 16> b,
+    CppTypeFor<TypeCategory::Integer, 4> e) {
+  return FPowI(b, e);
+}
+#endif
+
+CppTypeFor<TypeCategory::Real, 4> RTNAME(FPow4k)(
+    CppTypeFor<TypeCategory::Real, 4> b,
+    CppTypeFor<TypeCategory::Integer, 8> e) {
+  return FPowI(b, e);
+}
+CppTypeFor<TypeCategory::Real, 8> RTNAME(FPow8k)(
+    CppTypeFor<TypeCategory::Real, 8> b,
+    CppTypeFor<TypeCategory::Integer, 8> e) {
+  return FPowI(b, e);
+}
+#if LDBL_MANT_DIG == 64
+CppTypeFor<TypeCategory::Real, 10> RTNAME(FPow10k)(
+    CppTypeFor<TypeCategory::Real, 10> b,
+    CppTypeFor<TypeCategory::Integer, 8> e) {
+  return FPowI(b, e);
+}
+#endif
+#if LDBL_MANT_DIG == 113 || HAS_FLOAT128
+CppTypeFor<TypeCategory::Real, 16> RTNAME(FPow16k)(
+    CppTypeFor<TypeCategory::Real, 16> b,
+    CppTypeFor<TypeCategory::Integer, 8> e) {
+  return FPowI(b, e);
+}
+#endif
 } // extern "C"
 } // namespace Fortran::runtime

flang/test/Lower/HLFIR/binary-ops.f90

subroutine real_to_int_power(x, y, z)
   integer :: z
   x = y**z
 end subroutine
 ! CHECK-LABEL: func.func @_QPreal_to_int_power(
 ! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %{{.*}}y"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
 ! CHECK:  %[[VAL_5:.*]]:2 = hlfir.declare %{{.*}}z"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 ! CHECK:  %[[VAL_6:.*]] = fir.load %[[VAL_4]]#0 : !fir.ref<f32>
 ! CHECK:  %[[VAL_7:.*]] = fir.load %[[VAL_5]]#0 : !fir.ref<i32>
-! CHECK:  %[[VAL_8:.*]] = fir.call @llvm.powi.f32.i32(%[[VAL_6]], %[[VAL_7]]) fastmath<contract> : (f32, i32) -> f32
+! CHECK:  %[[VAL_8:.*]] = math.fpowi %[[VAL_6]], %[[VAL_7]] fastmath<contract> : f32, i32
 
 subroutine complex_to_int_power(x, y, z)
   complex :: x, y
   integer :: z
   x = y**z
 end subroutine
 ! CHECK-LABEL: func.func @_QPcomplex_to_int_power(
 ! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %{{.*}}y"} : (!fir.ref<!fir.complex<4>>) -> (!fir.ref<!fir.complex<4>>, !fir.ref<!fir.complex<4>>)

flang/test/Lower/math-lowering.f90

 //--- exponentiation.f90
 ! RUN: bbc -emit-fir %t/exponentiation.f90 -o - --math-runtime=fast | FileCheck --check-prefixes=ALL,FAST %t/exponentiation.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=fast %t/exponentiation.f90 -o - | FileCheck --check-prefixes=ALL,FAST %t/exponentiation.f90
 ! RUN: bbc -emit-fir %t/exponentiation.f90 -o - --math-runtime=relaxed | FileCheck --check-prefixes=ALL,RELAXED %t/exponentiation.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=relaxed %t/exponentiation.f90 -o - | FileCheck --check-prefixes=ALL,RELAXED %t/exponentiation.f90
 ! RUN: bbc -emit-fir %t/exponentiation.f90 -o - --math-runtime=precise | FileCheck --check-prefixes=ALL,PRECISE %t/exponentiation.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=precise %t/exponentiation.f90 -o - | FileCheck --check-prefixes=ALL,PRECISE %t/exponentiation.f90
 
-function test_real4(x, y, s, i)
+function test_real4(x, y, s, i, k)
   real :: x, y, test_real4
   integer(2) :: s
   integer(4) :: i
-  test_real4 = x ** s + x ** y + x ** i
+  integer(8) :: k
+  test_real4 = x ** s + x ** y + x ** i + x ** k
 end function
 
 ! ALL-LABEL: @_QPtest_real4
 ! ALL: [[STOI:%[A-Za-z0-9._]+]] = fir.convert {{%[A-Za-z0-9._]+}} : (i16) -> i32
-! ALL: {{%[A-Za-z0-9._]+}} = fir.call @llvm.powi.f32.i32({{%[A-Za-z0-9._]+}}, [[STOI]]) {{.*}}: (f32, i32) -> f32
+! FAST: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f32, i32
+! RELAXED: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f32, i32
+! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @_FortranAFPow4i({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) {{.*}}: (f32, i32) -> f32
 ! FAST: {{%[A-Za-z0-9._]+}} = math.powf {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f32
 ! RELAXED: {{%[A-Za-z0-9._]+}} = math.powf {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f32
 ! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @powf({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) {{.*}}: (f32, f32) -> f32
-! ALL: {{%[A-Za-z0-9._]+}} = fir.call @llvm.powi.f32.i32({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) {{.*}}: (f32, i32) -> f32
+! FAST: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f32, i32
+! RELAXED: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f32, i32
+! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @_FortranAFPow4i({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) {{.*}}: (f32, i32) -> f32
+! FAST: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f32, i64
+! RELAXED: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f32, i64
+! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @_FortranAFPow4k({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) {{.*}}: (f32, i64) -> f32
 
-function test_real8(x, y, s, i)
+function test_real8(x, y, s, i, k)
   real(8) :: x, y, test_real8
   integer(2) :: s
   integer(4) :: i
-  test_real8 = x ** s + x ** y + x ** i
+  integer(8) :: k
+  test_real8 = x ** s + x ** y + x ** i + x ** k
 end function
 
 ! ALL-LABEL: @_QPtest_real8
 ! ALL: [[STOI:%[A-Za-z0-9._]+]] = fir.convert {{%[A-Za-z0-9._]+}} : (i16) -> i32
-! ALL: {{%[A-Za-z0-9._]+}} = fir.call @llvm.powi.f64.i32({{%[A-Za-z0-9._]+}}, [[STOI]]) {{.*}}: (f64, i32) -> f64
+! FAST: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f64, i32
+! RELAXED: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f64, i32
+! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @_FortranAFPow8i({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) {{.*}}: (f64, i32) -> f64
 ! FAST: {{%[A-Za-z0-9._]+}} = math.powf {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f64
 ! RELAXED: {{%[A-Za-z0-9._]+}} = math.powf {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f64
 ! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @pow({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) {{.*}}: (f64, f64) -> f64
-! ALL: {{%[A-Za-z0-9._]+}} = fir.call @llvm.powi.f64.i32({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) {{.*}}: (f64, i32) -> f64
+! FAST: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f64, i32
+! RELAXED: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f64, i32
+! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @_FortranAFPow8i({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) {{.*}}: (f64, i32) -> f64
+! FAST: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f64, i64
+! RELAXED: {{%[A-Za-z0-9._]+}} = math.fpowi {{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}} {{.*}}: f64, i64
+! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @_FortranAFPow8k({{%[A-Za-z0-9._]+}}, {{%[A-Za-z0-9._]+}}) {{.*}}: (f64, i64) -> f64
 
 //--- sign.f90
 ! RUN: bbc -emit-fir %t/sign.f90 -o - --math-runtime=fast | FileCheck --check-prefixes=ALL,FAST %t/sign.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=fast %t/sign.f90 -o - | FileCheck --check-prefixes=ALL,FAST %t/sign.f90
 ! RUN: bbc -emit-fir %t/sign.f90 -o - --math-runtime=relaxed | FileCheck --check-prefixes=ALL,RELAXED %t/sign.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=relaxed %t/sign.f90 -o - | FileCheck --check-prefixes=ALL,RELAXED %t/sign.f90
 ! RUN: bbc -emit-fir %t/sign.f90 -o - --math-runtime=precise | FileCheck --check-prefixes=ALL,PRECISE %t/sign.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=precise %t/sign.f90 -o - | FileCheck --check-prefixes=ALL,PRECISE %t/sign.f90

flang/test/Lower/power-operator.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX-FAST"
-! RUN: bbc --math-runtime=precise -emit-fir %s -o - | FileCheck %s --check-prefixes="CMPLX-PRECISE"
-! RUN: bbc --disable-mlir-complex -emit-fir %s -o - | FileCheck %s --check-prefixes="CMPLX-PRECISE"
-! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX-FAST"
-! RUN: %flang_fc1 -emit-fir -mllvm --math-runtime=precise %s -o - | FileCheck %s --check-prefixes="CMPLX-PRECISE"
-! RUN: %flang_fc1 -emit-fir -mllvm --disable-mlir-complex %s -o - | FileCheck %s --check-prefixes="CMPLX-PRECISE"
+! RUN: bbc -emit-fir %s -o - | FileCheck %s --check-prefixes="CHECK,FAST"
+! RUN: bbc --math-runtime=precise -emit-fir %s -o - | FileCheck %s --check-prefixes="PRECISE"
+! RUN: bbc --disable-mlir-complex -emit-fir %s -o - | FileCheck %s --check-prefixes="PRECISE"
+! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s --check-prefixes="CHECK,FAST"
+! RUN: %flang_fc1 -emit-fir -mllvm --math-runtime=precise %s -o - | FileCheck %s --check-prefixes="PRECISE"
+! RUN: %flang_fc1 -emit-fir -mllvm --disable-mlir-complex %s -o - | FileCheck %s --check-prefixes="PRECISE"
 
 ! Test power operation lowering
 
 ! CHECK-LABEL: pow_r4_i4
 subroutine pow_r4_i4(x, y, z)
   real :: x, z
   integer :: y
   z = x ** y
-  ! CHECK: call @llvm.powi.f32.i32
+  ! CHECK: math.fpowi {{.*}} : f32, i32
 end subroutine
 
 ! CHECK-LABEL: pow_r4_r4
 subroutine pow_r4_r4(x, y, z)
   real :: x, z, y
   z = x ** y
   ! CHECK: math.powf %{{.*}}, %{{.*}} : f32
 end subroutine
 
 ! CHECK-LABEL: pow_r4_i8
 subroutine pow_r4_i8(x, y, z)
   real :: x, z
   integer(8) :: y
   z = x ** y
-  ! CHECK: call @__fs_powk_1
+  ! CHECK: math.fpowi {{.*}} : f32, i64
 end subroutine
 
 ! CHECK-LABEL: pow_r8_i4
 subroutine pow_r8_i4(x, y, z)
   real(8) :: x, z
   integer :: y
   z = x ** y
-  ! CHECK: call @llvm.powi.f64.i32
+  ! CHECK: math.fpowi {{.*}} : f64, i32
 end subroutine
 
 ! CHECK-LABEL: pow_r8_i8
 subroutine pow_r8_i8(x, y, z)
   real(8) :: x, z
   integer(8) :: y
   z = x ** y
-  ! CHECK: call @__fd_powk_1
+  ! CHECK: math.fpowi {{.*}} : f64, i64
 end subroutine
 
 ! CHECK-LABEL: pow_r8_r8
 subroutine pow_r8_r8(x, y, z)
   real(8) :: x, z, y
   z = x ** y
   ! CHECK: math.powf %{{.*}}, %{{.*}} : f64
 end subroutine
subroutine pow_c8_i8(x, y, z)
   z = x ** y
   ! CHECK: call @_FortranAzpowk
 end subroutine
 
 ! CHECK-LABEL: pow_c4_c4
 subroutine pow_c4_c4(x, y, z)
   complex :: x, y, z
   z = x ** y
-  ! CMPLX-FAST: complex.pow %{{.*}}, %{{.*}} : complex<f32>
-  ! CMPLX-PRECISE: call @cpowf
+  ! FAST: complex.pow %{{.*}}, %{{.*}} : complex<f32>
+  ! PRECISE: call @cpowf
 end subroutine
 
 ! CHECK-LABEL: pow_c8_c8
 subroutine pow_c8_c8(x, y, z)
   complex(8) :: x, y, z
   z = x ** y
-  ! CMPLX-FAST: complex.pow %{{.*}}, %{{.*}} : complex<f64>
-  ! CMPLX-PRECISE: call @cpow
+  ! FAST: complex.pow %{{.*}}, %{{.*}} : complex<f64>
+  ! PRECISE: call @cpow
 end subroutine
 

flang/unittests/Runtime/Numeric.cpp

 TEST(Numeric, Spacing) {
   EXPECT_EQ(RTNAME(Spacing8)(Real<8>{0}), std::numeric_limits<Real<8>>::min());
   EXPECT_EQ(RTNAME(Spacing4)(Real<4>{3.0}), std::ldexp(Real<4>{1.0}, -22));
   EXPECT_TRUE(
       std::isnan(RTNAME(Spacing4)(std::numeric_limits<Real<4>>::infinity())));
   EXPECT_TRUE(
       std::isnan(RTNAME(Spacing8)(std::numeric_limits<Real<8>>::quiet_NaN())));
 }
+
+TEST(Numeric, FPowI) {
+  EXPECT_EQ(RTNAME(FPow4i)(Real<4>{0}, Int<4>{0}), Real<4>{1});
+  EXPECT_EQ(RTNAME(FPow4i)(Real<4>{0.3}, Int<4>{0}), Real<4>{1});
+  EXPECT_EQ(RTNAME(FPow4i)(Real<4>{2}, Int<4>{-1}), Real<4>{0.5});
+  EXPECT_EQ(RTNAME(FPow4i)(Real<4>{0.5}, Int<4>{-1}), Real<4>{2});
+  EXPECT_EQ(RTNAME(FPow4i)(Real<4>{-3}, Int<4>{3}), Real<4>{-27});
+  EXPECT_EQ(RTNAME(FPow4i)(Real<4>{-2}, Int<4>{-3}), Real<4>{-0.125});
+
+  EXPECT_EQ(RTNAME(FPow4k)(Real<4>{0}, Int<8>{0}), Real<4>{1});
+  EXPECT_EQ(RTNAME(FPow4k)(Real<4>{0.3}, Int<8>{0}), Real<4>{1});
+  EXPECT_EQ(RTNAME(FPow4k)(Real<4>{2}, Int<8>{-1}), Real<4>{0.5});
+  EXPECT_EQ(RTNAME(FPow4k)(Real<4>{0.5}, Int<8>{-1}), Real<4>{2});
+  EXPECT_EQ(RTNAME(FPow4k)(Real<4>{-3}, Int<8>{3}), Real<4>{-27});
+  EXPECT_EQ(RTNAME(FPow4k)(Real<4>{-2}, Int<8>{-3}), Real<4>{-0.125});
+
+  EXPECT_EQ(RTNAME(FPow8i)(Real<8>{0}, Int<4>{0}), Real<8>{1});
+  EXPECT_EQ(RTNAME(FPow8i)(Real<8>{0.3}, Int<4>{0}), Real<8>{1});
+  EXPECT_EQ(RTNAME(FPow8i)(Real<8>{2}, Int<4>{-1}), Real<8>{0.5});
+  EXPECT_EQ(RTNAME(FPow8i)(Real<8>{0.5}, Int<4>{-1}), Real<8>{2});
+  EXPECT_EQ(RTNAME(FPow8i)(Real<8>{-3}, Int<4>{3}), Real<8>{-27});
+  EXPECT_EQ(RTNAME(FPow8i)(Real<8>{-2}, Int<4>{-3}), Real<8>{-0.125});
+
+  EXPECT_EQ(RTNAME(FPow8k)(Real<8>{0}, Int<8>{0}), Real<8>{1});
+  EXPECT_EQ(RTNAME(FPow8k)(Real<8>{0.3}, Int<8>{0}), Real<8>{1});
+  EXPECT_EQ(RTNAME(FPow8k)(Real<8>{2}, Int<8>{-1}), Real<8>{0.5});
+  EXPECT_EQ(RTNAME(FPow8k)(Real<8>{0.5}, Int<8>{-1}), Real<8>{2});
+  EXPECT_EQ(RTNAME(FPow8k)(Real<8>{-3}, Int<8>{3}), Real<8>{-27});
+  EXPECT_EQ(RTNAME(FPow8k)(Real<8>{-2}, Int<8>{-3}), Real<8>{-0.125});
+
+#if LDBL_MANT_DIG == 64
+  EXPECT_EQ(RTNAME(FPow10i)(Real<10>{0}, Int<4>{0}), Real<10>{1});
+  EXPECT_EQ(RTNAME(FPow10i)(Real<10>{0.3}, Int<4>{0}), Real<10>{1});
+  EXPECT_EQ(RTNAME(FPow10i)(Real<10>{2}, Int<4>{-1}), Real<10>{0.5});
+  EXPECT_EQ(RTNAME(FPow10i)(Real<10>{0.5}, Int<4>{-1}), Real<10>{2});
+  EXPECT_EQ(RTNAME(FPow10i)(Real<10>{-3}, Int<4>{3}), Real<10>{-27});
+  EXPECT_EQ(RTNAME(FPow10i)(Real<10>{-2}, Int<4>{-3}), Real<10>{-0.125});
+
+  EXPECT_EQ(RTNAME(FPow10k)(Real<10>{0}, Int<8>{0}), Real<10>{1});
+  EXPECT_EQ(RTNAME(FPow10k)(Real<10>{0.3}, Int<8>{0}), Real<10>{1});
+  EXPECT_EQ(RTNAME(FPow10k)(Real<10>{2}, Int<8>{-1}), Real<10>{0.5});
+  EXPECT_EQ(RTNAME(FPow10k)(Real<10>{0.5}, Int<8>{-1}), Real<10>{2});
+  EXPECT_EQ(RTNAME(FPow10k)(Real<10>{-3}, Int<8>{3}), Real<10>{-27});
+  EXPECT_EQ(RTNAME(FPow10k)(Real<10>{-2}, Int<8>{-3}), Real<10>{-0.125});
+#endif
+#if LDBL_MANT_DIG == 113 || HAS_FLOAT128
+  EXPECT_EQ(RTNAME(FPow16i)(Real<16>{0}, Int<4>{0}), Real<16>{1});
+  EXPECT_EQ(RTNAME(FPow16i)(Real<16>{0.3}, Int<4>{0}), Real<16>{1});
+  EXPECT_EQ(RTNAME(FPow16i)(Real<16>{2}, Int<4>{-1}), Real<16>{0.5});
+  EXPECT_EQ(RTNAME(FPow16i)(Real<16>{0.5}, Int<4>{-1}), Real<16>{2});
+  EXPECT_EQ(RTNAME(FPow16i)(Real<16>{-3}, Int<4>{3}), Real<16>{-27});
+  EXPECT_EQ(RTNAME(FPow16i)(Real<16>{-2}, Int<4>{-3}), Real<16>{-0.125});
+
+  EXPECT_EQ(RTNAME(FPow16k)(Real<16>{0}, Int<8>{0}), Real<16>{1});
+  EXPECT_EQ(RTNAME(FPow16k)(Real<16>{0.3}, Int<8>{0}), Real<16>{1});
+  EXPECT_EQ(RTNAME(FPow16k)(Real<16>{2}, Int<8>{-1}), Real<16>{0.5});
+  EXPECT_EQ(RTNAME(FPow16k)(Real<16>{0.5}, Int<8>{-1}), Real<16>{2});
+  EXPECT_EQ(RTNAME(FPow16k)(Real<16>{-3}, Int<8>{3}), Real<16>{-27});
+  EXPECT_EQ(RTNAME(FPow16k)(Real<16>{-2}, Int<8>{-3}), Real<16>{-0.125});
+#endif
+
+  // Test some extreme values.
+  if (sizeof(double) == sizeof(std::uint64_t)) {
+    // (0x3FF0000000000001 ** -2147483648) ~ 0x3FEFFFFF00000401
+    double base;
+    *reinterpret_cast<std::uint64_t *>(&base) = 4607182418800017409ULL;
+    double result;
+    *reinterpret_cast<std::uint64_t *>(&result) = 4607182414505051137ULL;
+    EXPECT_TRUE(std::abs(RTNAME(FPow8i)(Real<8>{base},
+                             Int<4>{std::numeric_limits<Int<4>>::min()}) -
+                    Real<8>{result}) < 0.00000000001);
+
+    // (0x3FF0000000000001 ** 4294967296ULL) ~ 0x3FF00001000007FF
+    *reinterpret_cast<std::uint64_t *>(&base) = 4607182418800017409ULL;
+    *reinterpret_cast<std::uint64_t *>(&result) = 4607182423094986751ULL;
+    EXPECT_TRUE(std::abs(RTNAME(FPow8k)(Real<8>{base}, Int<8>{4294967296ULL}) -
+                    Real<8>{result}) < 0.00000000001);
+  }
+}