[flang] Add platform-specific intrinsic lowering

[rovka]

Summary

Make it possible for math operations to be lowered in different ways on
different platforms. Use single precision hypot as a case study: on
most platforms, hypot can be lowered to hypotf. However, the MSVC
runtime is lacking a hypotf function and instead uses _hypotf (*).
This patch adds a platform check based on the FIR triple (which is
either the triple in the FIR module, or the system default triple) and
uses it to decide how to lower hypot.

Fixes https://github.com/llvm/llvm-project/issues/57563

(*) More specifically, MSVC's headers define hypotf as an inline
function that just calls _hypotf. This works fine for clang, since it
will include those headers, but flang only links with the CRT so we
don't get a free ride.

[rovka]

I'm planning to add more tests (see TODO), but I thought it would be good to get some general feedback on the approach first. @Meinersbur had also suggested adding a hypotf to the runtime when compiling for Windows, but this approach seems more flexible and straightforward to me. Other opinions welcome, thanks!

flang/lib/Lower/IntrinsicCall.cpp

1248

Alternatively we could just set a default lambda that returns true, and then we wouldn't need a helper to check for nullptr. I wasn't sure if people would consider that simpler and if it's worth going through a call every time, as opposed to a nullptr check in most cases.

[jeanPerier]

I think doing this target specific dispatch in lowering is a bit early (MLIR/FIR passes relying on recognizing libm functions would also need to special case based on the target. Maybe I am wrong here though @vzakhari or @MatsPetersson may have a better view).

I would rather suggest rewriting "hypotf" to "_hypotf" in https://github.com/flang-compiler/f18-llvm-project/blob/fir-dev/flang/lib/Optimizer/CodeGen/TargetRewrite.cpp if possible, although I understand it might be easier/cleaner from an implementation point of view to do it in IntrinsicCall.cpp. The runtime solution would also sounds fine to me.

[vzakhari]

In D134860#3823506, @jeanPerier wrote:

I think doing this target specific dispatch in lowering is a bit early (MLIR/FIR passes relying on recognizing libm functions would also need to special case based on the target. Maybe I am wrong here though @vzakhari or @MatsPetersson may have a better view).

I would rather suggest rewriting "hypotf" to "_hypotf" in https://github.com/flang-compiler/f18-llvm-project/blob/fir-dev/flang/lib/Optimizer/CodeGen/TargetRewrite.cpp if possible, although I understand it might be easier/cleaner from an implementation point of view to do it in IntrinsicCall.cpp. The runtime solution would also sounds fine to me.

Yes, I think having the late rewrite is a more consistent approach. Consider cases when we generate a Math dialect operation that is then converted to a libm call - if the callee does not have "default" name of a platform, we will have the same issue, but it will have to be resolved somewhere around MathToLibm convertor. So it seems a better approach is to have a dedicated platform-specific convertor for libm calls that will be applied to MLIR regardless of where the libm calls are coming from.

[rovka]

Right, I see what you mean. I'll rework this, thanks!

flang/lib/Lower/IntrinsicCall.cpp

 #include "flang/Optimizer/Builder/Runtime/Inquiry.h"
 #include "flang/Optimizer/Builder/Runtime/Numeric.h"
 #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
 #include "flang/Optimizer/Builder/Runtime/Reduction.h"
 #include "flang/Optimizer/Builder/Runtime/Stop.h"
 #include "flang/Optimizer/Builder/Runtime/Transformational.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/FatalError.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "flang-lower-intrinsic"
 
struct MathOperation {
   llvm::StringRef runtimeFunc;
   fir::runtime::FuncTypeBuilderFunc typeGenerator;
 
   // A callback to generate FIR for the intrinsic defined by 'key'.
   // A callback may generate either dedicated MLIR operation(s) or
   // a function call to a runtime function with name defined by
   // 'runtimeFunc'.
   MathGeneratorTy funcGenerator;
+
+  // A callback that restricts this lowering only to certain triples. The
+  // callback is expected to return true if this lowering is supported for the
+  // triple that it receives as parameter.
+  // If the callback is set to `nullptr`, then this lowering is available on all
+  // platforms.
+  using PlatformAvailability = bool (*)(llvm::Triple);
+  PlatformAvailability specificTo = nullptr;
+
+  bool isAvailableFor(llvm::Triple triple) const {
+    return !specificTo || specificTo(triple);
+  }
 };
 
+static bool MSVC(llvm::Triple triple) { return triple.isOSMSVCRT(); }
+
+static bool notMSVC(llvm::Triple triple) { return !MSVC(triple); }
+
 static mlir::Value genLibCall(fir::FirOpBuilder &builder, mlir::Location loc,
                               llvm::StringRef libFuncName,
                               mlir::FunctionType libFuncType,
                               llvm::ArrayRef<mlir::Value> args) {
   LLVM_DEBUG(llvm::dbgs() << "Generating '" << libFuncName
                           << "' call with type ";
              libFuncType.dump(); llvm::dbgs() << "\n");
   mlir::func::FuncOp funcOp =
static constexpr MathOperation mathOperations[] = {
     {"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", "hypotf", genF32F32F32FuncType, genLibCall, notMSVC},
+    {"hypot", "_hypotf", genF32F32F32FuncType, genLibCall, MSVC},
     {"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},

 /// \p bestMatchDistance specifies the FunctionDistance between
 /// the requested operation and the non-exact match.
 static const MathOperation *
 searchMathOperation(fir::FirOpBuilder &builder, llvm::StringRef name,
                     mlir::FunctionType funcType,
                     const MathOperation **bestNearMatch,
                     FunctionDistance &bestMatchDistance) {
   auto range = mathOps.equal_range(name);
+  auto triple = fir::getTargetTriple(builder.getModule());
   for (auto iter = range.first; iter != range.second && iter; ++iter) {
     const auto &impl = *iter;
+
+    if (!impl.isAvailableFor(triple))
+      continue;
+
     auto implType = impl.typeGenerator(builder.getContext());
     if (funcType == implType)
       return &impl; // exact match
 
     FunctionDistance distance(funcType, implType);
     if (distance.isSmallerThan(bestMatchDistance)) {
       *bestNearMatch = &impl;
       bestMatchDistance = std::move(distance);

flang/test/Lower/Intrinsics/hypot.f90

+! RUN: %flang_fc1 -emit-fir -triple aarch64-pc-windows-msvc %s -o - | FileCheck %s -DHYPOTF=_hypotf
+! RUN: %flang_fc1 -emit-fir -triple aarch64-unknown-linux-gnu %s -o - | FileCheck %s -DHYPOTF=hypotf
+
+! Test hypot intrinsic for different real kinds
+
+! CHECK-LABEL: func @_QPhypot_testh(
+! CHECK-SAME:  %[[AREF:.*]]: !fir.ref<f16>{{.*}}, %[[BREF:.*]]: !fir.ref<f16>{{.*}}, %[[CREF:.*]]: !fir.ref<f16>{{.*}}) {
+subroutine hypot_testh(a, b, c)
+! CHECK: %[[A:.*]] = fir.load %[[AREF]] : !fir.ref<f16>
+! CHECK: %[[B:.*]] = fir.load %[[BREF]] : !fir.ref<f16>
+! CHECK: %[[A32:.*]] = fir.convert %[[A]] : (f16) -> f32
+! CHECK: %[[B32:.*]] = fir.convert %[[B]] : (f16) -> f32
+! CHECK: %[[C32:.*]] = fir.call @[[HYPOTF]](%[[A32]], %[[B32]]) : (f32, f32) -> f32
+! CHECK: %[[C:.*]] = fir.convert %[[C32]] : (f32) -> f16
+! CHECK: fir.store %[[C]] to %[[CREF]] : !fir.ref<f16>
+! CHECK: return
+  real(kind=2) :: a, b, c
+  c = hypot(a, b)
+end subroutine
+
+! CHECK-LABEL: func @_QPhypot_testb(
+! CHECK-SAME:  %[[AREF:.*]]: !fir.ref<bf16>{{.*}}, %[[BREF:.*]]: !fir.ref<bf16>{{.*}}, %[[CREF:.*]]: !fir.ref<bf16>{{.*}}) {
+subroutine hypot_testb(a, b, c)
+! CHECK: %[[A:.*]] = fir.load %[[AREF]] : !fir.ref<bf16>
+! CHECK: %[[B:.*]] = fir.load %[[BREF]] : !fir.ref<bf16>
+! CHECK: %[[A32:.*]] = fir.convert %[[A]] : (bf16) -> f32
+! CHECK: %[[B32:.*]] = fir.convert %[[B]] : (bf16) -> f32
+! CHECK: %[[C32:.*]] = fir.call @[[HYPOTF]](%[[A32]], %[[B32]]) : (f32, f32) -> f32
+! CHECK: %[[C:.*]] = fir.convert %[[C32]] : (f32) -> bf16
+! CHECK: fir.store %[[C]] to %[[CREF]] : !fir.ref<bf16>
+! CHECK: return
+  real(kind=3) :: a, b, c
+  c = hypot(a, b)
+end subroutine
+
+! CHECK-LABEL: func @_QPhypot_testr(
+! CHECK-SAME:  %[[AREF:.*]]: !fir.ref<f32>{{.*}}, %[[BREF:.*]]: !fir.ref<f32>{{.*}}, %[[CREF:.*]]: !fir.ref<f32>{{.*}}) {
+subroutine hypot_testr(a, b, c)
+! CHECK: %[[A:.*]] = fir.load %[[AREF]] : !fir.ref<f32>
+! CHECK: %[[B:.*]] = fir.load %[[BREF]] : !fir.ref<f32>
+! CHECK: %[[C:.*]] = fir.call @[[HYPOTF]](%[[A]], %[[B]]) : (f32, f32) -> f32
+! CHECK: fir.store %[[C]] to %[[CREF]] : !fir.ref<f32>
+! CHECK: return
+  real :: a, b, c
+  c = hypot(a, b)
+end subroutine
+
+! CHECK-LABEL: func @_QPhypot_testd(
+! CHECK-SAME:  %[[AREF:.*]]: !fir.ref<f64>{{.*}}, %[[BREF:.*]]: !fir.ref<f64>{{.*}}, %[[CREF:.*]]: !fir.ref<f64>{{.*}}) {
+subroutine hypot_testd(a, b, c)
+! CHECK: %[[A:.*]] = fir.load %[[AREF]] : !fir.ref<f64>
+! CHECK: %[[B:.*]] = fir.load %[[BREF]] : !fir.ref<f64>
+! CHECK: %[[C:.*]] = fir.call @hypot(%[[A]], %[[B]]) : (f64, f64) -> f64
+! CHECK: fir.store %[[C]] to %[[CREF]] : !fir.ref<f64>
+! CHECK: return
+  real(kind=8) :: a, b, c
+  c = hypot(a, b)
+end subroutine
+
+! TODO: Test with abs(complex)