[Flang] Options to lower math intrinsics to relaxed, precise variants

[kiranchandramohan]

Summary

Enable lowering to the relaxed and precise variants in the pgmath
library.

This is part of the upstreaming effort from the fir-dev branch in [1].
[1] https://github.com/flang-compiler/f18-llvm-project

Co-authored-by: Eric Schweitz <[e-mail]>
Co-authored-by: Jean Perier <[e-mail]>
Co-authored-by: Peter Klausler <[e-mail]>

[clementval]

LGTM

flang/lib/Lower/IntrinsicCall.cpp

static llvm::cl::opt<bool> outlineAllIntrinsics(
     llvm::cl::init(false));
 
 //===----------------------------------------------------------------------===//
 // Math runtime description and matching utility
 //===----------------------------------------------------------------------===//
 
 /// Command line option to modify math runtime version used to implement
 /// intrinsics.
-enum MathRuntimeVersion { fastVersion, llvmOnly };
+enum MathRuntimeVersion {
+  fastVersion,
+  relaxedVersion,
+  preciseVersion,
+  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(relaxedVersion, "relaxed", "use pgmath relaxed runtime"),
+        clEnumValN(preciseVersion, "precise", "use pgmath precise 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;
 };
 
 #define RUNTIME_STATIC_DESCRIPTION(name, func)                                 \
   {#name, #func, fir::runtime::RuntimeTableKey<decltype(func)>::getTypeModel()},
 static constexpr RuntimeFunction pgmathFast[] = {
 #define PGMATH_FAST
 #define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
 #include "flang/Evaluate/pgmath.h.inc"
 };
+static constexpr RuntimeFunction pgmathRelaxed[] = {
+#define PGMATH_RELAXED
+#define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
+#include "flang/Evaluate/pgmath.h.inc"
+};
+static constexpr RuntimeFunction pgmathPrecise[] = {
+#define PGMATH_PRECISE
+#define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
+#include "flang/Evaluate/pgmath.h.inc"
+};
 
 static mlir::FunctionType genF32F32FuncType(mlir::MLIRContext *context) {
   mlir::Type t = mlir::FloatType::getF32(context);
   return mlir::FunctionType::get(context, {t}, {t});
 }
 
 static mlir::FunctionType genF64F64FuncType(mlir::MLIRContext *context) {
   mlir::Type t = mlir::FloatType::getF64(context);
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");
+  static constexpr RtMap pgmathR(pgmathRelaxed);
+  static_assert(pgmathR.Verify() && "map must be sorted");
+  static constexpr RtMap pgmathP(pgmathPrecise);
+  static_assert(pgmathP.Verify() && "map must be sorted");
   if (mathRuntimeVersion == fastVersion) {
     match = searchFunctionInLibrary(loc, builder, pgmathF, name, funcType,
                                     &bestNearMatch, bestMatchDistance);
+  } else if (mathRuntimeVersion == relaxedVersion) {
+    match = searchFunctionInLibrary(loc, builder, pgmathR, name, funcType,
+                                    &bestNearMatch, bestMatchDistance);
+  } else if (mathRuntimeVersion == preciseVersion) {
+    match = searchFunctionInLibrary(loc, builder, pgmathP, 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

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

+! RUN: bbc -emit-fir --math-runtime=fast %s -o - | FileCheck %s --check-prefixes="FIR,FAST"
+! RUN: bbc -emit-fir --math-runtime=relaxed %s -o - | FileCheck %s --check-prefixes="FIR,RELAXED"
+! RUN: bbc -emit-fir --math-runtime=precise %s -o - | FileCheck %s --check-prefixes="FIR,PRECISE"
+! RUN: bbc -emit-fir --math-runtime=llvm %s -o - | FileCheck %s --check-prefixes="FIR,LLVM"
+
+! CHECK-LABEL: cos_testr
+subroutine cos_testr(a, b)
+  real :: a, b
+! FIR: fir.call @fir.cos.f32.f32
+  b = cos(a)
+end subroutine
+
+! CHECK-LABEL: cos_testd
+subroutine cos_testd(a, b)
+  real(kind=8) :: a, b
+! FIR: fir.call @fir.cos.f64.f64
+  b = cos(a)
+end subroutine
+
+! FIR: @fir.cos.f32.f32(%arg0: f32) -> f32 attributes
+! FAST: fir.call @__fs_cos_1(%arg0) : (f32) -> f32
+! RELAXED: fir.call @__rs_cos_1(%arg0) : (f32) -> f32
+! PRECISE: fir.call @__ps_cos_1(%arg0) : (f32) -> f32
+! LLVM: fir.call @llvm.cos.f32(%arg0) : (f32) -> f32
+! FIR: @fir.cos.f64.f64(%arg0: f64) -> f64
+! FAST: fir.call @__fd_cos_1(%arg0) : (f64) -> f64
+! RELAXED: fir.call @__rd_cos_1(%arg0) : (f64) -> f64
+! PRECISE: fir.call @__pd_cos_1(%arg0) : (f64) -> f64
+! LLVM: fir.call @llvm.cos.f64(%arg0) : (f64) -> f64