Skip to content

Commit df12bad

Browse files
frasercrmckfrasercrmck
authored
[libclc] Use CLC conversion builtins in CLC functions (#127628)
This commit is a broad update across libclc to use the CLC conversion builtins in CLC functions, even those with a '__clc' prefix in the generic folder. This better prepares them for an official move to the CLC library in time. The CLC conversion builtins have an additional benefit in that they support scalars, unlike the __builtin_convertvector builtin which we were using previously. This allows us to simplify some shared definitions. There is one change to the IR, in the scalar upsample(char, uchar) builtin. It now sign-extends the first argument to i16, where before it zero-extended it. This appears to be correct, and matches the vector behaviour.
1 parent 10fc06a commit df12bad

File tree

12 files changed

+236
-251
lines changed

12 files changed

+236
-251
lines changed

‎libclc/clc/include/clc/clc_convert.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
11
#ifndef __CLC_CLC_CONVERT_H__
22
#define __CLC_CLC_CONVERT_H__
33

4+
#include <clc/clcmacro.h>
5+
46
#define _CLC_CONVERT_DECL(FROM_TYPE, TO_TYPE, SUFFIX) \
57
_CLC_OVERLOAD _CLC_DECL TO_TYPE __clc_convert_##TO_TYPE##SUFFIX(FROM_TYPE x);
68

‎libclc/clc/lib/generic/integer/clc_mad_sat.cl

Lines changed: 13 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
#include <clc/clc_convert.h>
12
#include <clc/clcmacro.h>
23
#include <clc/integer/clc_add_sat.h>
34
#include <clc/integer/clc_mad24.h>
@@ -8,34 +9,23 @@
89
#include <clc/relational/clc_select.h>
910
#include <clc/shared/clc_clamp.h>
1011

11-
#define __CLC_CONVERT_TY(X, TY) __builtin_convertvector(X, TY)
12-
13-
// Macro for defining mad_sat variants for char/uchar/short/ushort
14-
// FIXME: Once using __clc_convert_ty, can easily unify scalar and vector defs
1512
#define __CLC_DEFINE_SIMPLE_MAD_SAT(TYPE, UP_TYPE, LIT_PREFIX) \
1613
_CLC_OVERLOAD _CLC_DEF TYPE __clc_mad_sat(TYPE x, TYPE y, TYPE z) { \
17-
return __clc_clamp( \
18-
(UP_TYPE)__clc_mad24((UP_TYPE)x, (UP_TYPE)y, (UP_TYPE)z), \
19-
(UP_TYPE)LIT_PREFIX##_MIN, (UP_TYPE)LIT_PREFIX##_MAX); \
20-
}
21-
22-
#define __CLC_DEFINE_SIMPLE_MAD_SAT_VEC(TYPE, UP_TYPE, LIT_PREFIX) \
23-
_CLC_OVERLOAD _CLC_DEF TYPE __clc_mad_sat(TYPE x, TYPE y, TYPE z) { \
24-
UP_TYPE upscaled_mad = __clc_mad24(__CLC_CONVERT_TY(x, UP_TYPE), \
25-
__CLC_CONVERT_TY(y, UP_TYPE), \
26-
__CLC_CONVERT_TY(z, UP_TYPE)); \
14+
UP_TYPE upscaled_mad = \
15+
__clc_mad24(__clc_convert_##UP_TYPE(x), __clc_convert_##UP_TYPE(y), \
16+
__clc_convert_##UP_TYPE(z)); \
2717
UP_TYPE clamped_mad = __clc_clamp(upscaled_mad, (UP_TYPE)LIT_PREFIX##_MIN, \
2818
(UP_TYPE)LIT_PREFIX##_MAX); \
29-
return __CLC_CONVERT_TY(clamped_mad, TYPE); \
19+
return __clc_convert_##TYPE(clamped_mad); \
3020
}
3121

3222
#define __CLC_DEFINE_SIMPLE_MAD_SAT_ALL_TYS(TYPE, UP_TYPE, LIT_PREFIX) \
3323
__CLC_DEFINE_SIMPLE_MAD_SAT(TYPE, UP_TYPE, LIT_PREFIX) \
34-
__CLC_DEFINE_SIMPLE_MAD_SAT_VEC(TYPE##2, UP_TYPE##2, LIT_PREFIX) \
35-
__CLC_DEFINE_SIMPLE_MAD_SAT_VEC(TYPE##3, UP_TYPE##3, LIT_PREFIX) \
36-
__CLC_DEFINE_SIMPLE_MAD_SAT_VEC(TYPE##4, UP_TYPE##4, LIT_PREFIX) \
37-
__CLC_DEFINE_SIMPLE_MAD_SAT_VEC(TYPE##8, UP_TYPE##8, LIT_PREFIX) \
38-
__CLC_DEFINE_SIMPLE_MAD_SAT_VEC(TYPE##16, UP_TYPE##16, LIT_PREFIX)
24+
__CLC_DEFINE_SIMPLE_MAD_SAT(TYPE##2, UP_TYPE##2, LIT_PREFIX) \
25+
__CLC_DEFINE_SIMPLE_MAD_SAT(TYPE##3, UP_TYPE##3, LIT_PREFIX) \
26+
__CLC_DEFINE_SIMPLE_MAD_SAT(TYPE##4, UP_TYPE##4, LIT_PREFIX) \
27+
__CLC_DEFINE_SIMPLE_MAD_SAT(TYPE##8, UP_TYPE##8, LIT_PREFIX) \
28+
__CLC_DEFINE_SIMPLE_MAD_SAT(TYPE##16, UP_TYPE##16, LIT_PREFIX)
3929

4030
__CLC_DEFINE_SIMPLE_MAD_SAT_ALL_TYS(char, int, CHAR)
4131
__CLC_DEFINE_SIMPLE_MAD_SAT_ALL_TYS(uchar, uint, UCHAR)
@@ -67,20 +57,13 @@ __CLC_DEFINE_UINTLONG_MAD_SAT_ALL_TYS(ulong, long, ULONG)
6757
INTTY mhi = __clc_mul_hi(x, y); \
6858
UINTTY mlo = __clc_as_##UINTTY(x * y); \
6959
SLONGTY m = __clc_upsample(mhi, mlo); \
70-
m += __CLC_CONVERT_TY(z, SLONGTY); \
60+
m += __clc_convert_##SLONGTY(z); \
7161
m = __clc_clamp(m, (SLONGTY)INT_MIN, (SLONGTY)INT_MAX); \
72-
return __CLC_CONVERT_TY(m, INTTY); \
62+
return __clc_convert_##INTTY(m); \
7363
}
7464

75-
// FIXME: Once using __clc_convert_ty, can easily unify scalar and vector defs
7665
#define __CLC_DEFINE_SINT_MAD_SAT_ALL_TYS(INTTY, UINTTY, SLONGTY) \
77-
_CLC_OVERLOAD _CLC_DEF INTTY __clc_mad_sat(INTTY x, INTTY y, INTTY z) { \
78-
INTTY mhi = __clc_mul_hi(x, y); \
79-
UINTTY mlo = __clc_as_##UINTTY(x * y); \
80-
SLONGTY m = __clc_upsample(mhi, mlo); \
81-
m += z; \
82-
return __clc_clamp(m, (SLONGTY)INT_MIN, (SLONGTY)INT_MAX); \
83-
} \
66+
__CLC_DEFINE_SINT_MAD_SAT(INTTY, UINTTY, SLONGTY) \
8467
__CLC_DEFINE_SINT_MAD_SAT(INTTY##2, UINTTY##2, SLONGTY##2) \
8568
__CLC_DEFINE_SINT_MAD_SAT(INTTY##3, UINTTY##3, SLONGTY##3) \
8669
__CLC_DEFINE_SINT_MAD_SAT(INTTY##4, UINTTY##4, SLONGTY##4) \

‎libclc/clc/lib/generic/integer/clc_mul_hi.cl

Lines changed: 12 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1,31 +1,24 @@
1+
#include <clc/clc_convert.h>
12
#include <clc/integer/clc_hadd.h>
23
#include <clc/integer/definitions.h>
34
#include <clc/internal/clc.h>
45

5-
// TODO: Replace with __clc_convert_<type> when available
6-
#define __CLC_CONVERT_TY(X, TY) __builtin_convertvector(X, TY)
7-
8-
#define __CLC_MUL_HI_VEC_IMPL(BGENTYPE, GENTYPE, GENSIZE) \
9-
_CLC_OVERLOAD _CLC_DEF GENTYPE __clc_mul_hi(GENTYPE x, GENTYPE y) { \
10-
BGENTYPE large_x = __CLC_CONVERT_TY(x, BGENTYPE); \
11-
BGENTYPE large_y = __CLC_CONVERT_TY(y, BGENTYPE); \
12-
BGENTYPE large_mul_hi = (large_x * large_y) >> (BGENTYPE)GENSIZE; \
13-
return __CLC_CONVERT_TY(large_mul_hi, GENTYPE); \
14-
}
15-
166
// For all types EXCEPT long, which is implemented separately
177
#define __CLC_MUL_HI_IMPL(BGENTYPE, GENTYPE, GENSIZE) \
188
_CLC_OVERLOAD _CLC_DEF GENTYPE __clc_mul_hi(GENTYPE x, GENTYPE y) { \
19-
return (GENTYPE)(((BGENTYPE)x * (BGENTYPE)y) >> GENSIZE); \
9+
BGENTYPE large_x = __clc_convert_##BGENTYPE(x); \
10+
BGENTYPE large_y = __clc_convert_##BGENTYPE(y); \
11+
BGENTYPE large_mul_hi = (large_x * large_y) >> (BGENTYPE)GENSIZE; \
12+
return __clc_convert_##GENTYPE(large_mul_hi); \
2013
}
2114

2215
#define __CLC_MUL_HI_DEC_IMPL(BTYPE, TYPE, BITS) \
2316
__CLC_MUL_HI_IMPL(BTYPE, TYPE, BITS) \
24-
__CLC_MUL_HI_VEC_IMPL(BTYPE##2, TYPE##2, BITS) \
25-
__CLC_MUL_HI_VEC_IMPL(BTYPE##3, TYPE##3, BITS) \
26-
__CLC_MUL_HI_VEC_IMPL(BTYPE##4, TYPE##4, BITS) \
27-
__CLC_MUL_HI_VEC_IMPL(BTYPE##8, TYPE##8, BITS) \
28-
__CLC_MUL_HI_VEC_IMPL(BTYPE##16, TYPE##16, BITS)
17+
__CLC_MUL_HI_IMPL(BTYPE##2, TYPE##2, BITS) \
18+
__CLC_MUL_HI_IMPL(BTYPE##3, TYPE##3, BITS) \
19+
__CLC_MUL_HI_IMPL(BTYPE##4, TYPE##4, BITS) \
20+
__CLC_MUL_HI_IMPL(BTYPE##8, TYPE##8, BITS) \
21+
__CLC_MUL_HI_IMPL(BTYPE##16, TYPE##16, BITS)
2922

3023
_CLC_OVERLOAD _CLC_DEF long __clc_mul_hi(long x, long y) {
3124
long f, o, i;
@@ -98,8 +91,8 @@ _CLC_OVERLOAD _CLC_DEF ulong __clc_mul_hi(ulong x, ulong y) {
9891
f = x_hi * y_hi; \
9992
o = x_hi * y_lo; \
10093
i = x_lo * y_hi; \
101-
l = __CLC_CONVERT_TY(x_lo * y_lo, UTY); \
102-
i += __CLC_CONVERT_TY(l >> (UTY)32, TY); \
94+
l = __clc_convert_##UTY(x_lo * y_lo); \
95+
i += __clc_convert_##TY(l >> (UTY)32); \
10396
\
10497
return f + (__clc_hadd(o, i) >> (TY)31); \
10598
}
@@ -128,5 +121,3 @@ __CLC_MUL_HI_TYPES()
128121
#undef __CLC_MUL_HI_LONG_VEC_IMPL
129122
#undef __CLC_MUL_HI_DEC_IMPL
130123
#undef __CLC_MUL_HI_IMPL
131-
#undef __CLC_MUL_HI_VEC_IMPL
132-
#undef __CLC_CONVERT_TY

‎libclc/clc/lib/generic/integer/clc_upsample.cl

Lines changed: 18 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,35 +1,31 @@
1+
#include <clc/clc_convert.h>
12
#include <clc/internal/clc.h>
23

3-
// TODO: Replace with __clc_convert_<type> when available
4-
#define __CLC_CONVERT_TY(X, TY) __builtin_convertvector(X, TY)
5-
6-
#define __CLC_UPSAMPLE_VEC_IMPL(BGENTYPE, GENTYPE, UGENTYPE, GENSIZE) \
4+
#define __CLC_UPSAMPLE_IMPL(BGENTYPE, GENTYPE, UGENTYPE, GENSIZE) \
75
_CLC_OVERLOAD _CLC_DEF BGENTYPE __clc_upsample(GENTYPE hi, UGENTYPE lo) { \
8-
BGENTYPE large_hi = __CLC_CONVERT_TY(hi, BGENTYPE); \
9-
BGENTYPE large_lo = __CLC_CONVERT_TY(lo, BGENTYPE); \
6+
BGENTYPE large_hi = __clc_convert_##BGENTYPE(hi); \
7+
BGENTYPE large_lo = __clc_convert_##BGENTYPE(lo); \
108
return (large_hi << (BGENTYPE)GENSIZE) | large_lo; \
119
}
1210

13-
#define __CLC_UPSAMPLE_IMPL(BGENTYPE, GENTYPE, UGENTYPE, GENSIZE) \
14-
_CLC_OVERLOAD _CLC_DEF BGENTYPE __clc_upsample(GENTYPE hi, UGENTYPE lo) { \
15-
return ((BGENTYPE)hi << GENSIZE) | lo; \
16-
} \
17-
__CLC_UPSAMPLE_VEC_IMPL(BGENTYPE##2, GENTYPE##2, UGENTYPE##2, GENSIZE) \
18-
__CLC_UPSAMPLE_VEC_IMPL(BGENTYPE##3, GENTYPE##3, UGENTYPE##3, GENSIZE) \
19-
__CLC_UPSAMPLE_VEC_IMPL(BGENTYPE##4, GENTYPE##4, UGENTYPE##4, GENSIZE) \
20-
__CLC_UPSAMPLE_VEC_IMPL(BGENTYPE##8, GENTYPE##8, UGENTYPE##8, GENSIZE) \
21-
__CLC_UPSAMPLE_VEC_IMPL(BGENTYPE##16, GENTYPE##16, UGENTYPE##16, GENSIZE)
11+
#define __CLC_UPSAMPLE_IMPL_ALL_VEC_SIZES(BGENTYPE, GENTYPE, UGENTYPE, \
12+
GENSIZE) \
13+
__CLC_UPSAMPLE_IMPL(BGENTYPE, GENTYPE, UGENTYPE, GENSIZE) \
14+
__CLC_UPSAMPLE_IMPL(BGENTYPE##2, GENTYPE##2, UGENTYPE##2, GENSIZE) \
15+
__CLC_UPSAMPLE_IMPL(BGENTYPE##3, GENTYPE##3, UGENTYPE##3, GENSIZE) \
16+
__CLC_UPSAMPLE_IMPL(BGENTYPE##4, GENTYPE##4, UGENTYPE##4, GENSIZE) \
17+
__CLC_UPSAMPLE_IMPL(BGENTYPE##8, GENTYPE##8, UGENTYPE##8, GENSIZE) \
18+
__CLC_UPSAMPLE_IMPL(BGENTYPE##16, GENTYPE##16, UGENTYPE##16, GENSIZE)
2219

2320
#define __CLC_UPSAMPLE_TYPES() \
24-
__CLC_UPSAMPLE_IMPL(short, char, uchar, 8) \
25-
__CLC_UPSAMPLE_IMPL(ushort, uchar, uchar, 8) \
26-
__CLC_UPSAMPLE_IMPL(int, short, ushort, 16) \
27-
__CLC_UPSAMPLE_IMPL(uint, ushort, ushort, 16) \
28-
__CLC_UPSAMPLE_IMPL(long, int, uint, 32) \
29-
__CLC_UPSAMPLE_IMPL(ulong, uint, uint, 32)
21+
__CLC_UPSAMPLE_IMPL_ALL_VEC_SIZES(short, char, uchar, 8) \
22+
__CLC_UPSAMPLE_IMPL_ALL_VEC_SIZES(ushort, uchar, uchar, 8) \
23+
__CLC_UPSAMPLE_IMPL_ALL_VEC_SIZES(int, short, ushort, 16) \
24+
__CLC_UPSAMPLE_IMPL_ALL_VEC_SIZES(uint, ushort, ushort, 16) \
25+
__CLC_UPSAMPLE_IMPL_ALL_VEC_SIZES(long, int, uint, 32) \
26+
__CLC_UPSAMPLE_IMPL_ALL_VEC_SIZES(ulong, uint, uint, 32)
3027

3128
__CLC_UPSAMPLE_TYPES()
3229

3330
#undef __CLC_UPSAMPLE_TYPES
3431
#undef __CLC_UPSAMPLE_IMPL
35-
#undef __CLC_CONVERT_TY

‎libclc/generic/lib/math/clc_exp10.cl

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@
2121
*/
2222

2323
#include <clc/clc.h>
24+
#include <clc/clc_convert.h>
2425
#include <clc/clcmacro.h>
2526
#include <clc/math/clc_mad.h>
2627
#include <clc/math/clc_subnormal_config.h>
@@ -70,7 +71,7 @@ _CLC_DEF _CLC_OVERLOAD float __clc_exp10(float x) {
7071
int return_inf = x > X_MAX;
7172
int return_zero = x < X_MIN;
7273

73-
int n = convert_int(x * R_64_BY_LOG10_2);
74+
int n = __clc_convert_int(x * R_64_BY_LOG10_2);
7475

7576
float fn = (float)n;
7677
int j = n & 0x3f;
@@ -89,11 +90,11 @@ _CLC_DEF _CLC_OVERLOAD float __clc_exp10(float x) {
8990
float two_to_jby64 = USE_TABLE(exp_tbl, j);
9091
z2 = __clc_mad(two_to_jby64, z2, two_to_jby64);
9192

92-
float z2s = z2 * as_float(0x1 << (m + 149));
93-
float z2n = as_float(as_int(z2) + m2);
93+
float z2s = z2 * __clc_as_float(0x1 << (m + 149));
94+
float z2n = __clc_as_float(__clc_as_int(z2) + m2);
9495
z2 = m <= -126 ? z2s : z2n;
9596

96-
z2 = return_inf ? as_float(PINFBITPATT_SP32) : z2;
97+
z2 = return_inf ? __clc_as_float(PINFBITPATT_SP32) : z2;
9798
z2 = return_zero ? 0.0f : z2;
9899
z2 = return_nan ? x : z2;
99100
return z2;
@@ -115,7 +116,7 @@ _CLC_DEF _CLC_OVERLOAD double __clc_exp10(double x) {
115116
// ln(10)
116117
const double R_LN10 = 0x1.26bb1bbb55516p+1;
117118

118-
int n = convert_int(x * R_64_BY_LOG10_2);
119+
int n = __clc_convert_int(x * R_64_BY_LOG10_2);
119120

120121
double dn = (double)n;
121122

@@ -144,15 +145,15 @@ _CLC_DEF _CLC_OVERLOAD double __clc_exp10(double x) {
144145

145146
int n1 = m >> 2;
146147
int n2 = m - n1;
147-
double z3 = z2 * as_double(((long)n1 + 1023) << 52);
148-
z3 *= as_double(((long)n2 + 1023) << 52);
148+
double z3 = z2 * __clc_as_double(((long)n1 + 1023) << 52);
149+
z3 *= __clc_as_double(((long)n2 + 1023) << 52);
149150

150151
z2 = ldexp(z2, m);
151152
z2 = small_value ? z3 : z2;
152153

153154
z2 = __clc_isnan(x) ? x : z2;
154155

155-
z2 = x > X_MAX ? as_double(PINFBITPATT_DP64) : z2;
156+
z2 = x > X_MAX ? __clc_as_double(PINFBITPATT_DP64) : z2;
156157
z2 = x < X_MIN ? 0.0 : z2;
157158

158159
return z2;

‎libclc/generic/lib/math/clc_fmod.cl

Lines changed: 21 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@
2121
*/
2222

2323
#include <clc/clc.h>
24+
#include <clc/clc_convert.h>
2425
#include <clc/clcmacro.h>
2526
#include <clc/integer/clc_clz.h>
2627
#include <clc/math/clc_floor.h>
@@ -31,19 +32,19 @@
3132
#include <math/clc_remainder.h>
3233

3334
_CLC_DEF _CLC_OVERLOAD float __clc_fmod(float x, float y) {
34-
int ux = as_int(x);
35+
int ux = __clc_as_int(x);
3536
int ax = ux & EXSIGNBIT_SP32;
36-
float xa = as_float(ax);
37+
float xa = __clc_as_float(ax);
3738
int sx = ux ^ ax;
3839
int ex = ax >> EXPSHIFTBITS_SP32;
3940

40-
int uy = as_int(y);
41+
int uy = __clc_as_int(y);
4142
int ay = uy & EXSIGNBIT_SP32;
42-
float ya = as_float(ay);
43+
float ya = __clc_as_float(ay);
4344
int ey = ay >> EXPSHIFTBITS_SP32;
4445

45-
float xr = as_float(0x3f800000 | (ax & 0x007fffff));
46-
float yr = as_float(0x3f800000 | (ay & 0x007fffff));
46+
float xr = __clc_as_float(0x3f800000 | (ax & 0x007fffff));
47+
float yr = __clc_as_float(0x3f800000 | (ay & 0x007fffff));
4748
int c;
4849
int k = ex - ey;
4950

@@ -62,36 +63,36 @@ _CLC_DEF _CLC_OVERLOAD float __clc_fmod(float x, float y) {
6263
xr = lt ? xa : xr;
6364
yr = lt ? ya : yr;
6465

65-
float s = as_float(ey << EXPSHIFTBITS_SP32);
66+
float s = __clc_as_float(ey << EXPSHIFTBITS_SP32);
6667
xr *= lt ? 1.0f : s;
6768

6869
c = ax == ay;
6970
xr = c ? 0.0f : xr;
7071

71-
xr = as_float(sx ^ as_int(xr));
72+
xr = __clc_as_float(sx ^ __clc_as_int(xr));
7273

7374
c = ax > PINFBITPATT_SP32 | ay > PINFBITPATT_SP32 | ax == PINFBITPATT_SP32 |
7475
ay == 0;
75-
xr = c ? as_float(QNANBITPATT_SP32) : xr;
76+
xr = c ? __clc_as_float(QNANBITPATT_SP32) : xr;
7677

7778
return xr;
7879
}
7980
_CLC_BINARY_VECTORIZE(_CLC_DEF _CLC_OVERLOAD, float, __clc_fmod, float, float);
8081

8182
#ifdef cl_khr_fp64
8283
_CLC_DEF _CLC_OVERLOAD double __clc_fmod(double x, double y) {
83-
ulong ux = as_ulong(x);
84+
ulong ux = __clc_as_ulong(x);
8485
ulong ax = ux & ~SIGNBIT_DP64;
8586
ulong xsgn = ux ^ ax;
86-
double dx = as_double(ax);
87-
int xexp = convert_int(ax >> EXPSHIFTBITS_DP64);
87+
double dx = __clc_as_double(ax);
88+
int xexp = __clc_convert_int(ax >> EXPSHIFTBITS_DP64);
8889
int xexp1 = 11 - (int)__clc_clz(ax & MANTBITS_DP64);
8990
xexp1 = xexp < 1 ? xexp1 : xexp;
9091

91-
ulong uy = as_ulong(y);
92+
ulong uy = __clc_as_ulong(y);
9293
ulong ay = uy & ~SIGNBIT_DP64;
93-
double dy = as_double(ay);
94-
int yexp = convert_int(ay >> EXPSHIFTBITS_DP64);
94+
double dy = __clc_as_double(ay);
95+
int yexp = __clc_convert_int(ay >> EXPSHIFTBITS_DP64);
9596
int yexp1 = 11 - (int)__clc_clz(ay & MANTBITS_DP64);
9697
yexp1 = yexp < 1 ? yexp1 : yexp;
9798

@@ -151,12 +152,12 @@ _CLC_DEF _CLC_OVERLOAD double __clc_fmod(double x, double y) {
151152
dx += i ? w : 0.0;
152153

153154
// At this point, dx lies in the range [0,dy)
154-
double ret = as_double(xsgn ^ as_ulong(dx));
155-
dx = as_double(ax);
155+
double ret = __clc_as_double(xsgn ^ __clc_as_ulong(dx));
156+
dx = __clc_as_double(ax);
156157

157158
// Now handle |x| == |y|
158159
int c = dx == dy;
159-
t = as_double(xsgn);
160+
t = __clc_as_double(xsgn);
160161
ret = c ? t : ret;
161162

162163
// Next, handle |x| < |y|
@@ -167,7 +168,7 @@ _CLC_DEF _CLC_OVERLOAD double __clc_fmod(double x, double y) {
167168

168169
// |y| is 0
169170
c = dy == 0.0;
170-
ret = c ? as_double(QNANBITPATT_DP64) : ret;
171+
ret = c ? __clc_as_double(QNANBITPATT_DP64) : ret;
171172

172173
// y is +-Inf, NaN
173174
c = yexp > BIASEDEMAX_DP64;
@@ -176,7 +177,7 @@ _CLC_DEF _CLC_OVERLOAD double __clc_fmod(double x, double y) {
176177

177178
// x is +=Inf, NaN
178179
c = xexp > BIASEDEMAX_DP64;
179-
ret = c ? as_double(QNANBITPATT_DP64) : ret;
180+
ret = c ? __clc_as_double(QNANBITPATT_DP64) : ret;
180181

181182
return ret;
182183
}

0 commit comments

Comments
 (0)