Skip to content

Commit 3feeef3

Browse files
DavidSpickettDavidSpickett
committed
Revert "Tests for additional builtin classification functions (#59)"
This reverts commit 3ed1fbb due to failures in the new tests on Arm and AArch64. ``` cd /home/tcwg-buildbot/worker/clang-aarch64-global-isel/test/sandbox/build/SingleSource/UnitTests && /home/tcwg-buildbot/worker/clang-aarch64-global-isel/stage1.install/bin/llvm-size --format=sysv /home/tcwg-buildbot/worker/clang-aarch64-global-isel/test/sandbox/build/SingleSource/UnitTests/testcase-CGExprConstant > /home/tcwg-buildbot/worker/clang-aarch64-global-isel/test/sandbox/build/SingleSource/UnitTests/testcase-CGExprConstant.size | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~ 38 | (value)) | ~~~~~~~~ /home/tcwg-buildbot/worker/clang-aarch64-global-isel/test/test-suite/SingleSource/UnitTests/Float/test_isfpclass.h:28:11: note: expanded from macro 'CHECK_CLASS' 28 | if (!(cond)) { \ | ^~~~ /home/tcwg-buildbot/worker/clang-aarch64-global-isel/test/test-suite/SingleSource/UnitTests/Float/test_isfpclass.h:58:3: error: floating point classification requires argument of floating point type (passed in 'int') ``` https://lab.llvm.org/buildbot/#/builders/183/builds/18017 https://lab.llvm.org/buildbot/#/builders/186/builds/13698
1 parent 3ed1fbb commit 3feeef3

File tree

9 files changed

+251
-943
lines changed

9 files changed

+251
-943
lines changed

‎SingleSource/UnitTests/Float/check-helper.h‎

Lines changed: 35 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -15,38 +15,46 @@
1515

1616
#define DimOf(x) (sizeof(x) / sizeof(x[0]))
1717

18-
// Prints bits of a floating-point value, specified by the parameter 'value'.
19-
// 'value' may an integer or a pointer to integer, the exact meaning is
20-
// determined by macros VAL_FORMAT and GET_VALUE.
18+
// Checks if condition 'cond' is true for the 'value'.
2119
//
2220
// Requires the following macros to be defined:
2321
//
24-
// VAL_FORMAT - printf format specifier, like "%d" or "%llx %llx", which
25-
// should be used to print the value represented by the
26-
// argument 'value'.
27-
// GET_VALUE - a macro that extracts the value or values for printing
28-
// the 'value'.
22+
// VAL_FORMAT - printf format specifier without %, like "d" or "llx", which
23+
// should be used to print 'value'.
2924
//
30-
#define PRINT_VALUE(value) printf(VAL_FORMAT, GET_VALUE(value));
25+
#define CHECK_VALUE(cond, value) \
26+
do { \
27+
if (!(cond)) { \
28+
printf("Check '%s' in file '%s' at line %d " \
29+
"failed for the value '%" VAL_FORMAT "'\n", \
30+
#cond, __FILE__, __LINE__, (value)); \
31+
exit(-1); \
32+
} \
33+
} while(0)
3134

32-
// Checks if condition 'cond' is true for the 'value'.
33-
//
34-
// The argument 'value' is a pointer to the bits representing the tested
35-
// floating-point value. It does not participate in checks and is used only for
36-
// printing the tested value in diagnostics. Actual value to print is obtained
37-
// using macro 'GET_VALUE'.
35+
// Checks if floating point 'value' is equal to the value 'expected' which is an
36+
// integer that represents bits of floating point number.
3837
//
39-
// Macros required to be defined are same as for PRINT_VALUE.
38+
// Requires the following macros to be defined:
4039
//
41-
#define CHECK_VALUE(cond, value) \
42-
do { \
43-
if (!(cond)) { \
44-
printf("Check '%s' in file '%s' at line %d failed for the value '", \
45-
#cond, __FILE__, __LINE__); \
46-
PRINT_VALUE(value); \
47-
printf("'\n"); \
48-
exit(-1); \
49-
} \
50-
} while (0)
51-
40+
// INT_FORMAT - printf format specifier without %, like "d" or "llx",
41+
// which should be used to print 'expected'.
42+
// FLOAT_FORMAT - printf format specifier without % to print 'value'.
43+
// INT_TYPE - type of 'expected'.
44+
// FLOAT_TYPE - type of 'value'.
45+
//
46+
#define CHECK_EQ(value, expected) \
47+
do { \
48+
union { \
49+
INT_TYPE i; \
50+
FLOAT_TYPE f; \
51+
} u; \
52+
u.i = (value); \
53+
if (u.f != (expected)) { \
54+
printf("Check in file '%s' at line %d failed: " \
55+
"'%" INT_FORMAT "' != '%" FLOAT_FORMAT "'\n", \
56+
__FILE__, __LINE__, (INT_TYPE)(value), (expected)); \
57+
exit(-1); \
58+
} \
59+
} while(0)
5260
#endif

‎SingleSource/UnitTests/Float/classify-f32.h‎

Lines changed: 84 additions & 108 deletions
Original file line numberDiff line numberDiff line change
@@ -19,8 +19,12 @@
1919
#include <stdio.h>
2020
#include <stdlib.h>
2121

22-
#define VAL_FORMAT "%" PRIx32
23-
#define GET_VALUE(x) (*(uint32_t *)x)
22+
23+
#define INT_FORMAT PRIx32
24+
#define FLOAT_FORMAT "g"
25+
#define VAL_FORMAT INT_FORMAT
26+
#define INT_TYPE uint32_t
27+
#define FLOAT_TYPE float
2428

2529
uint32_t FloatQNaNValues[] = {
2630
F32_MAKE(0, F32_EXP_MASK, F32_QNAN_BIT | F32_PAYLOAD_MASK),
@@ -33,25 +37,28 @@ uint32_t FloatQNaNValues[] = {
3337
F32_MAKE(1, F32_EXP_MASK, F32_QNAN_BIT | 0x00100000U),
3438

3539
F32_MAKE(0, F32_EXP_MASK, F32_QNAN_BIT | 0x00000001U),
36-
F32_MAKE(1, F32_EXP_MASK, F32_QNAN_BIT | 0x00000002U)};
40+
F32_MAKE(1, F32_EXP_MASK, F32_QNAN_BIT | 0x00000002U)
41+
};
3742

38-
uint32_t FloatSNaNValues[] = {F32_MAKE(0, F32_EXP_MASK, F32_PAYLOAD_MASK),
39-
F32_MAKE(1, F32_EXP_MASK, F32_PAYLOAD_MASK),
43+
uint32_t FloatSNaNValues[] = {
44+
F32_MAKE(0, F32_EXP_MASK, F32_PAYLOAD_MASK),
45+
F32_MAKE(1, F32_EXP_MASK, F32_PAYLOAD_MASK),
4046

41-
F32_MAKE(0, F32_EXP_MASK, 0x00200000U),
42-
F32_MAKE(1, F32_EXP_MASK, 0x00100000U),
47+
F32_MAKE(0, F32_EXP_MASK, 0x00200000U),
48+
F32_MAKE(1, F32_EXP_MASK, 0x00100000U),
4349

44-
F32_MAKE(0, F32_EXP_MASK, 0x00000001U),
45-
F32_MAKE(1, F32_EXP_MASK, 0x00000002U)};
50+
F32_MAKE(0, F32_EXP_MASK, 0x00000001U),
51+
F32_MAKE(1, F32_EXP_MASK, 0x00000002U)
52+
};
4653

4754
uint32_t FloatInfValues[] = {
48-
F32_MAKE(0, F32_EXP_MASK, 0), // +Inf
49-
F32_MAKE(1, F32_EXP_MASK, 0) // -Inf
55+
F32_MAKE(0, F32_EXP_MASK, 0), // +Inf
56+
F32_MAKE(1, F32_EXP_MASK, 0) // -Inf
5057
};
5158

5259
uint32_t FloatZeroValues[] = {
53-
F32_MAKE(0, 0, 0), // +0.0
54-
F32_MAKE(1, 0, 0) // -0.0
60+
F32_MAKE(0, 0, 0), // +0.0
61+
F32_MAKE(1, 0, 0) // -0.0
5562
};
5663

5764
uint32_t FloatDenormValues[] = {
@@ -94,130 +101,99 @@ uint32_t FloatNormalValues[] = {
94101
};
95102

96103
int test_float() {
104+
CHECK_EQ(F32_NORMAL(0, 0, 0), 1.0F);
105+
CHECK_EQ(F32_NORMAL(0, 0, F32_MANTISSA(1, 0, 0)), 1.5F);
106+
CHECK_EQ(F32_NORMAL(0, 0, F32_MANTISSA(0, 1, 0)), 1.25F);
107+
CHECK_EQ(F32_NORMAL(0, 0, F32_MANTISSA(0, 0, 1)), 1.125);
108+
CHECK_EQ(F32_NORMAL(0, -1, 0), 0.5F);
109+
CHECK_EQ(F32_NORMAL(0, -2, 0), 0.25);
110+
CHECK_EQ(F32_NORMAL(0, -3, 0), 0.125);
111+
CHECK_EQ(F32_NORMAL(0, 1, 0), 2.0F);
112+
CHECK_EQ(F32_NORMAL(0, 1, F32_MANTISSA(1, 0, 0)), 3.0F);
113+
114+
CHECK_EQ(F32_NORMAL(1, 0, 0), -1.0F);
115+
CHECK_EQ(F32_NORMAL(1, 0, F32_MANTISSA(1, 0, 0)), -1.5F);
116+
CHECK_EQ(F32_NORMAL(1, 0, F32_MANTISSA(0, 1, 0)), -1.25F);
117+
CHECK_EQ(F32_NORMAL(1, 0, F32_MANTISSA(0, 0, 1)), -1.125);
118+
CHECK_EQ(F32_NORMAL(1, -1, 0), -0.5F);
119+
CHECK_EQ(F32_NORMAL(1, -2, 0), -0.25);
120+
CHECK_EQ(F32_NORMAL(1, -3, 0), -0.125);
121+
CHECK_EQ(F32_NORMAL(1, 1, 0), -2.0F);
122+
CHECK_EQ(F32_NORMAL(1, 1, F32_MANTISSA(1, 0, 0)), -3.0F);
123+
124+
CHECK_EQ(F32_NORMAL(0, F32_EXP_MIN, 0), 1.1754943508e-38F);
125+
CHECK_EQ(F32_NORMAL(1, F32_EXP_MIN, 0), -1.1754943508e-38F);
126+
CHECK_EQ(F32_NORMAL(0, F32_EXP_MAX, F32_MANTISSA_MASK), 3.4028234664e38F);
127+
CHECK_EQ(F32_NORMAL(1, F32_EXP_MAX, F32_MANTISSA_MASK), -3.4028234664e38F);
128+
97129
for (unsigned i = 0; i < DimOf(FloatQNaNValues); i++) {
98130
uint32_t *IPtr = FloatQNaNValues + i;
131+
uint32_t IX = *IPtr;
99132
float X = *(float *)IPtr;
100-
CHECK_VALUE(__builtin_isnan(X), IPtr);
101-
CHECK_VALUE(!__builtin_issignaling(X), IPtr);
102-
CHECK_VALUE(!__builtin_isinf(X), IPtr);
103-
CHECK_VALUE(!__builtin_isfinite(X), IPtr);
104-
CHECK_VALUE(!__builtin_isnormal(X), IPtr);
105-
CHECK_VALUE(!__builtin_issubnormal(X), IPtr);
106-
CHECK_VALUE(!__builtin_iszero(X), IPtr);
107-
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 0, IPtr);
133+
CHECK_VALUE(__builtin_isnan(X), IX);
134+
CHECK_VALUE(!__builtin_isinf(X), IX);
135+
CHECK_VALUE(!__builtin_isfinite(X), IX);
136+
CHECK_VALUE(!__builtin_isnormal(X), IX);
137+
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 0, IX);
108138
}
109139
for (unsigned i = 0; i < DimOf(FloatSNaNValues); i++) {
110140
uint32_t *IPtr = FloatSNaNValues + i;
141+
uint32_t IX = *IPtr;
111142
float X = *(float *)IPtr;
112-
CHECK_VALUE(__builtin_isnan(X), IPtr);
113-
CHECK_VALUE(__builtin_issignaling(X), IPtr);
114-
CHECK_VALUE(!__builtin_isinf(X), IPtr);
115-
CHECK_VALUE(!__builtin_isfinite(X), IPtr);
116-
CHECK_VALUE(!__builtin_isnormal(X), IPtr);
117-
CHECK_VALUE(!__builtin_issubnormal(X), IPtr);
118-
CHECK_VALUE(!__builtin_iszero(X), IPtr);
119-
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 0, IPtr);
143+
CHECK_VALUE(__builtin_isnan(X), IX);
144+
CHECK_VALUE(!__builtin_isinf(X), IX);
145+
CHECK_VALUE(!__builtin_isfinite(X), IX);
146+
CHECK_VALUE(!__builtin_isnormal(X), IX);
147+
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 0, IX);
120148
}
121149
for (unsigned i = 0; i < DimOf(FloatInfValues); i++) {
122150
uint32_t *IPtr = FloatInfValues + i;
151+
uint32_t IX = *IPtr;
123152
float X = *(float *)IPtr;
124-
CHECK_VALUE(!__builtin_isnan(X), IPtr);
125-
CHECK_VALUE(!__builtin_issignaling(X), IPtr);
126-
CHECK_VALUE(__builtin_isinf(X), IPtr);
127-
CHECK_VALUE(!__builtin_isfinite(X), IPtr);
128-
CHECK_VALUE(!__builtin_isnormal(X), IPtr);
129-
CHECK_VALUE(!__builtin_issubnormal(X), IPtr);
130-
CHECK_VALUE(!__builtin_iszero(X), IPtr);
131-
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 1, IPtr);
153+
CHECK_VALUE(!__builtin_isnan(X), IX);
154+
CHECK_VALUE(__builtin_isinf(X), IX);
155+
CHECK_VALUE(!__builtin_isfinite(X), IX);
156+
CHECK_VALUE(!__builtin_isnormal(X), IX);
157+
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 1, IX);
132158
}
133159
for (unsigned i = 0; i < DimOf(FloatZeroValues); i++) {
134160
uint32_t *IPtr = FloatZeroValues + i;
161+
uint32_t IX = *IPtr;
135162
float X = *(float *)IPtr;
136-
CHECK_VALUE(!__builtin_isnan(X), IPtr);
137-
CHECK_VALUE(!__builtin_issignaling(X), IPtr);
138-
CHECK_VALUE(!__builtin_isinf(X), IPtr);
139-
CHECK_VALUE(__builtin_isfinite(X), IPtr);
140-
CHECK_VALUE(!__builtin_isnormal(X), IPtr);
141-
CHECK_VALUE(!__builtin_issubnormal(X), IPtr);
142-
CHECK_VALUE(__builtin_iszero(X), IPtr);
143-
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 4, IPtr);
163+
CHECK_VALUE(!__builtin_isnan(X), IX);
164+
CHECK_VALUE(!__builtin_isinf(X), IX);
165+
CHECK_VALUE(__builtin_isfinite(X), IX);
166+
CHECK_VALUE(!__builtin_isnormal(X), IX);
167+
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 4, IX);
144168
}
145169
for (unsigned i = 0; i < DimOf(FloatDenormValues); i++) {
146170
uint32_t *IPtr = FloatDenormValues + i;
171+
uint32_t IX = *IPtr;
147172
float X = *(float *)IPtr;
148-
CHECK_VALUE(!__builtin_isnan(X), IPtr);
149-
CHECK_VALUE(!__builtin_issignaling(X), IPtr);
150-
CHECK_VALUE(!__builtin_isinf(X), IPtr);
151-
CHECK_VALUE(__builtin_isfinite(X), IPtr);
152-
CHECK_VALUE(!__builtin_isnormal(X), IPtr);
153-
CHECK_VALUE(__builtin_issubnormal(X), IPtr);
154-
CHECK_VALUE(!__builtin_iszero(X), IPtr);
155-
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 3, IPtr);
173+
CHECK_VALUE(!__builtin_isnan(X), IX);
174+
CHECK_VALUE(!__builtin_isinf(X), IX);
175+
CHECK_VALUE(__builtin_isfinite(X), IX);
176+
CHECK_VALUE(!__builtin_isnormal(X), IX);
177+
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 3, IX);
156178
}
157179
for (unsigned i = 0; i < DimOf(FloatNormalValues); i++) {
158180
uint32_t *IPtr = FloatNormalValues + i;
181+
uint32_t IX = *IPtr;
159182
float X = *(float *)IPtr;
160-
CHECK_VALUE(!__builtin_isnan(X), IPtr);
161-
CHECK_VALUE(!__builtin_issignaling(X), IPtr);
162-
CHECK_VALUE(!__builtin_isinf(X), IPtr);
163-
CHECK_VALUE(__builtin_isfinite(X), IPtr);
164-
CHECK_VALUE(__builtin_isnormal(X), IPtr);
165-
CHECK_VALUE(!__builtin_issubnormal(X), IPtr);
166-
CHECK_VALUE(!__builtin_iszero(X), IPtr);
167-
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 2, IPtr);
183+
CHECK_VALUE(!__builtin_isnan(X), IX);
184+
CHECK_VALUE(!__builtin_isinf(X), IX);
185+
CHECK_VALUE(__builtin_isfinite(X), IX);
186+
CHECK_VALUE(__builtin_isnormal(X), IX);
187+
CHECK_VALUE(__builtin_fpclassify(0, 1, 2, 3, 4, X) == 2, IX);
168188
}
169189

170190
return 0;
171191
}
172192

173-
#define FLOAT_TYPE float
174-
#include "gen_isfpclass_funcs.h"
175-
176-
void test_isfpclass_float() {
177-
for (unsigned i = 0; i < DimOf(FloatZeroValues); i++) {
178-
float X = *(float *)(FloatZeroValues + i);
179-
if (__builtin_signbit(X) == 0)
180-
test_fcPosZero_float(X);
181-
else
182-
test_fcNegZero_float(X);
183-
}
184-
for (unsigned i = 0; i < DimOf(FloatDenormValues); i++) {
185-
float X = *(float *)(FloatDenormValues + i);
186-
if (X < 0)
187-
test_fcNegSubnormal_float(X);
188-
else
189-
test_fcPosSubnormal_float(X);
190-
}
191-
for (unsigned i = 0; i < DimOf(FloatNormalValues); i++) {
192-
float X = *(float *)(FloatNormalValues + i);
193-
if (X < 0)
194-
test_fcNegNormal_float(X);
195-
else
196-
test_fcPosNormal_float(X);
197-
}
198-
for (unsigned i = 0; i < DimOf(FloatInfValues); i++) {
199-
float X = *(float *)(FloatInfValues + i);
200-
if (X > 0)
201-
test_fcPosInf_float(X);
202-
else
203-
test_fcNegInf_float(X);
204-
}
205-
for (unsigned i = 0; i < DimOf(FloatQNaNValues); i++) {
206-
float X = *(float *)(FloatQNaNValues + i);
207-
test_fcQNan_float(X);
208-
}
209-
for (unsigned i = 0; i < DimOf(FloatSNaNValues); i++) {
210-
float X = *(float *)(FloatSNaNValues + i);
211-
test_fcSNan_float(X);
212-
}
213-
test_fcPosInf_float(__builtin_inff());
214-
test_fcNegInf_float(-__builtin_inff());
215-
test_fcPosZero_float(0.0F);
216-
test_fcNegZero_float(-0.0F);
217-
}
218-
193+
#undef INT_FORMAT
194+
#undef FLOAT_FORMAT
219195
#undef VAL_FORMAT
220-
#undef GET_VALUE
196+
#undef INT_TYPE
221197
#undef FLOAT_TYPE
222198

223199
#endif

0 commit comments

Comments
 (0)