[flang] Remove fp128 support for llvm.round and llvm.trunc

[peixin]

Summary

The fp128 in llvm.round and llvm.trunc is not supported in X86_64 for
now. Revert the support. To support quad precision for llvm.round and
llvm.trunc, it may should be supported using runtime.

[jeanPerier]

+1 for disabling it until a solution is found to get this working on all platforms.

[peixin]

In D130556#3679223, @jeanPerier wrote:

+1 for disabling it until a solution is found to get this working on all platforms.

OK. Thanks.

flang/lib/Lower/IntrinsicCall.cpp

static constexpr MathOperation mathOperations[] = {
     {"abs", "fabsf", genF32F32FuncType, genMathOp<mlir::math::AbsOp>},
     {"abs", "fabs", genF64F64FuncType, genMathOp<mlir::math::AbsOp>},
     {"abs", "llvm.fabs.f128", genF128F128FuncType,
      genMathOp<mlir::math::AbsOp>},
     // llvm.trunc behaves the same way as libm's trunc.
     {"aint", "llvm.trunc.f32", genF32F32FuncType, genLibCall},
     {"aint", "llvm.trunc.f64", genF64F64FuncType, genLibCall},
     {"aint", "llvm.trunc.f80", genF80F80FuncType, genLibCall},
-    {"aint", "llvm.trunc.f128", genF128F128FuncType, genLibCall},
     // llvm.round behaves the same way as libm's round.
     {"anint", "llvm.round.f32", genF32F32FuncType,
      genMathOp<mlir::LLVM::RoundOp>},
     {"anint", "llvm.round.f64", genF64F64FuncType,
      genMathOp<mlir::LLVM::RoundOp>},
     {"anint", "llvm.round.f80", genF80F80FuncType,
      genMathOp<mlir::LLVM::RoundOp>},
-    {"anint", "llvm.round.f128", genF128F128FuncType,
-     genMathOp<mlir::LLVM::RoundOp>},
     {"atan", "atanf", genF32F32FuncType, genMathOp<mlir::math::AtanOp>},
     {"atan", "atan", genF64F64FuncType, genMathOp<mlir::math::AtanOp>},
     {"atan2", "atan2f", genF32F32F32FuncType, genMathOp<mlir::math::Atan2Op>},
     {"atan2", "atan2", genF64F64F64FuncType, genMathOp<mlir::math::Atan2Op>},
     // math::CeilOp returns a real, while Fortran CEILING returns integer.
     {"ceil", "ceilf", genF32F32FuncType, genMathOp<mlir::math::CeilOp>},
     {"ceil", "ceil", genF64F64FuncType, genMathOp<mlir::math::CeilOp>},
     {"cos", "cosf", genF32F32FuncType, genMathOp<mlir::math::CosOp>},

flang/test/Lower/Intrinsics/aint.f90

 ! CHECK:         return
 ! CHECK:       }
 
 subroutine aint_test_real10(a, b)
   real(10) :: a, b
   b = aint(a)
 end subroutine
 
-! CHECK-LABEL: func.func @_QPaint_test_real16(
-! CHECK-SAME:                                 %[[VAL_0:.*]]: !fir.ref<f128> {fir.bindc_name = "a"},
-! CHECK-SAME:                                 %[[VAL_1:.*]]: !fir.ref<f128> {fir.bindc_name = "b"}) {
-! CHECK:         %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<f128>
-! CHECK:         %[[VAL_3:.*]] = fir.call @llvm.trunc.f128(%[[VAL_2]]) : (f128) -> f128
-! CHECK:         fir.store %[[VAL_3]] to %[[VAL_1]] : !fir.ref<f128>
-! CHECK:         return
-! CHECK:       }
-
-subroutine aint_test_real16(a, b)
-  real(16) :: a, b
-  b = aint(a)
-end subroutine
+! TODO: wait until fp128 is supported well in llvm.trunc
+!subroutine aint_test_real16(a, b)
+!  real(16) :: a, b
+!  b = aint(a)
+!end subroutine

flang/test/Lower/Intrinsics/anint.f90

 ! CHECK:         return
 ! CHECK:       }
 
 subroutine anint_test_real10(a, b)
   real(10) :: a, b
   b = anint(a)
 end subroutine
 
-! CHECK-LABEL: func.func @_QPanint_test_real16(
-! CHECK-SAME:                                  %[[VAL_0:.*]]: !fir.ref<f128> {fir.bindc_name = "a"},
-! CHECK-SAME:                                  %[[VAL_1:.*]]: !fir.ref<f128> {fir.bindc_name = "b"}) {
-! CHECK:         %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<f128>
-! CHECK:         %[[VAL_3:.*]] = "llvm.intr.round"(%[[VAL_2]]) : (f128) -> f128
-! CHECK:         fir.store %[[VAL_3]] to %[[VAL_1]] : !fir.ref<f128>
-! CHECK:         return
-! CHECK:       }
-
-subroutine anint_test_real16(a, b)
-  real(16) :: a, b
-  b = anint(a)
-end subroutine
+! TODO: wait until fp128 is supported well in llvm.round
+!subroutine anint_test_real16(a, b)
+!  real(16) :: a, b
+!  b = anint(a)
+!end subroutine

flang/test/Lower/math-lowering.f90

 function test_real10(x)
   real(10) :: x, test_real10
   test_real10 = aint(x)
 end function
 
 ! ALL-LABEL: @_QPtest_real10
 ! ALL: {{%[A-Za-z0-9._]+}} = fir.call @llvm.trunc.f80({{%[A-Za-z0-9._]+}}) : (f80) -> f80
 
-function test_real16(x)
-  real(16) :: x, test_real16
-  test_real16 = aint(x)
-end function
-
-! ALL-LABEL: @_QPtest_real16
-! ALL: {{%[A-Za-z0-9._]+}} = fir.call @llvm.trunc.f128({{%[A-Za-z0-9._]+}}) : (f128) -> f128
+! TODO: wait until fp128 is supported well in llvm.trunc
+!function test_real16(x)
+!  real(16) :: x, test_real16
+!  test_real16 = aint(x)
+!end function
 
 //--- anint.f90
 ! RUN: bbc -emit-fir %t/anint.f90 -o - --math-runtime=fast | FileCheck --check-prefixes=ALL,FAST %t/anint.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=fast %t/anint.f90 -o - | FileCheck --check-prefixes=ALL,FAST %t/anint.f90
 ! RUN: bbc -emit-fir %t/anint.f90 -o - --math-runtime=relaxed | FileCheck --check-prefixes=ALL,RELAXED %t/anint.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=relaxed %t/anint.f90 -o - | FileCheck --check-prefixes=ALL,RELAXED %t/anint.f90
 ! RUN: bbc -emit-fir %t/anint.f90 -o - --math-runtime=precise | FileCheck --check-prefixes=ALL,PRECISE %t/anint.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=precise %t/anint.f90 -o - | FileCheck --check-prefixes=ALL,PRECISE %t/anint.f90
function test_real10(x)
   test_real10 = anint(x)
 end function
 
 ! ALL-LABEL: @_QPtest_real10
 ! FAST: {{%[A-Za-z0-9._]+}} = "llvm.intr.round"({{%[A-Za-z0-9._]+}}) : (f80) -> f80
 ! RELAXED: {{%[A-Za-z0-9._]+}} = "llvm.intr.round"({{%[A-Za-z0-9._]+}}) : (f80) -> f80
 ! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @llvm.round.f80({{%[A-Za-z0-9._]+}}) : (f80) -> f80
 
-function test_real16(x)
-  real(16) :: x, test_real16
-  test_real16 = anint(x)
-end function
-
-! ALL-LABEL: @_QPtest_real16
-! FAST: {{%[A-Za-z0-9._]+}} = "llvm.intr.round"({{%[A-Za-z0-9._]+}}) : (f128) -> f128
-! RELAXED: {{%[A-Za-z0-9._]+}} = "llvm.intr.round"({{%[A-Za-z0-9._]+}}) : (f128) -> f128
-! PRECISE: {{%[A-Za-z0-9._]+}} = fir.call @llvm.round.f128({{%[A-Za-z0-9._]+}}) : (f128) -> f128
+! TODO: wait until fp128 is supported well in llvm.round
+!function test_real16(x)
+!  real(16) :: x, test_real16
+!  test_real16 = anint(x)
+!end function
 
 //--- atan.f90
 ! RUN: bbc -emit-fir %t/atan.f90 -o - --math-runtime=fast | FileCheck --check-prefixes=ALL,FAST %t/atan.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=fast %t/atan.f90 -o - | FileCheck --check-prefixes=ALL,FAST %t/atan.f90
 ! RUN: bbc -emit-fir %t/atan.f90 -o - --math-runtime=relaxed | FileCheck --check-prefixes=ALL,RELAXED %t/atan.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=relaxed %t/atan.f90 -o - | FileCheck --check-prefixes=ALL,RELAXED %t/atan.f90
 ! RUN: bbc -emit-fir %t/atan.f90 -o - --math-runtime=precise | FileCheck --check-prefixes=ALL,PRECISE %t/atan.f90
 ! RUN: %flang_fc1 -emit-fir -mllvm -math-runtime=precise %t/atan.f90 -o - | FileCheck --check-prefixes=ALL,PRECISE %t/atan.f90