1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
//===--------------------------- fp_test.h - ------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines shared functions for the test.
//
//===----------------------------------------------------------------------===//
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <stdint.h>
enum EXPECTED_RESULT {
LESS_0, LESS_EQUAL_0, EQUAL_0, GREATER_0, GREATER_EQUAL_0, NEQUAL_0
};
static inline uint16_t fromRep16(uint16_t x)
{
return x;
}
static inline float fromRep32(uint32_t x)
{
float ret;
memcpy(&ret, &x, 4);
return ret;
}
static inline double fromRep64(uint64_t x)
{
double ret;
memcpy(&ret, &x, 8);
return ret;
}
#if __LDBL_MANT_DIG__ == 113
static inline long double fromRep128(uint64_t hi, uint64_t lo)
{
__uint128_t x = ((__uint128_t)hi << 64) + lo;
long double ret;
memcpy(&ret, &x, 16);
return ret;
}
#endif
static inline uint16_t toRep16(uint16_t x)
{
return x;
}
static inline uint32_t toRep32(float x)
{
uint32_t ret;
memcpy(&ret, &x, 4);
return ret;
}
static inline uint64_t toRep64(double x)
{
uint64_t ret;
memcpy(&ret, &x, 8);
return ret;
}
#if __LDBL_MANT_DIG__ == 113
static inline __uint128_t toRep128(long double x)
{
__uint128_t ret;
memcpy(&ret, &x, 16);
return ret;
}
#endif
static inline int compareResultH(uint16_t result,
uint16_t expected)
{
uint16_t rep = toRep16(result);
if (rep == expected){
return 0;
}
// test other possible NaN representation(signal NaN)
else if (expected == 0x7e00U){
if ((rep & 0x7c00U) == 0x7c00U &&
(rep & 0x3ffU) > 0){
return 0;
}
}
return 1;
}
static inline int compareResultF(float result,
uint32_t expected)
{
uint32_t rep = toRep32(result);
if (rep == expected){
return 0;
}
// test other possible NaN representation(signal NaN)
else if (expected == 0x7fc00000U){
if ((rep & 0x7f800000U) == 0x7f800000U &&
(rep & 0x7fffffU) > 0){
return 0;
}
}
return 1;
}
static inline int compareResultD(double result,
uint64_t expected)
{
uint64_t rep = toRep64(result);
if (rep == expected){
return 0;
}
// test other possible NaN representation(signal NaN)
else if (expected == 0x7ff8000000000000UL){
if ((rep & 0x7ff0000000000000UL) == 0x7ff0000000000000UL &&
(rep & 0xfffffffffffffUL) > 0){
return 0;
}
}
return 1;
}
#if __LDBL_MANT_DIG__ == 113
// return 0 if equal
// use two 64-bit integers intead of one 128-bit integer
// because 128-bit integer constant can't be assigned directly
static inline int compareResultLD(long double result,
uint64_t expectedHi,
uint64_t expectedLo)
{
__uint128_t rep = toRep128(result);
uint64_t hi = rep >> 64;
uint64_t lo = rep;
if (hi == expectedHi && lo == expectedLo){
return 0;
}
// test other possible NaN representation(signal NaN)
else if (expectedHi == 0x7fff800000000000UL && expectedLo == 0x0UL){
if ((hi & 0x7fff000000000000UL) == 0x7fff000000000000UL &&
((hi & 0xffffffffffffUL) > 0 || lo > 0)){
return 0;
}
}
return 1;
}
#endif
static inline int compareResultCMP(int result,
enum EXPECTED_RESULT expected)
{
switch(expected){
case LESS_0:
if (result < 0)
return 0;
break;
case LESS_EQUAL_0:
if (result <= 0)
return 0;
break;
case EQUAL_0:
if (result == 0)
return 0;
break;
case NEQUAL_0:
if (result != 0)
return 0;
break;
case GREATER_EQUAL_0:
if (result >= 0)
return 0;
break;
case GREATER_0:
if (result > 0)
return 0;
break;
default:
return 1;
}
return 1;
}
static inline char *expectedStr(enum EXPECTED_RESULT expected)
{
switch(expected){
case LESS_0:
return "<0";
case LESS_EQUAL_0:
return "<=0";
case EQUAL_0:
return "=0";
case NEQUAL_0:
return "!=0";
case GREATER_EQUAL_0:
return ">=0";
case GREATER_0:
return ">0";
default:
return "";
}
return "";
}
static inline uint16_t makeQNaN16()
{
return fromRep16(0x7e00U);
}
static inline float makeQNaN32()
{
return fromRep32(0x7fc00000U);
}
static inline double makeQNaN64()
{
return fromRep64(0x7ff8000000000000UL);
}
#if __LDBL_MANT_DIG__ == 113
static inline long double makeQNaN128()
{
return fromRep128(0x7fff800000000000UL, 0x0UL);
}
#endif
static inline uint16_t makeNaN16(uint16_t rand)
{
return fromRep16(0x7c00U | (rand & 0x7fffU));
}
static inline float makeNaN32(uint32_t rand)
{
return fromRep32(0x7f800000U | (rand & 0x7fffffU));
}
static inline double makeNaN64(uint64_t rand)
{
return fromRep64(0x7ff0000000000000UL | (rand & 0xfffffffffffffUL));
}
#if __LDBL_MANT_DIG__ == 113
static inline long double makeNaN128(uint64_t rand)
{
return fromRep128(0x7fff000000000000UL | (rand & 0xffffffffffffUL), 0x0UL);
}
#endif
static inline uint16_t makeInf16()
{
return fromRep16(0x7c00U);
}
static inline float makeInf32()
{
return fromRep32(0x7f800000U);
}
static inline double makeInf64()
{
return fromRep64(0x7ff0000000000000UL);
}
#if __LDBL_MANT_DIG__ == 113
static inline long double makeInf128()
{
return fromRep128(0x7fff000000000000UL, 0x0UL);
}
#endif
|
