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