[flang] Lower power operations

[clementval]

Summary

Lower the power operation for real, integer
and complex.

The power operation is lowered to library calls.

This patch is part of the upstreaming effort from fir-dev branch.

Depends on D120403

[rovka]

Shouldn't you also have tests for real :: x, y, z and real(8) :: x, y, z? You don't seem to be covering llvm.pow.f32 and llvm.pow.f64. Also, what happens when you mix real and real(8) base and exponents?

flang/include/flang/Lower/IntrinsicCall.h

87

[clementval]

Rebase + add tests

flang/include/flang/Lower/IntrinsicCall.h

 /// Return how argument \p argName should be lowered given the rules for the
 /// intrinsic function. The argument names are the one defined by the standard.
 ArgLoweringRule lowerIntrinsicArgumentAs(mlir::Location,
                                          const IntrinsicArgumentLoweringRules &,
                                          llvm::StringRef argName);
 
 /// Return place-holder for absent intrinsic arguments.
 fir::ExtendedValue getAbsentIntrinsicArgument();
+
+//===----------------------------------------------------------------------===//
+// Direct access to intrinsics that may be used by lowering outside
+// of intrinsic call lowering.
+//===----------------------------------------------------------------------===//
+
+/// Generate power function x**y with the given expected
+/// result type.
+mlir::Value genPow(fir::FirOpBuilder &, mlir::Location, mlir::Type resultType,
+                   mlir::Value x, mlir::Value y);
+
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_INTRINSICCALL_H

flang/lib/Lower/ConvertExpr.cpp

#define GENBIN(GenBinEvOp, GenBinTyCat, GenBinFirOp)                           \
   GENBIN(Multiply, Complex, fir::MulcOp)
   GENBIN(Divide, Integer, mlir::arith::DivSIOp)
   GENBIN(Divide, Real, mlir::arith::DivFOp)
   GENBIN(Divide, Complex, fir::DivcOp)
 
   template <Fortran::common::TypeCategory TC, int KIND>
   ExtValue genval(
       const Fortran::evaluate::Power<Fortran::evaluate::Type<TC, KIND>> &op) {
-    TODO(getLoc(), "genval Power");
+    mlir::Type ty = converter.genType(TC, KIND);
+    mlir::Value lhs = genunbox(op.left());
+    mlir::Value rhs = genunbox(op.right());
+    return Fortran::lower::genPow(builder, getLoc(), ty, lhs, rhs);
   }
 
   template <Fortran::common::TypeCategory TC, int KIND>
   ExtValue genval(
       const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<TC, KIND>>
           &op) {
-    TODO(getLoc(), "genval RealToInt");
+    mlir::Type ty = converter.genType(TC, KIND);
+    mlir::Value lhs = genunbox(op.left());
+    mlir::Value rhs = genunbox(op.right());
+    return Fortran::lower::genPow(builder, getLoc(), ty, lhs, rhs);
   }
 
   template <int KIND>
   ExtValue genval(const Fortran::evaluate::ComplexConstructor<KIND> &op) {
     mlir::Value realPartValue = genunbox(op.left());
     return fir::factory::Complex{builder, getLoc()}.createComplex(
         KIND, realPartValue, genunbox(op.right()));
   }

flang/lib/Lower/IntrinsicCall.cpp

static const IntrinsicHandler *findIntrinsicHandler(llvm::StringRef name) {
   return result != std::end(handlers) && result->name == name ? result
                                                               : nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Math runtime description and matching utility
 //===----------------------------------------------------------------------===//
 
+/// Command line option to modify math runtime version used to implement
+/// intrinsics.
+enum MathRuntimeVersion { fastVersion, llvmOnly };
+llvm::cl::opt<MathRuntimeVersion> mathRuntimeVersion(
+    "math-runtime", llvm::cl::desc("Select math runtime version:"),
+    llvm::cl::values(
+        clEnumValN(fastVersion, "fast", "use pgmath fast runtime"),
+        clEnumValN(llvmOnly, "llvm",
+                   "only use LLVM intrinsics (may be incomplete)")),
+    llvm::cl::init(fastVersion));
+
 struct RuntimeFunction {
   // llvm::StringRef comparison operator are not constexpr, so use string_view.
   using Key = std::string_view;
   // Needed for implicit compare with keys.
   constexpr operator Key() const { return key; }
   Key key; // intrinsic name
   llvm::StringRef symbol;
   fir::runtime::FuncTypeBuilderFunc typeGenerator;
static mlir::FunctionType genF32F32FuncType(mlir::MLIRContext *context) {
   return mlir::FunctionType::get(context, {t}, {t});
 }
 
 static mlir::FunctionType genF64F64FuncType(mlir::MLIRContext *context) {
   auto t = mlir::FloatType::getF64(context);
   return mlir::FunctionType::get(context, {t}, {t});
 }
 
+static mlir::FunctionType genF32F32F32FuncType(mlir::MLIRContext *context) {
+  auto t = mlir::FloatType::getF32(context);
+  return mlir::FunctionType::get(context, {t, t}, {t});
+}
+
+static mlir::FunctionType genF64F64F64FuncType(mlir::MLIRContext *context) {
+  auto t = mlir::FloatType::getF64(context);
+  return mlir::FunctionType::get(context, {t, t}, {t});
+}
+
 // TODO : Fill-up this table with more intrinsic.
 // Note: These are also defined as operations in LLVM dialect. See if this
 // can be use and has advantages.
 static constexpr RuntimeFunction llvmIntrinsics[] = {
     {"abs", "llvm.fabs.f32", genF32F32FuncType},
     {"abs", "llvm.fabs.f64", genF64F64FuncType},
+    {"pow", "llvm.pow.f32", genF32F32F32FuncType},
+    {"pow", "llvm.pow.f64", genF64F64F64FuncType},
 };
 
 // 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
static mlir::FuncOp getRuntimeFunction(mlir::Location loc,
                                        llvm::StringRef name,
                                        mlir::FunctionType funcType) {
   const RuntimeFunction *bestNearMatch = nullptr;
   FunctionDistance bestMatchDistance{};
   mlir::FuncOp match;
   using RtMap = Fortran::common::StaticMultimapView<RuntimeFunction>;
   static constexpr RtMap pgmathF(pgmathFast);
   static_assert(pgmathF.Verify() && "map must be sorted");
+  if (mathRuntimeVersion == fastVersion) {
     match = searchFunctionInLibrary(loc, builder, pgmathF, name, funcType,
                                     &bestNearMatch, bestMatchDistance);
+  } else {
+    assert(mathRuntimeVersion == llvmOnly && "unknown math runtime");
+  }
   if (match)
     return match;
 
   // Go through llvm intrinsics if not exact match in libpgmath or if
   // mathRuntimeVersion == llvmOnly
   static constexpr RtMap llvmIntr(llvmIntrinsics);
   static_assert(llvmIntr.Verify() && "map must be sorted");
   if (mlir::FuncOp exactMatch =

 fir::ExtendedValue
 Fortran::lower::genIntrinsicCall(fir::FirOpBuilder &builder, mlir::Location loc,
                                  llvm::StringRef name,
                                  llvm::Optional<mlir::Type> resultType,
                                  llvm::ArrayRef<fir::ExtendedValue> args) {
   return IntrinsicLibrary{builder, loc}.genIntrinsicCall(name, resultType,
                                                          args);
 }
+
+mlir::Value Fortran::lower::genPow(fir::FirOpBuilder &builder,
+                                   mlir::Location loc, mlir::Type type,
+                                   mlir::Value x, mlir::Value y) {
+  return IntrinsicLibrary{builder, loc}.genRuntimeCall("pow", type, {x, y});
+}

flang/test/Lower/llvm-math.f90

+! RUN: bbc -emit-fir %s -o - --math-runtime=llvm | FileCheck %s
+
+      SUBROUTINE POW_WRAPPER(IN, IN2, OUT)
+      DOUBLE PRECISION IN, IN2
+      OUT = IN ** IN2
+      RETURN
+      END
+      
+! CHECK-LABEL: func @_QPpow_wrapper(
+! CHECK-SAME: %{{.*}}: !fir.ref<f64>{{.*}}, %{{.*}}: !fir.ref<f64>{{.*}}, %{{.*}}: !fir.ref<f32>{{.*}}) {
+! CHECK-NEXT:   %0 = fir.load %arg0 : !fir.ref<f64>
+! CHECK-NEXT:   %1 = fir.load %arg1 : !fir.ref<f64>
+! CHECK-NEXT:   %2 = fir.call @llvm.pow.f64(%0, %1) : (f64, f64) -> f64
+
+      SUBROUTINE POWF_WRAPPER(IN, IN2, OUT)
+      REAL IN, IN2
+      OUT = IN ** IN2
+      RETURN
+      END
+
+! CHECK-LABEL: func @_QPpowf_wrapper(
+! CHECK-SAME: %{{.*}}: !fir.ref<f32>{{.*}}, %{{.*}}: !fir.ref<f32>{{.*}}, %{{.*}}: !fir.ref<f32>{{.*}}) {
+! CHECK-NEXT:   %0 = fir.load %arg0 : !fir.ref<f32>
+! CHECK-NEXT:   %1 = fir.load %arg1 : !fir.ref<f32>
+! CHECK-NEXT:   %2 = fir.call @llvm.pow.f32(%0, %1) : (f32, f32) -> f32

flang/test/Lower/power-operator.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+! 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 @__fs_powi_1
+end subroutine
+
+! CHECK-LABEL: pow_r4_r4
+subroutine pow_r4_r4(x, y, z)
+  real :: x, z, y
+  z = x ** y
+  ! CHECK: call @__fs_pow_1
+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
+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 @__fd_powi_1
+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
+end subroutine
+
+! CHECK-LABEL: pow_r8_r8
+subroutine pow_r8_r8(x, y, z)
+  real(8) :: x, z, y
+  z = x ** y
+  ! CHECK: call @__fd_pow_1
+end subroutine
+
+! CHECK-LABEL: pow_r4_r8
+subroutine pow_r4_r8(x, y, z)
+  real(4) :: x
+  real(8) :: z, y
+  z = x ** y
+  ! CHECK: %{{.*}} = fir.convert %{{.*}} : (f32) -> f64
+  ! CHECK: call @__fd_pow_1
+end subroutine
+
+! CHECK-LABEL: pow_i4_i4
+subroutine pow_i4_i4(x, y, z)
+  integer(4) :: x, y, z
+  z = x ** y
+  ! CHECK: call @__mth_i_ipowi
+end subroutine
+
+! CHECK-LABEL: pow_i8_i8
+subroutine pow_i8_i8(x, y, z)
+  integer(8) :: x, y, z
+  z = x ** y
+  ! CHECK: call @__mth_i_kpowk
+end subroutine
+
+! CHECK-LABEL: pow_c4_i4
+subroutine pow_c4_i4(x, y, z)
+  complex :: x, z
+  integer :: y
+  z = x ** y
+  ! CHECK: call @__fc_powi_1
+end subroutine
+
+! CHECK-LABEL: pow_c4_i8
+subroutine pow_c4_i8(x, y, z)
+  complex :: x, z
+  integer(8) :: y
+  z = x ** y
+  ! CHECK: call @__fc_powk_1
+end subroutine
+
+! CHECK-LABEL: pow_c8_i4
+subroutine pow_c8_i4(x, y, z)
+  complex(8) :: x, z
+  integer :: y
+  z = x ** y
+  ! CHECK: call @__fz_powi_1
+end subroutine
+
+! 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