Handle more LLVM math functions and permit old flang abi as option (#775)

Author: wsmoses

flang/lib/Lower/IntrinsicCall.cpp

@@ -715,6 +715,16 @@ static mlir::FunctionType genF64F64FuncType(mlir::MLIRContext *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});
+}
+
 template <int Bits>
 static mlir::FunctionType genIntF64FuncType(mlir::MLIRContext *context) {
   auto t = mlir::FloatType::getF64(context);
@@ -739,11 +749,17 @@ static constexpr RuntimeFunction llvmIntrinsics[] = {
     {"aint", "llvm.trunc.f64", genF64F64FuncType},
     {"anint", "llvm.round.f32", genF32F32FuncType},
     {"anint", "llvm.round.f64", genF64F64FuncType},
+    {"atan", "atanf", genF32F32FuncType},
+    {"atan", "atan", genF64F64FuncType},
     // ceil is used for CEILING but is different, it returns a real.
     {"ceil", "llvm.ceil.f32", genF32F32FuncType},
     {"ceil", "llvm.ceil.f64", genF64F64FuncType},
     {"cos", "llvm.cos.f32", genF32F32FuncType},
     {"cos", "llvm.cos.f64", genF64F64FuncType},
+    {"cosh", "coshf", genF32F32FuncType},
+    {"cosh", "cosh", genF64F64FuncType},
+    {"exp", "llvm.exp.f32", genF32F32FuncType},
+    {"exp", "llvm.exp.f64", genF64F64FuncType},
     // llvm.floor is used for FLOOR, but returns real.
     {"floor", "llvm.floor.f32", genF32F32FuncType},
     {"floor", "llvm.floor.f64", genF64F64FuncType},
@@ -755,8 +771,12 @@ static constexpr RuntimeFunction llvmIntrinsics[] = {
     {"nint", "llvm.lround.i64.f32", genIntF32FuncType<64>},
     {"nint", "llvm.lround.i32.f64", genIntF64FuncType<32>},
     {"nint", "llvm.lround.i32.f32", genIntF32FuncType<32>},
+    {"pow", "llvm.pow.f32", genF32F32F32FuncType},
+    {"pow", "llvm.pow.f64", genF64F64F64FuncType},
     {"sin", "llvm.sin.f32", genF32F32FuncType},
     {"sin", "llvm.sin.f64", genF64F64FuncType},
+    {"sinh", "sinhf", genF32F32FuncType},
+    {"sinh", "sinh", genF64F64FuncType},
     {"sqrt", "llvm.sqrt.f32", genF32F32FuncType},
     {"sqrt", "llvm.sqrt.f64", genF64F64FuncType},
 };

flang/test/Lower/llvm-math.f90

@@ -0,0 +1,113 @@
+! 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: func @_QPpow_wrapper(%arg0: !fir.ref<f64>, %arg1: !fir.ref<f64>, %arg2: !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: func @_QPpowf_wrapper(%arg0: !fir.ref<f32>, %arg1: !fir.ref<f32>, %arg2: !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
+
+      SUBROUTINE ATAN_WRAPPER(IN, OUT)
+      DOUBLE PRECISION IN
+      OUT = DATAN(IN)
+      RETURN
+      END
+     
+! CHECK:       func private @fir.atan.f64.f64(%arg0: f64) 
+! CHECK-NEXT:   %0 = fir.call @atan(%arg0) : (f64) -> f64
+! CHECK-NEXT:   return %0 : f64
+! CHECK-NEXT: }
+
+      SUBROUTINE EXP_WRAPPER(IN, OUT)
+      DOUBLE PRECISION IN
+      OUT = DEXP(IN)
+      RETURN
+      END
+      
+! CHECK:       func private @fir.exp.f64.f64(%arg0: f64) 
+! CHECK-NEXT:   %0 = fir.call @llvm.exp.f64(%arg0) : (f64) -> f64
+! CHECK-NEXT:   return %0 : f64
+! CHECK-NEXT: }
+
+      SUBROUTINE SINH_WRAPPER(IN, OUT)
+      DOUBLE PRECISION IN
+      OUT = DSINH(IN)
+      RETURN
+      END
+      
+! CHECK:       func private @fir.sinh.f64.f64(%arg0: f64) 
+! CHECK-NEXT:   %0 = fir.call @sinh(%arg0) : (f64) -> f64
+! CHECK-NEXT:   return %0 : f64
+! CHECK-NEXT: }
+
+      SUBROUTINE COSH_WRAPPER(IN, OUT)
+      DOUBLE PRECISION IN
+      OUT = DCOSH(IN)
+      RETURN
+      END
+
+! CHECK:       func private @fir.cosh.f64.f64(%arg0: f64) 
+! CHECK-NEXT:   %0 = fir.call @cosh(%arg0) : (f64) -> f64
+! CHECK-NEXT:   return %0 : f64
+! CHECK-NEXT: }
+
+
+      SUBROUTINE ATANF_WRAPPER(IN, OUT)
+      REAL IN
+      OUT = ATAN(IN)
+      RETURN
+      END
+      
+! CHECK:       func private @fir.atan.f32.f32(%arg0: f32) 
+! CHECK-NEXT:   %0 = fir.call @atanf(%arg0) : (f32) -> f32
+! CHECK-NEXT:   return %0 : f32
+! CHECK-NEXT: }
+
+      SUBROUTINE EXPF_WRAPPER(IN, OUT)
+      REAL IN
+      OUT = EXP(IN)
+      RETURN
+      END
+
+! CHECK:       func private @fir.exp.f32.f32(%arg0: f32) 
+! CHECK-NEXT:   %0 = fir.call @llvm.exp.f32(%arg0) : (f32) -> f32
+! CHECK-NEXT:   return %0 : f32
+! CHECK-NEXT: }
+
+      SUBROUTINE SINHF_WRAPPER(IN, OUT)
+      REAL IN
+      OUT = SINH(IN)
+      RETURN
+      END
+      
+! CHECK:       func private @fir.sinh.f32.f32(%arg0: f32) 
+! CHECK-NEXT:   %0 = fir.call @sinhf(%arg0) : (f32) -> f32
+! CHECK-NEXT:   return %0 : f32
+! CHECK-NEXT: }
+
+      SUBROUTINE COSHF_WRAPPER(IN, OUT)
+      REAL IN
+      OUT = COSH(IN)
+      RETURN
+      END
+      
+! CHECK:       func private @fir.cosh.f32.f32(%arg0: f32) 
+! CHECK-NEXT:   %0 = fir.call @coshf(%arg0) : (f32) -> f32
+! CHECK-NEXT:   return %0 : f32
+! CHECK-NEXT: }
+