Skip to content

Commit 92604cf

Browse files
vdonaldsonvdonaldson
authored
[flang] IEEE_REM (#115936)
Implement the IEEE 60559:2020 remainder function.
1 parent 1b8e0cf commit 92604cf

File tree

7 files changed

+182
-6
lines changed

7 files changed

+182
-6
lines changed

‎flang/include/flang/Optimizer/Builder/IntrinsicCall.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -290,6 +290,7 @@ struct IntrinsicLibrary {
290290
mlir::Value genIeeeQuietCompare(mlir::Type resultType,
291291
llvm::ArrayRef<mlir::Value>);
292292
mlir::Value genIeeeReal(mlir::Type, llvm::ArrayRef<mlir::Value>);
293+
mlir::Value genIeeeRem(mlir::Type, llvm::ArrayRef<mlir::Value>);
293294
mlir::Value genIeeeRint(mlir::Type, llvm::ArrayRef<mlir::Value>);
294295
template <bool isFlag>
295296
void genIeeeSetFlagOrHaltingMode(llvm::ArrayRef<fir::ExtendedValue>);

‎flang/lib/Optimizer/Builder/IntrinsicCall.cpp‎

Lines changed: 35 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -97,7 +97,6 @@ static bool isStaticallyPresent(const fir::ExtendedValue &exv) {
9797

9898
/// IEEE module procedure names not yet implemented for genModuleProcTODO.
9999
static constexpr char ieee_get_underflow_mode[] = "ieee_get_underflow_mode";
100-
static constexpr char ieee_rem[] = "ieee_rem";
101100
static constexpr char ieee_set_underflow_mode[] = "ieee_set_underflow_mode";
102101

103102
using I = IntrinsicLibrary;
@@ -362,7 +361,7 @@ static constexpr IntrinsicHandler handlers[]{
362361
{"ieee_quiet_lt", &I::genIeeeQuietCompare<mlir::arith::CmpFPredicate::OLT>},
363362
{"ieee_quiet_ne", &I::genIeeeQuietCompare<mlir::arith::CmpFPredicate::UNE>},
364363
{"ieee_real", &I::genIeeeReal},
365-
{"ieee_rem", &I::genModuleProcTODO<ieee_rem>},
364+
{"ieee_rem", &I::genIeeeRem},
366365
{"ieee_rint", &I::genIeeeRint},
367366
{"ieee_round_eq", &I::genIeeeTypeCompare<mlir::arith::CmpIPredicate::eq>},
368367
{"ieee_round_ne", &I::genIeeeTypeCompare<mlir::arith::CmpIPredicate::ne>},
@@ -1298,6 +1297,14 @@ static constexpr MathOperation mathOperations[] = {
12981297
genFuncType<Ty::Complex<8>, Ty::Complex<8>, Ty::Integer<8>>, genLibCall},
12991298
{"pow", RTNAME_STRING(cqpowk), FuncTypeComplex16Complex16Integer8,
13001299
genLibF128Call},
1300+
{"remainder", "remainderf",
1301+
genFuncType<Ty::Real<4>, Ty::Real<4>, Ty::Real<4>>, genLibCall},
1302+
{"remainder", "remainder",
1303+
genFuncType<Ty::Real<8>, Ty::Real<8>, Ty::Real<8>>, genLibCall},
1304+
{"remainder", "remainderl",
1305+
genFuncType<Ty::Real<10>, Ty::Real<10>, Ty::Real<10>>, genLibCall},
1306+
{"remainder", RTNAME_STRING(RemainderF128), FuncTypeReal16Real16Real16,
1307+
genLibF128Call},
13011308
{"sign", "copysignf", genFuncType<Ty::Real<4>, Ty::Real<4>, Ty::Real<4>>,
13021309
genMathOp<mlir::math::CopySignOp>},
13031310
{"sign", "copysign", genFuncType<Ty::Real<8>, Ty::Real<8>, Ty::Real<8>>,
@@ -5030,6 +5037,32 @@ mlir::Value IntrinsicLibrary::genIeeeReal(mlir::Type resultType,
50305037
return ifOp1.getResult(0);
50315038
}
50325039

5040+
// IEEE_REM
5041+
mlir::Value IntrinsicLibrary::genIeeeRem(mlir::Type resultType,
5042+
llvm::ArrayRef<mlir::Value> args) {
5043+
// Return the remainder of X divided by Y.
5044+
// Signal IEEE_UNDERFLOW if X is subnormal and Y is infinite.
5045+
// Signal IEEE_INVALID if X is infinite or Y is zero and neither is a NaN.
5046+
assert(args.size() == 2);
5047+
mlir::Value x = args[0];
5048+
mlir::Value y = args[1];
5049+
if (mlir::dyn_cast<mlir::FloatType>(resultType).getWidth() < 32) {
5050+
mlir::Type f32Ty = mlir::FloatType::getF32(builder.getContext());
5051+
x = builder.create<fir::ConvertOp>(loc, f32Ty, x);
5052+
y = builder.create<fir::ConvertOp>(loc, f32Ty, y);
5053+
} else {
5054+
x = builder.create<fir::ConvertOp>(loc, resultType, x);
5055+
y = builder.create<fir::ConvertOp>(loc, resultType, y);
5056+
}
5057+
// remainder calls do not signal IEEE_UNDERFLOW.
5058+
mlir::Value underflow = builder.create<mlir::arith::AndIOp>(
5059+
loc, genIsFPClass(builder.getI1Type(), x, subnormalTest),
5060+
genIsFPClass(builder.getI1Type(), y, infiniteTest));
5061+
mlir::Value result = genRuntimeCall("remainder", x.getType(), {x, y});
5062+
genRaiseExcept(_FORTRAN_RUNTIME_IEEE_UNDERFLOW, underflow);
5063+
return builder.create<fir::ConvertOp>(loc, resultType, result);
5064+
}
5065+
50335066
// IEEE_RINT
50345067
mlir::Value IntrinsicLibrary::genIeeeRint(mlir::Type resultType,
50355068
llvm::ArrayRef<mlir::Value> args) {

‎flang/module/ieee_arithmetic.f90‎

Lines changed: 33 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -161,6 +161,11 @@ end function ieee_round_ne
161161

162162
! Define specifics with 1 or 2 INTEGER, LOGICAL, or REAL arguments for
163163
! generic G.
164+
!
165+
! The result type of most function specifics is either a fixed type or
166+
! the type of the first argument. The result type of a SPECIFICS_rRR
167+
! function call is the highest precision argument type.
168+
164169
#define SPECIFICS_I(G) \
165170
G(1) G(2) G(4) G(8) G(16)
166171
#define SPECIFICS_L(G) \
@@ -234,13 +239,26 @@ end function ieee_round_ne
234239
G(8,2) G(8,3) G(8,4) G(8,8) G(8,10) G(8,16) \
235240
G(10,2) G(10,3) G(10,4) G(10,8) G(10,10) G(10,16) \
236241
G(16,2) G(16,3) G(16,4) G(16,8) G(16,10) G(16,16)
242+
#define SPECIFICS_rRR(G) \
243+
G(2,2,2) G(2,2,3) G(4,2,4) G(8,2,8) G(10,2,10) G(16,2,16) \
244+
G(2,3,2) G(3,3,3) G(4,3,4) G(8,3,8) G(10,3,10) G(16,3,16) \
245+
G(4,4,2) G(4,4,3) G(4,4,4) G(8,4,8) G(10,4,10) G(16,4,16) \
246+
G(8,8,2) G(8,8,3) G(8,8,4) G(8,8,8) G(10,8,10) G(16,8,16) \
247+
G(10,10,2) G(10,10,3) G(10,10,4) G(10,10,8) G(10,10,10) G(16,10,16) \
248+
G(16,16,2) G(16,16,3) G(16,16,4) G(16,16,8) G(16,16,10) G(16,16,16)
237249
#else
238250
#define SPECIFICS_RR(G) \
239251
G(2,2) G(2,3) G(2,4) G(2,8) G(2,16) \
240252
G(3,2) G(3,3) G(3,4) G(3,8) G(3,16) \
241253
G(4,2) G(4,3) G(4,4) G(4,8) G(4,16) \
242254
G(8,2) G(8,3) G(8,4) G(8,8) G(8,16) \
243255
G(16,2) G(16,3) G(16,4) G(16,8) G(16,16)
256+
#define SPECIFICS_rRR(G) \
257+
G(2,2,2) G(2,2,3) G(4,2,4) G(8,2,8) G(16,2,16) \
258+
G(2,3,2) G(3,3,3) G(4,3,4) G(8,3,8) G(16,3,16) \
259+
G(4,4,2) G(4,4,3) G(4,4,4) G(8,4,8) G(16,4,16) \
260+
G(8,8,2) G(8,8,3) G(8,8,4) G(8,8,8) G(16,8,16) \
261+
G(16,16,2) G(16,16,3) G(16,16,4) G(16,16,8) G(16,16,16)
244262
#endif
245263
#else
246264
#if __x86_64__
@@ -250,12 +268,23 @@ end function ieee_round_ne
250268
G(4,2) G(4,3) G(4,4) G(4,8) G(4,10) \
251269
G(8,2) G(8,3) G(8,4) G(8,8) G(8,10) \
252270
G(10,2) G(10,3) G(10,4) G(10,8) G(10,10)
271+
#define SPECIFICS_rRR(G) \
272+
G(2,2,2) G(2,2,3) G(4,2,4) G(8,2,8) G(10,2,10) \
273+
G(2,3,2) G(3,3,3) G(4,3,4) G(8,3,8) G(10,3,10) \
274+
G(4,4,2) G(4,4,3) G(4,4,4) G(8,4,8) G(10,4,10) \
275+
G(8,8,2) G(8,8,3) G(8,8,4) G(8,8,8) G(10,8,10) \
276+
G(10,10,2) G(10,10,3) G(10,10,4) G(10,10,8) G(10,10,10)
253277
#else
254278
#define SPECIFICS_RR(G) \
255279
G(2,2) G(2,3) G(2,4) G(2,8) \
256280
G(3,2) G(3,3) G(3,4) G(3,8) \
257281
G(4,2) G(4,3) G(4,4) G(4,8) \
258282
G(8,2) G(8,3) G(8,4) G(8,8)
283+
#define SPECIFICS_rRR(G) \
284+
G(2,2,2) G(2,2,3) G(4,2,4) G(8,2,8) \
285+
G(2,3,2) G(3,3,3) G(4,3,4) G(8,3,8) \
286+
G(4,4,2) G(4,4,3) G(4,4,4) G(8,4,8) \
287+
G(8,8,2) G(8,8,3) G(8,8,4) G(8,8,8)
259288
#endif
260289
#endif
261290

@@ -467,16 +496,16 @@ end function ieee_quiet_ne_a##AKIND;
467496
public :: ieee_quiet_ne
468497
#undef IEEE_QUIET_NE_R
469498

470-
#define IEEE_REM_RR(XKIND, YKIND) \
471-
elemental real(XKIND) function ieee_rem_a##XKIND##_a##YKIND(x, y); \
499+
#define IEEE_REM_rRR(RKIND, XKIND, YKIND) \
500+
elemental real(RKIND) function ieee_rem_a##XKIND##_a##YKIND(x, y); \
472501
real(XKIND), intent(in) :: x; \
473502
real(YKIND), intent(in) :: y; \
474503
end function ieee_rem_a##XKIND##_a##YKIND;
475504
interface ieee_rem
476-
SPECIFICS_RR(IEEE_REM_RR)
505+
SPECIFICS_rRR(IEEE_REM_rRR)
477506
end interface ieee_rem
478507
public :: ieee_rem
479-
#undef IEEE_REM_RR
508+
#undef IEEE_REM_rRR
480509

481510
#define IEEE_RINT_R(XKIND) \
482511
elemental real(XKIND) function ieee_rint_a##XKIND(x, round); \

‎flang/runtime/Float128Math/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,7 @@ set(sources
5151
norm2.cpp
5252
pow.cpp
5353
random.cpp
54+
remainder.cpp
5455
round.cpp
5556
rrspacing.cpp
5657
scale.cpp

‎flang/runtime/Float128Math/math-entries.h‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -96,6 +96,7 @@ DEFINE_FALLBACK_F128(Nearbyint)
9696
DEFINE_FALLBACK_F128(Nextafter)
9797
DEFINE_FALLBACK_F128(Pow)
9898
DEFINE_FALLBACK_F128(Qnan)
99+
DEFINE_FALLBACK_F128(Remainder)
99100
DEFINE_FALLBACK_F128(Round)
100101
DEFINE_FALLBACK_F128(Sin)
101102
DEFINE_FALLBACK_F128(Sinh)
@@ -144,6 +145,7 @@ DEFINE_SIMPLE_ALIAS(Lround, lroundq)
144145
DEFINE_SIMPLE_ALIAS(Nearbyint, nearbyintq)
145146
DEFINE_SIMPLE_ALIAS(Nextafter, nextafterq)
146147
DEFINE_SIMPLE_ALIAS(Pow, powq)
148+
DEFINE_SIMPLE_ALIAS(Remainder, remainderq)
147149
DEFINE_SIMPLE_ALIAS(Round, roundq)
148150
DEFINE_SIMPLE_ALIAS(Sin, sinq)
149151
DEFINE_SIMPLE_ALIAS(Sinh, sinhq)
@@ -196,6 +198,7 @@ DEFINE_SIMPLE_ALIAS(Lround, std::lround)
196198
DEFINE_SIMPLE_ALIAS(Nearbyint, std::nearbyint)
197199
DEFINE_SIMPLE_ALIAS(Nextafter, std::nextafter)
198200
DEFINE_SIMPLE_ALIAS(Pow, std::pow)
201+
DEFINE_SIMPLE_ALIAS(Remainder, std::remainder)
199202
DEFINE_SIMPLE_ALIAS(Round, std::round)
200203
DEFINE_SIMPLE_ALIAS(Sin, std::sin)
201204
DEFINE_SIMPLE_ALIAS(Sinh, std::sinh)

‎flang/runtime/Float128Math/remainder.cpp‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
//===-- runtime/Float128Math/remainder.cpp --------------------------------===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
9+
#include "math-entries.h"
10+
11+
namespace Fortran::runtime {
12+
extern "C" {
13+
14+
#if HAS_LDBL128 || HAS_FLOAT128
15+
CppTypeFor<TypeCategory::Real, 16> RTDEF(RemainderF128)(
16+
CppTypeFor<TypeCategory::Real, 16> x,
17+
CppTypeFor<TypeCategory::Real, 16> y) {
18+
return Remainder<true>::invoke(x, y);
19+
}
20+
#endif
21+
22+
} // extern "C"
23+
} // namespace Fortran::runtime

‎flang/test/Lower/Intrinsics/ieee_rem.f90‎

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,86 @@
1+
! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
2+
3+
! CHECK-LABEL: c.func @_QQmain
4+
use ieee_arithmetic, only: ieee_rem
5+
6+
! CHECK: %[[V_0:[0-9]+]] = fir.alloca f16 {bindc_name = "x2", uniq_name = "_QFEx2"}
7+
! CHECK: %[[V_1:[0-9]+]]:2 = hlfir.declare %[[V_0]] {uniq_name = "_QFEx2"} : (!fir.ref<f16>) -> (!fir.ref<f16>, !fir.ref<f16>)
8+
! CHECK: %[[V_2:[0-9]+]] = fir.alloca f32 {bindc_name = "x4", uniq_name = "_QFEx4"}
9+
! CHECK: %[[V_3:[0-9]+]]:2 = hlfir.declare %[[V_2]] {uniq_name = "_QFEx4"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
10+
! CHECK: %[[V_4:[0-9]+]] = fir.alloca f64 {bindc_name = "x8", uniq_name = "_QFEx8"}
11+
! CHECK: %[[V_5:[0-9]+]]:2 = hlfir.declare %[[V_4]] {uniq_name = "_QFEx8"} : (!fir.ref<f64>) -> (!fir.ref<f64>, !fir.ref<f64>)
12+
! CHECK: %[[V_6:[0-9]+]] = fir.alloca f16 {bindc_name = "y2", uniq_name = "_QFEy2"}
13+
! CHECK: %[[V_7:[0-9]+]]:2 = hlfir.declare %[[V_6]] {uniq_name = "_QFEy2"} : (!fir.ref<f16>) -> (!fir.ref<f16>, !fir.ref<f16>)
14+
! CHECK: %[[V_8:[0-9]+]] = fir.alloca f32 {bindc_name = "y4", uniq_name = "_QFEy4"}
15+
! CHECK: %[[V_9:[0-9]+]]:2 = hlfir.declare %[[V_8]] {uniq_name = "_QFEy4"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
16+
! CHECK: %[[V_10:[0-9]+]] = fir.alloca f64 {bindc_name = "y8", uniq_name = "_QFEy8"}
17+
! CHECK: %[[V_11:[0-9]+]]:2 = hlfir.declare %[[V_10]] {uniq_name = "_QFEy8"} : (!fir.ref<f64>) -> (!fir.ref<f64>, !fir.ref<f64>)
18+
real(2) :: x2, y2
19+
real(4) :: x4, y4
20+
real(8) :: x8, y8
21+
22+
! CHECK: hlfir.assign %cst{{[_0-9]*}} to %[[V_3]]#0 : f32, !fir.ref<f32>
23+
x4 = 3.3_4
24+
! CHECK: hlfir.assign %cst{{[_0-9]*}} to %[[V_9]]#0 : f32, !fir.ref<f32>
25+
y4 = -0.0_4
26+
! CHECK-DAG: %[[V_12:[0-9]+]] = fir.load %[[V_3]]#0 : !fir.ref<f32>
27+
! CHECK-DAG: %[[V_13:[0-9]+]] = fir.load %[[V_9]]#0 : !fir.ref<f32>
28+
! CHECK-DAG: %[[V_14:[0-9]+]] = fir.convert %[[V_12]] : (f32) -> f32
29+
! CHECK-DAG: %[[V_15:[0-9]+]] = fir.convert %[[V_13]] : (f32) -> f32
30+
! CHECK-DAG: %[[V_16:[0-9]+]] = "llvm.intr.is.fpclass"(%[[V_15]]) <{bit = 516 : i32}> : (f32) -> i1
31+
! CHECK-DAG: %[[V_17:[0-9]+]] = "llvm.intr.is.fpclass"(%[[V_14]]) <{bit = 144 : i32}> : (f32) -> i1
32+
! CHECK-DAG: %[[V_18:[0-9]+]] = arith.andi %[[V_17]], %[[V_16]] : i1
33+
! CHECK-DAG: %[[V_19:[0-9]+]] = fir.call @remainderf(%[[V_14]], %[[V_15]]) fastmath<contract> : (f32, f32) -> f32
34+
! CHECK: fir.if %[[V_18]] {
35+
! CHECK: %[[V_40:[0-9]+]] = fir.call @_FortranAMapException(%c16{{.*}}) fastmath<contract> : (i32) -> i32
36+
! CHECK: %[[V_41:[0-9]+]] = fir.call @feraiseexcept(%[[V_40]]) fastmath<contract> : (i32) -> i32
37+
! CHECK: }
38+
! CHECK: %[[V_20:[0-9]+]] = fir.convert %[[V_19]] : (f32) -> f32
39+
! CHECK: hlfir.assign %[[V_20]] to %[[V_3]]#0 : f32, !fir.ref<f32>
40+
x4 = ieee_rem(x4, y4)
41+
! print*, x4
42+
43+
! CHECK: hlfir.assign %cst{{[_0-9]*}} to %[[V_1]]#0 : f16, !fir.ref<f16>
44+
x2 = 3.0_2
45+
! CHECK: hlfir.assign %cst{{[_0-9]*}} to %[[V_11]]#0 : f64, !fir.ref<f64>
46+
y8 = 2.0_8
47+
! CHECK-DAG: %[[V_21:[0-9]+]] = fir.load %[[V_1]]#0 : !fir.ref<f16>
48+
! CHECK-DAG: %[[V_22:[0-9]+]] = fir.load %[[V_11]]#0 : !fir.ref<f64>
49+
! CHECK-DAG: %[[V_23:[0-9]+]] = fir.convert %[[V_21]] : (f16) -> f64
50+
! CHECK-DAG: %[[V_24:[0-9]+]] = fir.convert %[[V_22]] : (f64) -> f64
51+
! CHECK-DAG: %[[V_25:[0-9]+]] = "llvm.intr.is.fpclass"(%[[V_24]]) <{bit = 516 : i32}> : (f64) -> i1
52+
! CHECK-DAG: %[[V_26:[0-9]+]] = "llvm.intr.is.fpclass"(%[[V_23]]) <{bit = 144 : i32}> : (f64) -> i1
53+
! CHECK-DAG: %[[V_27:[0-9]+]] = arith.andi %[[V_26]], %[[V_25]] : i1
54+
! CHECK-DAG: %[[V_28:[0-9]+]] = fir.call @remainder(%[[V_23]], %[[V_24]]) fastmath<contract> : (f64, f64) -> f64
55+
! CHECK: fir.if %[[V_27]] {
56+
! CHECK: %[[V_40:[0-9]+]] = fir.call @_FortranAMapException(%c16{{.*}}) fastmath<contract> : (i32) -> i32
57+
! CHECK: %[[V_41:[0-9]+]] = fir.call @feraiseexcept(%[[V_40]]) fastmath<contract> : (i32) -> i32
58+
! CHECK: }
59+
! CHECK: %[[V_29:[0-9]+]] = fir.convert %[[V_28]] : (f64) -> f64
60+
! CHECK: %[[V_30:[0-9]+]] = fir.convert %[[V_29]] : (f64) -> f16
61+
! CHECK: hlfir.assign %[[V_30]] to %[[V_1]]#0 : f16, !fir.ref<f16>
62+
x2 = ieee_rem(x2, y8)
63+
! print*, x2
64+
65+
! CHECK: hlfir.assign %cst{{[_0-9]*}} to %[[V_5]]#0 : f64, !fir.ref<f64>
66+
x8 = huge(x8)
67+
! CHECK: hlfir.assign %cst{{[_0-9]*}} to %[[V_7]]#0 : f16, !fir.ref<f16>
68+
y2 = tiny(y2)
69+
! CHECK-DAG: %[[V_31:[0-9]+]] = fir.load %[[V_5]]#0 : !fir.ref<f64>
70+
! CHECK-DAG: %[[V_32:[0-9]+]] = fir.load %[[V_7]]#0 : !fir.ref<f16>
71+
! CHECK-DAG: %[[V_33:[0-9]+]] = fir.convert %[[V_31]] : (f64) -> f64
72+
! CHECK-DAG: %[[V_34:[0-9]+]] = fir.convert %[[V_32]] : (f16) -> f64
73+
! CHECK-DAG: %[[V_35:[0-9]+]] = "llvm.intr.is.fpclass"(%[[V_34]]) <{bit = 516 : i32}> : (f64) -> i1
74+
! CHECK-DAG: %[[V_36:[0-9]+]] = "llvm.intr.is.fpclass"(%[[V_33]]) <{bit = 144 : i32}> : (f64) -> i1
75+
! CHECK-DAG: %[[V_37:[0-9]+]] = arith.andi %[[V_36]], %[[V_35]] : i1
76+
! CHECK-DAG: %[[V_38:[0-9]+]] = fir.call @remainder(%[[V_33]], %[[V_34]]) fastmath<contract> : (f64, f64) -> f64
77+
! CHECK: fir.if %[[V_37]] {
78+
! CHECK: %[[V_40:[0-9]+]] = fir.call @_FortranAMapException(%c16{{.*}}) fastmath<contract> : (i32) -> i32
79+
! CHECK: %[[V_41:[0-9]+]] = fir.call @feraiseexcept(%[[V_40]]) fastmath<contract> : (i32) -> i32
80+
! CHECK: }
81+
! CHECK: %[[V_39:[0-9]+]] = fir.convert %[[V_38]] : (f64) -> f64
82+
! CHECK: hlfir.assign %[[V_39]] to %[[V_5]]#0 : f64, !fir.ref<f64>
83+
x8 = ieee_rem(x8, y2)
84+
! print*, x8
85+
86+
end

0 commit comments

Comments
 (0)