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