[Flang] Lower sin, cos intrinsics

[kiranchandramohan]

Summary

The intrinsic computes the sin, cosine values. By default they are lowered
to runtime calls to the pgmath library, for llvm lowering they are
lowered to llvm intrinsics. The generic and llvm lowering does not
lower floating point types with kind greater than 8, the llvm lowering
does not support the complex types.

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]>

[clementval]

LGTM

flang/lib/Lower/IntrinsicCall.cpp

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},
     {"log", "llvm.log.f32", genF32F32FuncType},
     {"log", "llvm.log.f64", genF64F64FuncType},
     {"log10", "llvm.log10.f32", genF32F32FuncType},
     {"log10", "llvm.log10.f64", genF64F64FuncType},
     {"nint", "llvm.lround.i64.f64", genIntF64FuncType<64>},
     {"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},
     {"sign", "llvm.copysign.f32", genF32F32F32FuncType},
     {"sign", "llvm.copysign.f64", genF64F64F64FuncType},
     {"sign", "llvm.copysign.f80", genF80F80F80FuncType},
     {"sign", "llvm.copysign.f128", genF128F128F128FuncType},
+    {"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},
 };
 
 // This helper class computes a "distance" between two function types.
 // The distance measures how many narrowing conversions of actual arguments

flang/test/Lower/llvm-math.f90

! CHECK-NEXT: }
       REAL(KIND=8) :: IN, OUT
       OUT = SQRT(IN)
       END SUBROUTINE
 
 ! CHECK-LABEL: func private @fir.sqrt.f64.f64(%arg0: f64)
 ! CHECK-NEXT:  %0 = fir.call @llvm.sqrt.f64(%arg0) : (f64) -> f64
 ! CHECK-NEXT:   return %0 : f64
 ! CHECK-NEXT: }
+
+      SUBROUTINE COS_WRAPPER(IN, OUT)
+      REAL :: IN, OUT
+      OUT = COS(IN)
+      END SUBROUTINE
+
+! CHECK-LABEL: func private @fir.cos.f32.f32(%arg0: f32)
+! CHECK-NEXT:  %0 = fir.call @llvm.cos.f32(%arg0) : (f32) -> f32
+! CHECK-NEXT:   return %0 : f32
+! CHECK-NEXT: }
+
+      SUBROUTINE COSD_WRAPPER(IN, OUT)
+      REAL(KIND=8) :: IN, OUT
+      OUT = COS(IN)
+      END SUBROUTINE
+
+! CHECK-LABEL: func private @fir.cos.f64.f64(%arg0: f64)
+! CHECK-NEXT:  %0 = fir.call @llvm.cos.f64(%arg0) : (f64) -> f64
+! CHECK-NEXT:   return %0 : f64
+! CHECK-NEXT: }
+
+      SUBROUTINE SIN_WRAPPER(IN, OUT)
+      REAL :: IN, OUT
+      OUT = SIN(IN)
+      END SUBROUTINE
+
+! CHECK-LABEL: func private @fir.sin.f32.f32(%arg0: f32)
+! CHECK-NEXT:  %0 = fir.call @llvm.sin.f32(%arg0) : (f32) -> f32
+! CHECK-NEXT:   return %0 : f32
+! CHECK-NEXT: }
+
+      SUBROUTINE SIND_WRAPPER(IN, OUT)
+      REAL(KIND=8) :: IN, OUT
+      OUT = SIN(IN)
+      END SUBROUTINE
+
+! CHECK-LABEL: func private @fir.sin.f64.f64(%arg0: f64)
+! CHECK-NEXT:  %0 = fir.call @llvm.sin.f64(%arg0) : (f64) -> f64
+! CHECK-NEXT:   return %0 : f64
+! CHECK-NEXT: }

flang/test/Lower/trigonometric-intrinsics.f90

 
 ! CHECK-LABEL: atan_testcd
 subroutine atan_testcd(z)
   complex(kind=8) :: z
 ! CHECK: fir.call @fir.atan.z8.z8
   z = atan(z)
 end subroutine
 
+! CHECK-LABEL: cos_testr
+subroutine cos_testr(a, b)
+  real :: a, b
+! CHECK: 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
+! CHECK: fir.call @fir.cos.f64.f64
+  b = cos(a)
+end subroutine
+
+! CHECK-LABEL: cos_testc
+subroutine cos_testc(z)
+  complex :: z
+! CHECK: fir.call @fir.cos.z4.z4
+  z = cos(z)
+end subroutine
+
+! CHECK-LABEL: cos_testcd
+subroutine cos_testcd(z)
+  complex(kind=8) :: z
+! CHECK: fir.call @fir.cos.z8.z8
+  z = cos(z)
+end subroutine
+
 ! CHECK-LABEL: cosh_testr
 subroutine cosh_testr(a, b)
   real :: a, b
 ! CHECK: fir.call @fir.cosh.f32.f32
   b = cosh(a)
 end subroutine
 
 ! CHECK-LABEL: cosh_testd

 
 ! CHECK-LABEL: cosh_testcd
 subroutine cosh_testcd(z)
   complex(kind=8) :: z
 ! CHECK: fir.call @fir.cosh.z8.z8
   z = cosh(z)
 end subroutine
 
+! CHECK-LABEL: sin_testr
+subroutine sin_testr(a, b)
+  real :: a, b
+! CHECK: fir.call @fir.sin.f32.f32
+  b = sin(a)
+end subroutine
+
+! CHECK-LABEL: sin_testd
+subroutine sin_testd(a, b)
+  real(kind=8) :: a, b
+! CHECK: fir.call @fir.sin.f64.f64
+  b = sin(a)
+end subroutine
+
+! CHECK-LABEL: sin_testc
+subroutine sin_testc(z)
+  complex :: z
+! CHECK: fir.call @fir.sin.z4.z4
+  z = sin(z)
+end subroutine
+
+! CHECK-LABEL: sin_testcd
+subroutine sin_testcd(z)
+  complex(kind=8) :: z
+! CHECK: fir.call @fir.sin.z8.z8
+  z = sin(z)
+end subroutine
+
 ! CHECK-LABEL: sinh_testr
 subroutine sinh_testr(a, b)
   real :: a, b
 ! CHECK: fir.call @fir.sinh.f32.f32
   b = sinh(a)
 end subroutine
 
 ! CHECK-LABEL: sinh_testd

 ! CHECK: fir.call {{.*}}atan
 
 ! CHECK-LABEL: @fir.atan.z4.z4
 ! CHECK: fir.call {{.*}}atan
 
 ! CHECK-LABEL: @fir.atan.z8.z8
 ! CHECK: fir.call {{.*}}atan
 
+! CHECK-LABEL: @fir.cos.f32.f32
+! CHECK: fir.call {{.*}}cos
+
+! CHECK-LABEL: @fir.cos.f64.f64
+! CHECK: fir.call {{.*}}cos
+
+! CHECK-LABEL: @fir.cos.z4.z4
+! CHECK: fir.call {{.*}}cos
+
+! CHECK-LABEL: @fir.cos.z8.z8
+! CHECK: fir.call {{.*}}cos
+
 ! CHECK-LABEL: @fir.cosh.f32.f32
 ! CHECK: fir.call {{.*}}cosh
 
 ! CHECK-LABEL: @fir.cosh.f64.f64
 ! CHECK: fir.call {{.*}}cosh
 
 ! CHECK-LABEL: @fir.cosh.z4.z4
 ! CHECK: fir.call {{.*}}cosh
 
 ! CHECK-LABEL: @fir.cosh.z8.z8
 ! CHECK: fir.call {{.*}}cosh
 
+! CHECK-LABEL: @fir.sin.f32.f32
+! CHECK: fir.call {{.*}}sin
+
+! CHECK-LABEL: @fir.sin.f64.f64
+! CHECK: fir.call {{.*}}sin
+
+! CHECK-LABEL: @fir.sin.z4.z4
+! CHECK: fir.call {{.*}}sin
+
+! CHECK-LABEL: @fir.sin.z8.z8
+! CHECK: fir.call {{.*}}sin
+
 ! CHECK-LABEL: @fir.sinh.f32.f32
 ! CHECK: fir.call {{.*}}sinh
 
 ! CHECK-LABEL: @fir.sinh.f64.f64
 ! CHECK: fir.call {{.*}}sinh
 
 ! CHECK-LABEL: @fir.sinh.z4.z4
 ! CHECK: fir.call {{.*}}sinh
 
 ! CHECK-LABEL: @fir.sinh.z8.z8
 ! CHECK: fir.call {{.*}}sinh