[Flang] [PowerPC] Implement remaining PPC math operation intrinsics that do not require semantic error checks

[pscoro]

Summary

This review implements the following PowerPC math operations that we care about:

• fnabs
• fre
• fres
• frsqrte
• frsqrtes

None of these intrinsics require additional error checks in semantics. The interfaces handle checking types and kinds

[kkwli0]

LG. Let's wait a day or two to see if any comments from other reviewers. Thanks.

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

 //===-- IntrinsicCall.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
static constexpr MathOperation ppcMathOperations[] = {
     {"__ppc_fctudz", "llvm.ppc.fctudz", genF64F64FuncType, genLibCall},
     {"__ppc_fctuwz", "llvm.ppc.fctuwz", genF64F64FuncType, genLibCall},
     {"__ppc_fmadd", "llvm.fma.f32", genF32F32F32F32FuncType,
      genMathOp<mlir::math::FmaOp>},
     {"__ppc_fmadd", "llvm.fma.f64", genF64F64F64F64FuncType,
      genMathOp<mlir::math::FmaOp>},
     {"__ppc_fmsub", "llvm.ppc.fmsubs", genF32F32F32F32FuncType, genLibCall},
     {"__ppc_fmsub", "llvm.ppc.fmsub", genF64F64F64F64FuncType, genLibCall},
+    {"__ppc_fnabs", "llvm.ppc.fnabss", genF32F32FuncType, genLibCall},
+    {"__ppc_fnabs", "llvm.ppc.fnabs", genF64F64FuncType, genLibCall},
     {"__ppc_fnmadd", "llvm.ppc.fnmadds", genF32F32F32F32FuncType, genLibCall},
     {"__ppc_fnmadd", "llvm.ppc.fnmadd", genF64F64F64F64FuncType, genLibCall},
     {"__ppc_fnmsub", "llvm.ppc.fnmsub.f32", genF32F32F32F32FuncType,
      genLibCall},
     {"__ppc_fnmsub", "llvm.ppc.fnmsub.f64", genF64F64F64F64FuncType,
      genLibCall},
+    {"__ppc_fre", "llvm.ppc.fre", genF64F64FuncType, genLibCall},
+    {"__ppc_fres", "llvm.ppc.fres", genF32F32FuncType, genLibCall},
+    {"__ppc_frsqrte", "llvm.ppc.frsqrte", genF64F64FuncType, genLibCall},
+    {"__ppc_frsqrtes", "llvm.ppc.frsqrtes", genF32F32FuncType, genLibCall},
 };
 
 // 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

flang/module/__fortran_ppc_intrinsics.f90

! fmadd, fmsub, fnmadd, fnmsub
   interface fnmsub
     procedure :: __ppc_fnmsub_r4
     procedure :: __ppc_fnmsub_r8
   end interface fnmsub
   public :: fnmsub
 
 ! fctid, fctidz, fctiw, fctiwz, fctudz, fctuwz
   abstract interface
+    elemental real(4) function func_r4r4x(x)
+      real(4), intent(in) :: x
+    end function func_r4r4x
     elemental real(8) function func_r8r8x(x)
       real(8), intent(in) :: x
     end function func_r8r8x
   end interface
 
   procedure(func_r8r8x) :: __ppc_fctid
   interface fctid
     procedure :: __ppc_fctid
! fcfi, fcfid, fcfud
   public :: fcfid
 
   procedure(func_r8r8i) :: __ppc_fcfud
   interface fcfud
     procedure :: __ppc_fcfud
   end interface fcfud
   public :: fcfud
 
+! fnabs
+  procedure(func_r4r4x) :: __ppc_fnabs_r4
+  procedure(func_r8r8x) :: __ppc_fnabs_r8
+  interface fnabs
+    procedure :: __ppc_fnabs_r4
+    procedure :: __ppc_fnabs_r8
+  end interface fnabs
+  public :: fnabs
+
+! fre, fres
+  procedure(func_r8r8x) :: __ppc_fre
+  interface fre
+    procedure :: __ppc_fre
+  end interface fre
+  public :: fre
+
+  procedure(func_r4r4x) :: __ppc_fres
+  interface fres
+    procedure :: __ppc_fres
+  end interface fres
+  public :: fres
+
+! frsqrte, frsqrtes
+  procedure(func_r8r8x) :: __ppc_frsqrte
+  interface frsqrte
+    procedure :: __ppc_frsqrte
+  end interface frsqrte
+  public :: frsqrte
+
+  procedure(func_r4r4x) :: __ppc_frsqrtes
+  interface frsqrtes
+    procedure :: __ppc_frsqrtes
+  end interface frsqrtes
+  public :: frsqrtes
 end module __Fortran_PPC_intrinsics

flang/test/Lower/ppc-intrinsics.f90

 
 ! CHECK-LABEL: fcfud_test
 subroutine fcfud_test(i)
   real(8) :: i, r
   r = fcfud(i)
 ! CHECK-FIR: fir.call @fir.__ppc_fcfud.f64.f64
 ! CHECK-LLVMIR: call contract double @llvm.ppc.fcfud(double %{{[0-9]}})
 end
+
+! CHECK-LABEL: fnabs_testr(x)
+subroutine fnabs_testr(x)
+  real :: x, y
+  y = fnabs(x)
+! CHECK-FIR: fir.call @fir.__ppc_fnabs.f32.f32
+! CHECK-LLVMIR: call contract float @llvm.ppc.fnabss(float %{{[0-9]}})
+end
+
+! CHECK-LABEL: fnabs_testd(x)
+subroutine fnabs_testd(x)
+  real(8) :: x, y
+  y = fnabs(x)
+! CHECK-FIR: fir.call @fir.__ppc_fnabs.f64.f64
+! CHECK-LLVMIR: call contract double @llvm.ppc.fnabs(double %{{[0-9]}})
+end
+
+!CHECK-LABEL: fre_test(x)
+subroutine fre_test(x)
+  real(8) :: x, y
+  y = fre(x)
+! CHECK-FIR: fir.call @fir.__ppc_fre.f64.f64
+! CHECK-LLVMIR: call contract double @llvm.ppc.fre(double %{{[0-9]}})
+end
+
+!CHECK-LABEL: fres_test(x)
+subroutine fres_test(x)
+  real :: x, y
+  y = fres(x)
+! CHECK-FIR: fir.call @fir.__ppc_fres.f32.f32
+! CHECK-LLVMIR: call contract float @llvm.ppc.fres(float %{{[0-9]}})
+end
+
+!CHECK-LABEL: frsqrte_test(x)
+subroutine frsqrte_test(x)
+  real(8) :: x, y
+  y = frsqrte(x)
+! CHECK-FIR: fir.call @fir.__ppc_frsqrte.f64.f64
+! CHECK-LLVMIR: call contract double @llvm.ppc.frsqrte(double %{{[0-9]}})
+end
+
+!CHECK-LABEL: frsqrtes_test(x)
+subroutine frsqrtes_test(x)
+  real :: x, y
+  y = frsqrtes(x)
+! CHECK-FIR: fir.call @fir.__ppc_frsqrtes.f32.f32
+! CHECK-LLVMIR: call contract float @llvm.ppc.frsqrtes(float %{{[0-9]}})
+end