1 //===-- Unittests for the FPBits class ------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "src/__support/FPUtil/FPBits.h" 10 #include "src/__support/FPUtil/fpbits_str.h" 11 #include "src/__support/big_int.h" 12 #include "src/__support/integer_literals.h" 13 #include "src/__support/macros/properties/types.h" 14 #include "src/__support/sign.h" // Sign 15 #include "test/UnitTest/Test.h" 16 17 using LIBC_NAMESPACE::Sign; 18 using LIBC_NAMESPACE::UInt; 19 using LIBC_NAMESPACE::fputil::FPBits; 20 using LIBC_NAMESPACE::fputil::FPType; 21 using LIBC_NAMESPACE::fputil::internal::FPRep; 22 23 using LIBC_NAMESPACE::operator""_u16; 24 using LIBC_NAMESPACE::operator""_u32; 25 using LIBC_NAMESPACE::operator""_u64; 26 using LIBC_NAMESPACE::operator""_u96; 27 using LIBC_NAMESPACE::operator""_u128; 28 29 TEST(LlvmLibcFPBitsTest, FPType_IEEE754_Binary16) { 30 using Rep = FPRep<FPType::IEEE754_Binary16>; 31 using u16 = typename Rep::StorageType; 32 33 EXPECT_EQ(0b0'00000'0000000000_u16, u16(Rep::zero())); 34 EXPECT_EQ(0b0'01111'0000000000_u16, u16(Rep::one())); 35 EXPECT_EQ(0b0'00000'0000000001_u16, u16(Rep::min_subnormal())); 36 EXPECT_EQ(0b0'00000'1111111111_u16, u16(Rep::max_subnormal())); 37 EXPECT_EQ(0b0'00001'0000000000_u16, u16(Rep::min_normal())); 38 EXPECT_EQ(0b0'11110'1111111111_u16, u16(Rep::max_normal())); 39 EXPECT_EQ(0b0'11111'0000000000_u16, u16(Rep::inf())); 40 EXPECT_EQ(0b0'11111'0100000000_u16, u16(Rep::signaling_nan())); 41 EXPECT_EQ(0b0'11111'1000000000_u16, u16(Rep::quiet_nan())); 42 } 43 44 TEST(LlvmLibcFPBitsTest, FPType_IEEE754_Binary32) { 45 using Rep = FPRep<FPType::IEEE754_Binary32>; 46 using u32 = typename Rep::StorageType; 47 48 EXPECT_EQ(0b0'00000000'00000000000000000000000_u32, u32(Rep::zero())); 49 EXPECT_EQ(0b0'01111111'00000000000000000000000_u32, u32(Rep::one())); 50 EXPECT_EQ(0b0'00000000'00000000000000000000001_u32, 51 u32(Rep::min_subnormal())); 52 EXPECT_EQ(0b0'00000000'11111111111111111111111_u32, 53 u32(Rep::max_subnormal())); 54 EXPECT_EQ(0b0'00000001'00000000000000000000000_u32, u32(Rep::min_normal())); 55 EXPECT_EQ(0b0'11111110'11111111111111111111111_u32, u32(Rep::max_normal())); 56 EXPECT_EQ(0b0'11111111'00000000000000000000000_u32, u32(Rep::inf())); 57 EXPECT_EQ(0b0'11111111'01000000000000000000000_u32, 58 u32(Rep::signaling_nan())); 59 EXPECT_EQ(0b0'11111111'10000000000000000000000_u32, u32(Rep::quiet_nan())); 60 } 61 62 TEST(LlvmLibcFPBitsTest, FPType_IEEE754_Binary64) { 63 using Rep = FPRep<FPType::IEEE754_Binary64>; 64 using u64 = typename Rep::StorageType; 65 66 EXPECT_EQ( 67 0b0'00000000000'0000000000000000000000000000000000000000000000000000_u64, 68 u64(Rep::zero())); 69 EXPECT_EQ( 70 0b0'01111111111'0000000000000000000000000000000000000000000000000000_u64, 71 u64(Rep::one())); 72 EXPECT_EQ( 73 0b0'00000000000'0000000000000000000000000000000000000000000000000001_u64, 74 u64(Rep::min_subnormal())); 75 EXPECT_EQ( 76 0b0'00000000000'1111111111111111111111111111111111111111111111111111_u64, 77 u64(Rep::max_subnormal())); 78 EXPECT_EQ( 79 0b0'00000000001'0000000000000000000000000000000000000000000000000000_u64, 80 u64(Rep::min_normal())); 81 EXPECT_EQ( 82 0b0'11111111110'1111111111111111111111111111111111111111111111111111_u64, 83 u64(Rep::max_normal())); 84 EXPECT_EQ( 85 0b0'11111111111'0000000000000000000000000000000000000000000000000000_u64, 86 u64(Rep::inf())); 87 EXPECT_EQ( 88 0b0'11111111111'0100000000000000000000000000000000000000000000000000_u64, 89 u64(Rep::signaling_nan())); 90 EXPECT_EQ( 91 0b0'11111111111'1000000000000000000000000000000000000000000000000000_u64, 92 u64(Rep::quiet_nan())); 93 } 94 95 TEST(LlvmLibcFPBitsTest, FPType_IEEE754_Binary128) { 96 using Rep = FPRep<FPType::IEEE754_Binary128>; 97 98 EXPECT_EQ( 99 0b0'000000000000000'0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_u128, 100 UInt128(Rep::zero())); 101 EXPECT_EQ( 102 0b0'011111111111111'0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_u128, 103 UInt128(Rep::one())); 104 EXPECT_EQ( 105 0b0'000000000000000'0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001_u128, 106 UInt128(Rep::min_subnormal())); 107 EXPECT_EQ( 108 0b0'000000000000000'1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111_u128, 109 UInt128(Rep::max_subnormal())); 110 EXPECT_EQ( 111 0b0'000000000000001'0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_u128, 112 UInt128(Rep::min_normal())); 113 EXPECT_EQ( 114 0b0'111111111111110'1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111_u128, 115 UInt128(Rep::max_normal())); 116 EXPECT_EQ( 117 0b0'111111111111111'0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_u128, 118 UInt128(Rep::inf())); 119 EXPECT_EQ( 120 0b0'111111111111111'0100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_u128, 121 UInt128(Rep::signaling_nan())); 122 EXPECT_EQ( 123 0b0'111111111111111'1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_u128, 124 UInt128(Rep::quiet_nan())); 125 } 126 127 #ifdef LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80 128 TEST(LlvmLibcFPBitsTest, FPType_X86_Binary80) { 129 using Rep = FPRep<FPType::X86_Binary80>; 130 131 #if __SIZEOF_LONG_DOUBLE__ == 16 132 EXPECT_EQ( 133 0b0'0000000000000000000000000000000000000000000000000000000000000000000000000000000_u128, 134 UInt128(Rep::zero())); 135 EXPECT_EQ( 136 0b0'0111111111111111000000000000000000000000000000000000000000000000000000000000000_u128, 137 UInt128(Rep::one())); 138 EXPECT_EQ( 139 0b0'0000000000000000000000000000000000000000000000000000000000000000000000000000001_u128, 140 UInt128(Rep::min_subnormal())); 141 EXPECT_EQ( 142 0b0'0000000000000000111111111111111111111111111111111111111111111111111111111111111_u128, 143 UInt128(Rep::max_subnormal())); 144 EXPECT_EQ( 145 0b0'0000000000000011000000000000000000000000000000000000000000000000000000000000000_u128, 146 UInt128(Rep::min_normal())); 147 EXPECT_EQ( 148 0b0'1111111111111101111111111111111111111111111111111111111111111111111111111111111_u128, 149 UInt128(Rep::max_normal())); 150 EXPECT_EQ( 151 0b0'1111111111111111000000000000000000000000000000000000000000000000000000000000000_u128, 152 UInt128(Rep::inf())); 153 EXPECT_EQ( 154 0b0'1111111111111111010000000000000000000000000000000000000000000000000000000000000_u128, 155 UInt128(Rep::signaling_nan())); 156 EXPECT_EQ( 157 0b0'1111111111111111100000000000000000000000000000000000000000000000000000000000000_u128, 158 UInt128(Rep::quiet_nan())); 159 #elif __SIZEOF_LONG_DOUBLE__ == 12 160 EXPECT_EQ( 161 0b0'0000000000000000000000000000000000000000000000000000000000000000000000000000000_u96, 162 UInt<96>(Rep::zero())); 163 EXPECT_EQ( 164 0b0'0111111111111111000000000000000000000000000000000000000000000000000000000000000_u96, 165 UInt<96>(Rep::one())); 166 EXPECT_EQ( 167 0b0'0000000000000000000000000000000000000000000000000000000000000000000000000000001_u96, 168 UInt<96>(Rep::min_subnormal())); 169 EXPECT_EQ( 170 0b0'0000000000000000111111111111111111111111111111111111111111111111111111111111111_u96, 171 UInt<96>(Rep::max_subnormal())); 172 EXPECT_EQ( 173 0b0'0000000000000011000000000000000000000000000000000000000000000000000000000000000_u96, 174 UInt<96>(Rep::min_normal())); 175 EXPECT_EQ( 176 0b0'1111111111111101111111111111111111111111111111111111111111111111111111111111111_u96, 177 UInt<96>(Rep::max_normal())); 178 EXPECT_EQ( 179 0b0'1111111111111111000000000000000000000000000000000000000000000000000000000000000_u96, 180 UInt<96>(Rep::inf())); 181 EXPECT_EQ( 182 0b0'1111111111111111010000000000000000000000000000000000000000000000000000000000000_u96, 183 UInt<96>(Rep::signaling_nan())); 184 EXPECT_EQ( 185 0b0'1111111111111111100000000000000000000000000000000000000000000000000000000000000_u96, 186 UInt<96>(Rep::quiet_nan())); 187 #else 188 #error "unhandled long double type" 189 #endif 190 } 191 192 TEST(LlvmLibcFPBitsTest, FPType_X86_Binary80_IsNan) { 193 using Rep = FPRep<FPType::X86_Binary80>; 194 195 #if __SIZEOF_LONG_DOUBLE__ == 16 196 EXPECT_TRUE( // NAN : Pseudo-Infinity 197 Rep(0b0'111111111111111'0000000000000000000000000000000000000000000000000000000000000000_u128) 198 .is_nan()); 199 EXPECT_TRUE( // NAN : Pseudo Not a Number 200 Rep(0b0'111111111111111'0000000000000000000000000000000000000000000000000000000000000001_u128) 201 .is_nan()); 202 EXPECT_TRUE( // NAN : Pseudo Not a Number 203 Rep(0b0'111111111111111'0100000000000000000000000000000000000000000000000000000000000000_u128) 204 .is_nan()); 205 EXPECT_TRUE( // NAN : Signalling Not a Number 206 Rep(0b0'111111111111111'1000000000000000000000000000000000000000000000000000000000000001_u128) 207 .is_nan()); 208 EXPECT_TRUE( // NAN : Floating-point Indefinite 209 Rep(0b0'111111111111111'1100000000000000000000000000000000000000000000000000000000000000_u128) 210 .is_nan()); 211 EXPECT_TRUE( // NAN : Quiet Not a Number 212 Rep(0b0'111111111111111'1100000000000000000000000000000000000000000000000000000000000001_u128) 213 .is_nan()); 214 EXPECT_TRUE( // NAN : Unnormal 215 Rep(0b0'111111111111110'0000000000000000000000000000000000000000000000000000000000000000_u128) 216 .is_nan()); 217 EXPECT_FALSE( // Zero 218 Rep(0b0'000000000000000'0000000000000000000000000000000000000000000000000000000000000000_u128) 219 .is_nan()); 220 EXPECT_FALSE( // Subnormal 221 Rep(0b0'000000000000000'0000000000000000000000000000000000000000000000000000000000000001_u128) 222 .is_nan()); 223 EXPECT_FALSE( // Pseudo Denormal 224 Rep(0b0'000000000000000'1000000000000000000000000000000000000000000000000000000000000001_u128) 225 .is_nan()); 226 EXPECT_FALSE( // Infinity 227 Rep(0b0'111111111111111'1000000000000000000000000000000000000000000000000000000000000000_u128) 228 .is_nan()); 229 EXPECT_FALSE( // Normalized 230 Rep(0b0'111111111111110'1000000000000000000000000000000000000000000000000000000000000000_u128) 231 .is_nan()); 232 #elif __SIZEOF_LONG_DOUBLE__ == 12 233 EXPECT_TRUE( // NAN : Pseudo-Infinity 234 Rep(0b0'111111111111111'0000000000000000000000000000000000000000000000000000000000000000_u96) 235 .is_nan()); 236 EXPECT_TRUE( // NAN : Pseudo Not a Number 237 Rep(0b0'111111111111111'0000000000000000000000000000000000000000000000000000000000000001_u96) 238 .is_nan()); 239 EXPECT_TRUE( // NAN : Pseudo Not a Number 240 Rep(0b0'111111111111111'0100000000000000000000000000000000000000000000000000000000000000_u96) 241 .is_nan()); 242 EXPECT_TRUE( // NAN : Signalling Not a Number 243 Rep(0b0'111111111111111'1000000000000000000000000000000000000000000000000000000000000001_u96) 244 .is_nan()); 245 EXPECT_TRUE( // NAN : Floating-point Indefinite 246 Rep(0b0'111111111111111'1100000000000000000000000000000000000000000000000000000000000000_u96) 247 .is_nan()); 248 EXPECT_TRUE( // NAN : Quiet Not a Number 249 Rep(0b0'111111111111111'1100000000000000000000000000000000000000000000000000000000000001_u96) 250 .is_nan()); 251 EXPECT_TRUE( // NAN : Unnormal 252 Rep(0b0'111111111111110'0000000000000000000000000000000000000000000000000000000000000000_u96) 253 .is_nan()); 254 EXPECT_FALSE( // Zero 255 Rep(0b0'000000000000000'0000000000000000000000000000000000000000000000000000000000000000_u96) 256 .is_nan()); 257 EXPECT_FALSE( // Subnormal 258 Rep(0b0'000000000000000'0000000000000000000000000000000000000000000000000000000000000001_u96) 259 .is_nan()); 260 EXPECT_FALSE( // Pseudo Denormal 261 Rep(0b0'000000000000000'1000000000000000000000000000000000000000000000000000000000000001_u96) 262 .is_nan()); 263 EXPECT_FALSE( // Infinity 264 Rep(0b0'111111111111111'1000000000000000000000000000000000000000000000000000000000000000_u96) 265 .is_nan()); 266 EXPECT_FALSE( // Normalized 267 Rep(0b0'111111111111110'1000000000000000000000000000000000000000000000000000000000000000_u96) 268 .is_nan()); 269 #else 270 #error "unhandled long double type" 271 #endif 272 } 273 #endif // LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80 274 275 enum class FP { 276 ZERO, 277 MIN_SUBNORMAL, 278 MAX_SUBNORMAL, 279 MIN_NORMAL, 280 ONE, 281 MAX_NORMAL, 282 INF, 283 SIGNALING_NAN, 284 QUIET_NAN 285 }; 286 287 constexpr FP all_fp_values[] = { 288 FP::ZERO, FP::MIN_SUBNORMAL, FP::MAX_SUBNORMAL, 289 FP::MIN_NORMAL, FP::ONE, FP::MAX_NORMAL, 290 FP::INF, FP::SIGNALING_NAN, FP::QUIET_NAN, 291 }; 292 293 constexpr Sign all_signs[] = {Sign::POS, Sign::NEG}; 294 295 using FPTypes = LIBC_NAMESPACE::testing::TypeList< 296 FPRep<FPType::IEEE754_Binary16>, FPRep<FPType::IEEE754_Binary32>, 297 FPRep<FPType::IEEE754_Binary64>, FPRep<FPType::IEEE754_Binary128>, 298 FPRep<FPType::X86_Binary80>>; 299 300 template <typename T> constexpr auto make(Sign sign, FP fp) { 301 switch (fp) { 302 case FP::ZERO: 303 return T::zero(sign); 304 case FP::MIN_SUBNORMAL: 305 return T::min_subnormal(sign); 306 case FP::MAX_SUBNORMAL: 307 return T::max_subnormal(sign); 308 case FP::MIN_NORMAL: 309 return T::min_normal(sign); 310 case FP::ONE: 311 return T::one(sign); 312 case FP::MAX_NORMAL: 313 return T::max_normal(sign); 314 case FP::INF: 315 return T::inf(sign); 316 case FP::SIGNALING_NAN: 317 return T::signaling_nan(sign); 318 case FP::QUIET_NAN: 319 return T::quiet_nan(sign); 320 } 321 __builtin_unreachable(); 322 } 323 324 // Tests all properties for all types of float. 325 TYPED_TEST(LlvmLibcFPBitsTest, Properties, FPTypes) { 326 for (Sign sign : all_signs) { 327 for (FP fp : all_fp_values) { 328 const T value = make<T>(sign, fp); 329 // is_zero 330 ASSERT_EQ(value.is_zero(), fp == FP::ZERO); 331 // is_inf_or_nan 332 ASSERT_EQ(value.is_inf_or_nan(), fp == FP::INF || 333 fp == FP::SIGNALING_NAN || 334 fp == FP::QUIET_NAN); 335 // is_finite 336 ASSERT_EQ(value.is_finite(), fp != FP::INF && fp != FP::SIGNALING_NAN && 337 fp != FP::QUIET_NAN); 338 // is_inf 339 ASSERT_EQ(value.is_inf(), fp == FP::INF); 340 // is_nan 341 ASSERT_EQ(value.is_nan(), fp == FP::SIGNALING_NAN || fp == FP::QUIET_NAN); 342 // is_normal 343 ASSERT_EQ(value.is_normal(), 344 fp == FP::MIN_NORMAL || fp == FP::ONE || fp == FP::MAX_NORMAL); 345 // is_quiet_nan 346 ASSERT_EQ(value.is_quiet_nan(), fp == FP::QUIET_NAN); 347 // is_signaling_nan 348 ASSERT_EQ(value.is_signaling_nan(), fp == FP::SIGNALING_NAN); 349 // is_subnormal 350 ASSERT_EQ(value.is_subnormal(), fp == FP::ZERO || 351 fp == FP::MIN_SUBNORMAL || 352 fp == FP::MAX_SUBNORMAL); 353 // is_pos 354 ASSERT_EQ(value.is_pos(), sign == Sign::POS); 355 ASSERT_EQ(value.sign().is_pos(), sign == Sign::POS); 356 // is_neg 357 ASSERT_EQ(value.is_neg(), sign == Sign::NEG); 358 ASSERT_EQ(value.sign().is_neg(), sign == Sign::NEG); 359 } 360 } 361 } 362 363 #define ASSERT_SAME_REP(A, B) ASSERT_EQ(A.uintval(), B.uintval()); 364 365 TYPED_TEST(LlvmLibcFPBitsTest, NextTowardInf, FPTypes) { 366 struct { 367 FP before, after; 368 } TEST_CASES[] = { 369 {FP::ZERO, FP::MIN_SUBNORMAL}, // 370 {FP::MAX_SUBNORMAL, FP::MIN_NORMAL}, // 371 {FP::MAX_NORMAL, FP::INF}, // 372 {FP::INF, FP::INF}, // 373 {FP::QUIET_NAN, FP::QUIET_NAN}, // 374 {FP::SIGNALING_NAN, FP::SIGNALING_NAN}, // 375 }; 376 for (Sign sign : all_signs) { 377 for (auto tc : TEST_CASES) { 378 T val = make<T>(sign, tc.before); 379 ASSERT_SAME_REP(val.next_toward_inf(), make<T>(sign, tc.after)); 380 } 381 } 382 } 383 384 TEST(LlvmLibcFPBitsTest, FloatType) { 385 using FloatBits = FPBits<float>; 386 387 EXPECT_STREQ(LIBC_NAMESPACE::str(FloatBits::inf(Sign::POS)).c_str(), 388 "(+Infinity)"); 389 EXPECT_STREQ(LIBC_NAMESPACE::str(FloatBits::inf(Sign::NEG)).c_str(), 390 "(-Infinity)"); 391 EXPECT_STREQ(LIBC_NAMESPACE::str(FloatBits::signaling_nan()).c_str(), 392 "(NaN)"); 393 394 FloatBits zero(0.0f); 395 EXPECT_TRUE(zero.is_pos()); 396 EXPECT_EQ(zero.get_biased_exponent(), 0_u16); 397 EXPECT_EQ(zero.get_mantissa(), 0_u32); 398 EXPECT_EQ(zero.uintval(), 0_u32); 399 EXPECT_STREQ(LIBC_NAMESPACE::str(zero).c_str(), 400 "0x00000000 = (S: 0, E: 0x0000, M: 0x00000000)"); 401 402 FloatBits negzero(-0.0f); 403 EXPECT_TRUE(negzero.is_neg()); 404 EXPECT_EQ(negzero.get_biased_exponent(), 0_u16); 405 EXPECT_EQ(negzero.get_mantissa(), 0_u32); 406 EXPECT_EQ(negzero.uintval(), 0x80000000_u32); 407 EXPECT_STREQ(LIBC_NAMESPACE::str(negzero).c_str(), 408 "0x80000000 = (S: 1, E: 0x0000, M: 0x00000000)"); 409 410 FloatBits one(1.0f); 411 EXPECT_TRUE(one.is_pos()); 412 EXPECT_EQ(one.get_biased_exponent(), 0x7F_u16); 413 EXPECT_EQ(one.get_mantissa(), 0_u32); 414 EXPECT_EQ(one.uintval(), 0x3F800000_u32); 415 EXPECT_STREQ(LIBC_NAMESPACE::str(one).c_str(), 416 "0x3F800000 = (S: 0, E: 0x007F, M: 0x00000000)"); 417 418 FloatBits negone(-1.0f); 419 EXPECT_TRUE(negone.is_neg()); 420 EXPECT_EQ(negone.get_biased_exponent(), 0x7F_u16); 421 EXPECT_EQ(negone.get_mantissa(), 0_u32); 422 EXPECT_EQ(negone.uintval(), 0xBF800000_u32); 423 EXPECT_STREQ(LIBC_NAMESPACE::str(negone).c_str(), 424 "0xBF800000 = (S: 1, E: 0x007F, M: 0x00000000)"); 425 426 FloatBits num(1.125f); 427 EXPECT_TRUE(num.is_pos()); 428 EXPECT_EQ(num.get_biased_exponent(), 0x7F_u16); 429 EXPECT_EQ(num.get_mantissa(), 0x00100000_u32); 430 EXPECT_EQ(num.uintval(), 0x3F900000_u32); 431 EXPECT_STREQ(LIBC_NAMESPACE::str(num).c_str(), 432 "0x3F900000 = (S: 0, E: 0x007F, M: 0x00100000)"); 433 434 FloatBits negnum(-1.125f); 435 EXPECT_TRUE(negnum.is_neg()); 436 EXPECT_EQ(negnum.get_biased_exponent(), 0x7F_u16); 437 EXPECT_EQ(negnum.get_mantissa(), 0x00100000_u32); 438 EXPECT_EQ(negnum.uintval(), 0xBF900000_u32); 439 EXPECT_STREQ(LIBC_NAMESPACE::str(negnum).c_str(), 440 "0xBF900000 = (S: 1, E: 0x007F, M: 0x00100000)"); 441 442 FloatBits quiet_nan = FloatBits::quiet_nan(); 443 EXPECT_EQ(quiet_nan.is_quiet_nan(), true); 444 } 445 446 TEST(LlvmLibcFPBitsTest, DoubleType) { 447 using DoubleBits = FPBits<double>; 448 449 EXPECT_STREQ(LIBC_NAMESPACE::str(DoubleBits::inf(Sign::POS)).c_str(), 450 "(+Infinity)"); 451 EXPECT_STREQ(LIBC_NAMESPACE::str(DoubleBits::inf(Sign::NEG)).c_str(), 452 "(-Infinity)"); 453 EXPECT_STREQ(LIBC_NAMESPACE::str(DoubleBits::signaling_nan()).c_str(), 454 "(NaN)"); 455 456 DoubleBits zero(0.0); 457 EXPECT_TRUE(zero.is_pos()); 458 EXPECT_EQ(zero.get_biased_exponent(), 0_u16); 459 EXPECT_EQ(zero.get_mantissa(), 0_u64); 460 EXPECT_EQ(zero.uintval(), 0_u64); 461 EXPECT_STREQ(LIBC_NAMESPACE::str(zero).c_str(), 462 "0x0000000000000000 = (S: 0, E: 0x0000, M: 0x0000000000000000)"); 463 464 DoubleBits negzero(-0.0); 465 EXPECT_TRUE(negzero.is_neg()); 466 EXPECT_EQ(negzero.get_biased_exponent(), 0_u16); 467 EXPECT_EQ(negzero.get_mantissa(), 0_u64); 468 EXPECT_EQ(negzero.uintval(), 0x8000000000000000_u64); 469 EXPECT_STREQ(LIBC_NAMESPACE::str(negzero).c_str(), 470 "0x8000000000000000 = (S: 1, E: 0x0000, M: 0x0000000000000000)"); 471 472 DoubleBits one(1.0); 473 EXPECT_TRUE(one.is_pos()); 474 EXPECT_EQ(one.get_biased_exponent(), 0x03FF_u16); 475 EXPECT_EQ(one.get_mantissa(), 0_u64); 476 EXPECT_EQ(one.uintval(), 0x3FF0000000000000_u64); 477 EXPECT_STREQ(LIBC_NAMESPACE::str(one).c_str(), 478 "0x3FF0000000000000 = (S: 0, E: 0x03FF, M: 0x0000000000000000)"); 479 480 DoubleBits negone(-1.0); 481 EXPECT_TRUE(negone.is_neg()); 482 EXPECT_EQ(negone.get_biased_exponent(), 0x03FF_u16); 483 EXPECT_EQ(negone.get_mantissa(), 0_u64); 484 EXPECT_EQ(negone.uintval(), 0xBFF0000000000000_u64); 485 EXPECT_STREQ(LIBC_NAMESPACE::str(negone).c_str(), 486 "0xBFF0000000000000 = (S: 1, E: 0x03FF, M: 0x0000000000000000)"); 487 488 DoubleBits num(1.125); 489 EXPECT_TRUE(num.is_pos()); 490 EXPECT_EQ(num.get_biased_exponent(), 0x03FF_u16); 491 EXPECT_EQ(num.get_mantissa(), 0x0002000000000000_u64); 492 EXPECT_EQ(num.uintval(), 0x3FF2000000000000_u64); 493 EXPECT_STREQ(LIBC_NAMESPACE::str(num).c_str(), 494 "0x3FF2000000000000 = (S: 0, E: 0x03FF, M: 0x0002000000000000)"); 495 496 DoubleBits negnum(-1.125); 497 EXPECT_TRUE(negnum.is_neg()); 498 EXPECT_EQ(negnum.get_biased_exponent(), 0x03FF_u16); 499 EXPECT_EQ(negnum.get_mantissa(), 0x0002000000000000_u64); 500 EXPECT_EQ(negnum.uintval(), 0xBFF2000000000000_u64); 501 EXPECT_STREQ(LIBC_NAMESPACE::str(negnum).c_str(), 502 "0xBFF2000000000000 = (S: 1, E: 0x03FF, M: 0x0002000000000000)"); 503 504 DoubleBits quiet_nan = DoubleBits::quiet_nan(); 505 EXPECT_EQ(quiet_nan.is_quiet_nan(), true); 506 } 507 508 #ifdef LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80 509 TEST(LlvmLibcFPBitsTest, X86LongDoubleType) { 510 using LongDoubleBits = FPBits<long double>; 511 using Rep = FPRep<FPType::X86_Binary80>; 512 513 EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::inf(Sign::POS)).c_str(), 514 "(+Infinity)"); 515 EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::inf(Sign::NEG)).c_str(), 516 "(-Infinity)"); 517 EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::signaling_nan()).c_str(), 518 "(NaN)"); 519 520 LongDoubleBits zero(0.0l); 521 EXPECT_TRUE(zero.is_pos()); 522 EXPECT_EQ(zero.get_biased_exponent(), 0_u16); 523 EXPECT_EQ(zero.get_mantissa(), LongDoubleBits::StorageType(Rep::zero())); 524 EXPECT_EQ(zero.uintval(), LongDoubleBits::StorageType(Rep::zero())); 525 #if __SIZEOF_LONG_DOUBLE__ == 16 526 EXPECT_STREQ( 527 LIBC_NAMESPACE::str(zero).c_str(), 528 "0x00000000000000000000000000000000 = " 529 "(S: 0, E: 0x0000, I: 0, M: 0x00000000000000000000000000000000)"); 530 #elif __SIZEOF_LONG_DOUBLE__ == 12 531 EXPECT_STREQ(LIBC_NAMESPACE::str(zero).c_str(), 532 "0x000000000000000000000000 = " 533 "(S: 0, E: 0x0000, I: 0, M: 0x000000000000000000000000)"); 534 #else 535 #error "unhandled long double type" 536 #endif 537 538 LongDoubleBits negzero(-0.0l); 539 EXPECT_TRUE(negzero.is_neg()); 540 EXPECT_EQ(negzero.get_biased_exponent(), 0_u16); 541 EXPECT_EQ(negzero.get_mantissa(), LongDoubleBits::StorageType(Rep::zero())); 542 #if __SIZEOF_LONG_DOUBLE__ == 16 543 EXPECT_EQ(negzero.uintval(), 0x8000'00000000'00000000_u128); 544 EXPECT_STREQ( 545 LIBC_NAMESPACE::str(negzero).c_str(), 546 "0x00000000000080000000000000000000 = " 547 "(S: 1, E: 0x0000, I: 0, M: 0x00000000000000000000000000000000)"); 548 #elif __SIZEOF_LONG_DOUBLE__ == 12 549 EXPECT_EQ(negzero.uintval(), 0x8000'00000000'00000000_u96); 550 EXPECT_STREQ(LIBC_NAMESPACE::str(negzero).c_str(), 551 "0x000080000000000000000000 = " 552 "(S: 1, E: 0x0000, I: 0, M: 0x000000000000000000000000)"); 553 #else 554 #error "unhandled long double type" 555 #endif 556 557 LongDoubleBits one(1.0l); 558 EXPECT_TRUE(one.is_pos()); 559 EXPECT_EQ(one.get_biased_exponent(), 0x3FFF_u16); 560 EXPECT_EQ(one.get_mantissa(), LongDoubleBits::StorageType(Rep::zero())); 561 #if __SIZEOF_LONG_DOUBLE__ == 16 562 EXPECT_EQ(one.uintval(), 0x3FFF'80000000'00000000_u128); 563 EXPECT_STREQ( 564 LIBC_NAMESPACE::str(one).c_str(), 565 "0x0000000000003FFF8000000000000000 = " 566 "(S: 0, E: 0x3FFF, I: 1, M: 0x00000000000000000000000000000000)"); 567 #elif __SIZEOF_LONG_DOUBLE__ == 12 568 EXPECT_EQ(one.uintval(), 0x3FFF'80000000'00000000_u96); 569 EXPECT_STREQ(LIBC_NAMESPACE::str(one).c_str(), 570 "0x00003FFF8000000000000000 = " 571 "(S: 0, E: 0x3FFF, I: 1, M: 0x000000000000000000000000)"); 572 #else 573 #error "unhandled long double type" 574 #endif 575 576 LongDoubleBits negone(-1.0l); 577 EXPECT_TRUE(negone.is_neg()); 578 EXPECT_EQ(negone.get_biased_exponent(), 0x3FFF_u16); 579 EXPECT_EQ(negone.get_mantissa(), LongDoubleBits::StorageType(Rep::zero())); 580 #if __SIZEOF_LONG_DOUBLE__ == 16 581 EXPECT_EQ(negone.uintval(), 0xBFFF'80000000'00000000_u128); 582 EXPECT_STREQ( 583 LIBC_NAMESPACE::str(negone).c_str(), 584 "0x000000000000BFFF8000000000000000 = " 585 "(S: 1, E: 0x3FFF, I: 1, M: 0x00000000000000000000000000000000)"); 586 #elif __SIZEOF_LONG_DOUBLE__ == 12 587 EXPECT_EQ(negone.uintval(), 0xBFFF'80000000'00000000_u96); 588 EXPECT_STREQ(LIBC_NAMESPACE::str(negone).c_str(), 589 "0x0000BFFF8000000000000000 = " 590 "(S: 1, E: 0x3FFF, I: 1, M: 0x000000000000000000000000)"); 591 #else 592 #error "unhandled long double type" 593 #endif 594 595 LongDoubleBits num(1.125l); 596 EXPECT_TRUE(num.is_pos()); 597 EXPECT_EQ(num.get_biased_exponent(), 0x3FFF_u16); 598 #if __SIZEOF_LONG_DOUBLE__ == 16 599 EXPECT_EQ(num.get_mantissa(), 0x10000000'00000000_u128); 600 EXPECT_EQ(num.uintval(), 0x3FFF'90000000'00000000_u128); 601 EXPECT_STREQ( 602 LIBC_NAMESPACE::str(num).c_str(), 603 "0x0000000000003FFF9000000000000000 = " 604 "(S: 0, E: 0x3FFF, I: 1, M: 0x00000000000000001000000000000000)"); 605 #elif __SIZEOF_LONG_DOUBLE__ == 12 606 EXPECT_EQ(num.get_mantissa(), 0x10000000'00000000_u96); 607 EXPECT_EQ(num.uintval(), 0x3FFF'90000000'00000000_u96); 608 EXPECT_STREQ(LIBC_NAMESPACE::str(num).c_str(), 609 "0x00003FFF9000000000000000 = " 610 "(S: 0, E: 0x3FFF, I: 1, M: 0x000000001000000000000000)"); 611 #else 612 #error "unhandled long double type" 613 #endif 614 615 LongDoubleBits negnum(-1.125l); 616 EXPECT_TRUE(negnum.is_neg()); 617 EXPECT_EQ(negnum.get_biased_exponent(), 0x3FFF_u16); 618 #if __SIZEOF_LONG_DOUBLE__ == 16 619 EXPECT_EQ(negnum.get_mantissa(), 0x10000000'00000000_u128); 620 EXPECT_EQ(negnum.uintval(), 0xBFFF'90000000'00000000_u128); 621 EXPECT_STREQ( 622 LIBC_NAMESPACE::str(negnum).c_str(), 623 "0x000000000000BFFF9000000000000000 = " 624 "(S: 1, E: 0x3FFF, I: 1, M: 0x00000000000000001000000000000000)"); 625 #elif __SIZEOF_LONG_DOUBLE__ == 12 626 EXPECT_EQ(negnum.get_mantissa(), 0x10000000'00000000_u96); 627 EXPECT_EQ(negnum.uintval(), 0xBFFF'90000000'00000000_u96); 628 EXPECT_STREQ(LIBC_NAMESPACE::str(negnum).c_str(), 629 "0x0000BFFF9000000000000000 = " 630 "(S: 1, E: 0x3FFF, I: 1, M: 0x000000001000000000000000)"); 631 #else 632 #error "unhandled long double type" 633 #endif 634 635 LongDoubleBits quiet_nan = LongDoubleBits::quiet_nan(); 636 EXPECT_EQ(quiet_nan.is_quiet_nan(), true); 637 } 638 #else 639 TEST(LlvmLibcFPBitsTest, LongDoubleType) { 640 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64) 641 return; // The tests for the "double" type cover for this case. 642 #else 643 using LongDoubleBits = FPBits<long double>; 644 645 EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::inf(Sign::POS)).c_str(), 646 "(+Infinity)"); 647 EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::inf(Sign::NEG)).c_str(), 648 "(-Infinity)"); 649 EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::signaling_nan()).c_str(), 650 "(NaN)"); 651 652 LongDoubleBits zero(0.0l); 653 EXPECT_TRUE(zero.is_pos()); 654 EXPECT_EQ(zero.get_biased_exponent(), 0_u16); 655 EXPECT_EQ(zero.get_mantissa(), 0_u128); 656 EXPECT_EQ(zero.uintval(), 0_u128); 657 EXPECT_STREQ(LIBC_NAMESPACE::str(zero).c_str(), 658 "0x00000000000000000000000000000000 = " 659 "(S: 0, E: 0x0000, M: 0x00000000000000000000000000000000)"); 660 661 LongDoubleBits negzero(-0.0l); 662 EXPECT_TRUE(negzero.is_neg()); 663 EXPECT_EQ(negzero.get_biased_exponent(), 0_u16); 664 EXPECT_EQ(negzero.get_mantissa(), 0_u128); 665 EXPECT_EQ(negzero.uintval(), 0x80000000'00000000'00000000'00000000_u128); 666 EXPECT_STREQ(LIBC_NAMESPACE::str(negzero).c_str(), 667 "0x80000000000000000000000000000000 = " 668 "(S: 1, E: 0x0000, M: 0x00000000000000000000000000000000)"); 669 670 LongDoubleBits one(1.0l); 671 EXPECT_TRUE(one.is_pos()); 672 EXPECT_EQ(one.get_biased_exponent(), 0x3FFF_u16); 673 EXPECT_EQ(one.get_mantissa(), 0_u128); 674 EXPECT_EQ(one.uintval(), 0x3FFF0000'00000000'00000000'00000000_u128); 675 EXPECT_STREQ(LIBC_NAMESPACE::str(one).c_str(), 676 "0x3FFF0000000000000000000000000000 = " 677 "(S: 0, E: 0x3FFF, M: 0x00000000000000000000000000000000)"); 678 679 LongDoubleBits negone(-1.0l); 680 EXPECT_TRUE(negone.is_neg()); 681 EXPECT_EQ(negone.get_biased_exponent(), 0x3FFF_u16); 682 EXPECT_EQ(negone.get_mantissa(), 0_u128); 683 EXPECT_EQ(negone.uintval(), 0xBFFF0000'00000000'00000000'00000000_u128); 684 EXPECT_STREQ(LIBC_NAMESPACE::str(negone).c_str(), 685 "0xBFFF0000000000000000000000000000 = " 686 "(S: 1, E: 0x3FFF, M: 0x00000000000000000000000000000000)"); 687 688 LongDoubleBits num(1.125l); 689 EXPECT_TRUE(num.is_pos()); 690 EXPECT_EQ(num.get_biased_exponent(), 0x3FFF_u16); 691 EXPECT_EQ(num.get_mantissa(), 0x2000'00000000'00000000'00000000_u128); 692 EXPECT_EQ(num.uintval(), 0x3FFF2000'00000000'00000000'00000000_u128); 693 EXPECT_STREQ(LIBC_NAMESPACE::str(num).c_str(), 694 "0x3FFF2000000000000000000000000000 = " 695 "(S: 0, E: 0x3FFF, M: 0x00002000000000000000000000000000)"); 696 697 LongDoubleBits negnum(-1.125l); 698 EXPECT_TRUE(negnum.is_neg()); 699 EXPECT_EQ(negnum.get_biased_exponent(), 0x3FFF_u16); 700 EXPECT_EQ(negnum.get_mantissa(), 0x2000'00000000'00000000'00000000_u128); 701 EXPECT_EQ(negnum.uintval(), 0xBFFF2000'00000000'00000000'00000000_u128); 702 EXPECT_STREQ(LIBC_NAMESPACE::str(negnum).c_str(), 703 "0xBFFF2000000000000000000000000000 = " 704 "(S: 1, E: 0x3FFF, M: 0x00002000000000000000000000000000)"); 705 706 LongDoubleBits quiet_nan = LongDoubleBits::quiet_nan(); 707 EXPECT_EQ(quiet_nan.is_quiet_nan(), true); 708 #endif 709 } 710 #endif 711 712 #if defined(LIBC_TYPES_HAS_FLOAT128) 713 TEST(LlvmLibcFPBitsTest, Float128Type) { 714 using Float128Bits = FPBits<float128>; 715 716 EXPECT_STREQ(LIBC_NAMESPACE::str(Float128Bits::inf(Sign::POS)).c_str(), 717 "(+Infinity)"); 718 EXPECT_STREQ(LIBC_NAMESPACE::str(Float128Bits::inf(Sign::NEG)).c_str(), 719 "(-Infinity)"); 720 EXPECT_STREQ(LIBC_NAMESPACE::str(Float128Bits::signaling_nan()).c_str(), 721 "(NaN)"); 722 723 Float128Bits zero = Float128Bits::zero(Sign::POS); 724 EXPECT_TRUE(zero.is_pos()); 725 EXPECT_EQ(zero.get_biased_exponent(), 0_u16); 726 EXPECT_EQ(zero.get_mantissa(), 0_u128); 727 EXPECT_EQ(zero.uintval(), 0_u128); 728 EXPECT_STREQ(LIBC_NAMESPACE::str(zero).c_str(), 729 "0x00000000000000000000000000000000 = " 730 "(S: 0, E: 0x0000, M: 0x00000000000000000000000000000000)"); 731 732 Float128Bits negzero = Float128Bits::zero(Sign::NEG); 733 EXPECT_TRUE(negzero.is_neg()); 734 EXPECT_EQ(negzero.get_biased_exponent(), 0_u16); 735 EXPECT_EQ(negzero.get_mantissa(), 0_u128); 736 EXPECT_EQ(negzero.uintval(), 0x80000000'00000000'00000000'00000000_u128); 737 EXPECT_STREQ(LIBC_NAMESPACE::str(negzero).c_str(), 738 "0x80000000000000000000000000000000 = " 739 "(S: 1, E: 0x0000, M: 0x00000000000000000000000000000000)"); 740 741 Float128Bits one(float128(1.0)); 742 EXPECT_TRUE(one.is_pos()); 743 EXPECT_EQ(one.get_biased_exponent(), 0x3FFF_u16); 744 EXPECT_EQ(one.get_mantissa(), 0_u128); 745 EXPECT_EQ(one.uintval(), 0x3FFF0000'00000000'00000000'00000000_u128); 746 EXPECT_STREQ(LIBC_NAMESPACE::str(one).c_str(), 747 "0x3FFF0000000000000000000000000000 = " 748 "(S: 0, E: 0x3FFF, M: 0x00000000000000000000000000000000)"); 749 750 Float128Bits negone(float128(-1.0)); 751 EXPECT_TRUE(negone.is_neg()); 752 EXPECT_EQ(negone.get_biased_exponent(), 0x3FFF_u16); 753 EXPECT_EQ(negone.get_mantissa(), 0_u128); 754 EXPECT_EQ(negone.uintval(), 0xBFFF0000'00000000'00000000'00000000_u128); 755 EXPECT_STREQ(LIBC_NAMESPACE::str(negone).c_str(), 756 "0xBFFF0000000000000000000000000000 = " 757 "(S: 1, E: 0x3FFF, M: 0x00000000000000000000000000000000)"); 758 759 Float128Bits num(float128(1.125)); 760 EXPECT_TRUE(num.is_pos()); 761 EXPECT_EQ(num.get_biased_exponent(), 0x3FFF_u16); 762 EXPECT_EQ(num.get_mantissa(), 0x2000'00000000'00000000'00000000_u128); 763 EXPECT_EQ(num.uintval(), 0x3FFF2000'00000000'00000000'00000000_u128); 764 EXPECT_STREQ(LIBC_NAMESPACE::str(num).c_str(), 765 "0x3FFF2000000000000000000000000000 = " 766 "(S: 0, E: 0x3FFF, M: 0x00002000000000000000000000000000)"); 767 768 Float128Bits negnum(float128(-1.125)); 769 EXPECT_TRUE(negnum.is_neg()); 770 EXPECT_EQ(negnum.get_biased_exponent(), 0x3FFF_u16); 771 EXPECT_EQ(negnum.get_mantissa(), 0x2000'00000000'00000000'00000000_u128); 772 EXPECT_EQ(negnum.uintval(), 0xBFFF2000'00000000'00000000'00000000_u128); 773 EXPECT_STREQ(LIBC_NAMESPACE::str(negnum).c_str(), 774 "0xBFFF2000000000000000000000000000 = " 775 "(S: 1, E: 0x3FFF, M: 0x00002000000000000000000000000000)"); 776 777 Float128Bits quiet_nan = Float128Bits::quiet_nan(); 778 EXPECT_EQ(quiet_nan.is_quiet_nan(), true); 779 } 780 #endif // LIBC_TYPES_HAS_FLOAT128 781