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
|
//===--------------------------- 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>
enum EXPECTED_RESULT {
LESS_0, LESS_EQUAL_0, EQUAL_0, GREATER_0, GREATER_EQUAL_0, NEQUAL_0
};
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;
}
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;
}
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;
}
static inline __uint128_t toRep128(long double x)
{
__uint128_t ret;
memcpy(&ret, &x, 16);
return ret;
}
static inline int compareResultF(float result,
uint32_t expected)
{
uint32_t rep = toRep32(result);
if (rep == expected){
return 0;
}
// test other posible 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 posible NaN representation(signal NaN)
else if (expected == 0x7ff8000000000000UL){
if ((rep & 0x7ff0000000000000UL) == 0x7ff0000000000000UL &&
(rep & 0xfffffffffffffUL) > 0){
return 0;
}
}
return 1;
}
// 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 posible NaN representation(signal NaN)
else if (expectedHi == 0x7fff800000000000UL && expectedLo == 0x0UL){
if ((hi & 0x7fff000000000000UL) == 0x7fff000000000000UL &&
((hi & 0xffffffffffffUL) > 0 || lo > 0)){
return 0;
}
}
return 1;
}
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 float makeQNaN32()
{
return fromRep32(0x7fc00000U);
}
static inline double makeQNaN64()
{
return fromRep64(0x7ff8000000000000UL);
}
static inline long double makeQNaN128()
{
return fromRep128(0x7fff800000000000UL, 0x0UL);
}
static inline float makeNaN32(uint32_t rand)
{
return fromRep32(0x7f800000U | (rand & 0x7fffffU));
}
static inline double makeNaN64(uint64_t rand)
{
return fromRep64(0x7ff0000000000000UL | (rand & 0xfffffffffffffUL));
}
static inline long double makeNaN128(uint64_t rand)
{
return fromRep128(0x7fff000000000000UL | (rand & 0xffffffffffffUL), 0x0UL);
}
static inline float makeInf32()
{
return fromRep32(0x7f800000U);
}
static inline double makeInf64()
{
return fromRep64(0x7ff0000000000000UL);
}
static inline long double makeInf128()
{
return fromRep128(0x7fff000000000000UL, 0x0UL);
}
|
