ceph/src/boost/libs/spirit/include/boost/spirit/home/support/detail/math/detail/fp_traits.hpp

   1 // fp_traits.hpp
   2
   3 #ifndef BOOST_SPIRIT_MATH_FP_TRAITS_HPP
   4 #define BOOST_SPIRIT_MATH_FP_TRAITS_HPP
   5
   6 // Copyright (c) 2006 Johan Rade
   7
   8 // Distributed under the Boost Software License, Version 1.0.
   9 // (See accompanying file LICENSE_1_0.txt
  10 // or copy at http://www.boost.org/LICENSE_1_0.txt)
  11
  12 #if defined(__vms) && defined(__DECCXX) && !__IEEE_FLOAT
  13 #   error The VAX floating point mode on VMS is not supported.
  14 #endif
  15
  16 #if defined(_MSC_VER)
  17 #pragma once
  18 #endif
  19
  20 #include <cstring>
  21
  22 #include <boost/assert.hpp>
  23 #include <boost/cstdint.hpp>
  24 #include <boost/detail/endian.hpp>
  25 #include <boost/static_assert.hpp>
  26 #include <boost/type_traits/is_floating_point.hpp>
  27
  28 //------------------------------------------------------------------------------
  29
  30 namespace boost {
  31 namespace spirit {
  32 namespace math {
  33 namespace detail {
  34
  35 //------------------------------------------------------------------------------
  36
  37 /*
  38 Most processors support three different floating point precisions:
  39 single precision (32 bits), double precision (64 bits)
  40 and extended double precision (>64 bits)
  41
  42 Note that the C++ type long double can be implemented
  43 both as double precision and extended double precision.
  44 */
  45
  46 struct single_precision_tag {};
  47 struct double_precision_tag {};
  48 struct extended_double_precision_tag {};
  49
  50 //------------------------------------------------------------------------------
  51
  52 /*
  53 template<class T, class U> struct fp_traits_impl;
  54
  55   This is traits class that describes the binary structure of floating
  56   point numbers of C++ type T and precision U
  57
  58 Requirements:
  59
  60   T = float, double or long double
  61   U = single_precision_tag, double_precision_tag
  62       or extended_double_precision_tag
  63
  64 Typedef members:
  65
  66   bits -- the target type when copying the leading bytes of a floating
  67       point number. It is a typedef for uint32_t or uint64_t.
  68
  69   coverage -- tells us whether all bytes are copied or not.
  70       It is a typedef for all_bits or not_all_bits.
  71
  72 Static data members:
  73
  74   sign, exponent, flag, mantissa -- bit masks that give the meaning of the bits
  75       in the leading bytes.
  76
  77 Static function members:
  78
  79   init() -- initializes the static data members, if needed.
  80             (Is a no-op in the specialized versions of the template.)
  81
  82   get_bits(), set_bits() -- provide access to the leading bytes.
  83 */
  84
  85 struct all_bits {};
  86 struct not_all_bits {};
  87
  88 // Generic version -------------------------------------------------------------
  89
  90 // The generic version uses run time initialization to determine the floating
  91 // point format. It is capable of handling most formats,
  92 // but not the Motorola 68K extended double precision format.
  93
  94 // Currently the generic version is used only for extended double precision
  95 // on Itanium. In all other cases there are specializations of the template
  96 // that use compile time initialization.
  97
  98 template<class T> struct uint32_t_coverage
  99 {
 100     typedef not_all_bits type;
 101 };
 102
 103 template<> struct uint32_t_coverage<single_precision_tag>
 104 {
 105     typedef all_bits type;
 106 };
 107
 108 template<class T, class U> struct fp_traits_impl
 109 {
 110     typedef uint32_t bits;
 111     typedef BOOST_DEDUCED_TYPENAME uint32_t_coverage<U>::type coverage;
 112
 113     BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
 114     static uint32_t exponent;
 115     static uint32_t flag;
 116     static uint32_t mantissa;
 117
 118     static void init()
 119     {
 120         if(is_init_) return;
 121         do_init_();
 122         is_init_ = true;
 123     }
 124
 125     static void get_bits(T x, uint32_t& a)
 126     {
 127         memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
 128     }
 129
 130     static void set_bits(T& x, uint32_t a)
 131     {
 132         memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
 133     }
 134
 135 private:
 136     static size_t offset_;
 137     static bool is_init_;
 138     static void do_init_();
 139 };
 140
 141 //..............................................................................
 142
 143 template<class T, class U> uint32_t fp_traits_impl<T,U>::exponent;
 144 template<class T, class U> uint32_t fp_traits_impl<T,U>::flag;
 145 template<class T, class U> uint32_t fp_traits_impl<T,U>::mantissa;
 146 template<class T, class U> size_t   fp_traits_impl<T,U>::offset_;
 147 template<class T, class U> bool     fp_traits_impl<T,U>::is_init_;
 148
 149 // In a single-threaded program, do_init will be called exactly once.
 150 // In a multi-threaded program, do_init may be called simultaneously
 151 // by more then one thread. That should not be a problem.
 152
 153 //..............................................................................
 154
 155 template<class T, class U> void fp_traits_impl<T,U>::do_init_()
 156 {
 157     T x = static_cast<T>(3) / static_cast<T>(4);
 158     // sign bit = 0
 159     // exponent: first and last bit = 0, all other bits  = 1
 160     // flag bit (if present) = 1
 161     // mantissa: first bit = 1, all other bits = 0
 162
 163     uint32_t a;
 164
 165     for(size_t k = 0; k <= sizeof(T) - 4; ++k) {
 166
 167         memcpy(&a, reinterpret_cast<unsigned char*>(&x) + k, 4);
 168
 169         switch(a) {
 170
 171         case 0x3f400000:      // IEEE single precision format
 172
 173             offset_  = k;
 174             exponent = 0x7f800000;
 175             flag     = 0x00000000;
 176             mantissa = 0x007fffff;
 177             return;
 178
 179         case 0x3fe80000:      // IEEE double precision format
 180                               // and PowerPC extended double precision format
 181             offset_  = k;
 182             exponent = 0x7ff00000;
 183             flag     = 0x00000000;
 184             mantissa = 0x000fffff;
 185             return;
 186
 187         case 0x3ffe0000:      // Motorola extended double precision format
 188
 189             // Must not get here. Must be handled by specialization.
 190             // To get accurate cutoff between normals and subnormals
 191             // we must use the flag bit that is in the 5th byte.
 192             // Otherwise this cutoff will be off by a factor 2.
 193             // If we do get here, then we have failed to detect the Motorola
 194             // processor at compile time.
 195
 196             BOOST_ASSERT(false &&
 197                 "Failed to detect the Motorola processor at compile time");
 198             return;
 199
 200         case 0x3ffe8000:      // IEEE extended double precision format
 201                               // with 15 exponent bits
 202             offset_  = k;
 203             exponent = 0x7fff0000;
 204             flag     = 0x00000000;
 205             mantissa = 0x0000ffff;
 206             return;
 207
 208         case 0x3ffec000:      // Intel extended double precision format
 209
 210             offset_  = k;
 211             exponent = 0x7fff0000;
 212             flag     = 0x00008000;
 213             mantissa = 0x00007fff;
 214             return;
 215
 216         default:
 217             continue;
 218         }
 219     }
 220
 221     BOOST_ASSERT(false);
 222
 223     // Unknown format.
 224 }
 225
 226
 227 // float (32 bits) -------------------------------------------------------------
 228
 229 template<> struct fp_traits_impl<float, single_precision_tag>
 230 {
 231     typedef uint32_t bits;
 232     typedef all_bits coverage;
 233
 234     BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
 235     BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7f800000);
 236     BOOST_STATIC_CONSTANT(uint32_t, flag     = 0x00000000);
 237     BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x007fffff);
 238
 239     static void init() {}
 240     static void get_bits(float x, uint32_t& a) { memcpy(&a, &x, 4); }
 241     static void set_bits(float& x, uint32_t a) { memcpy(&x, &a, 4); }
 242 };
 243
 244
 245 // double (64 bits) ------------------------------------------------------------
 246
 247 #if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
 248
 249 template<> struct fp_traits_impl<double, double_precision_tag>
 250 {
 251     typedef uint32_t bits;
 252     typedef not_all_bits coverage;
 253
 254     BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
 255     BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
 256     BOOST_STATIC_CONSTANT(uint32_t, flag     = 0);
 257     BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);
 258
 259     static void init() {}
 260
 261     static void get_bits(double x, uint32_t& a)
 262     {
 263         memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
 264     }
 265
 266     static void set_bits(double& x, uint32_t a)
 267     {
 268         memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
 269     }
 270
 271 private:
 272
 273 #if defined(BOOST_BIG_ENDIAN)
 274     BOOST_STATIC_CONSTANT(int, offset_ = 0);
 275 #elif defined(BOOST_LITTLE_ENDIAN)
 276     BOOST_STATIC_CONSTANT(int, offset_ = 4);
 277 #else
 278     BOOST_STATIC_ASSERT(false);
 279 #endif
 280 };
 281
 282 //..............................................................................
 283
 284 #else
 285
 286 template<> struct fp_traits_impl<double, double_precision_tag>
 287 {
 288     typedef uint64_t bits;
 289     typedef all_bits coverage;
 290
 291     static const uint64_t sign     = (uint64_t)0x80000000 << 32;
 292     static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
 293     static const uint64_t flag     = 0;
 294     static const uint64_t mantissa
 295         = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffff;
 296
 297     static void init() {}
 298     static void get_bits(double x, uint64_t& a) { memcpy(&a, &x, 8); }
 299     static void set_bits(double& x, uint64_t a) { memcpy(&x, &a, 8); }
 300 };
 301
 302 #endif
 303
 304
 305 // long double (64 bits) -------------------------------------------------------
 306
 307 #if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
 308
 309 template<> struct fp_traits_impl<long double, double_precision_tag>
 310 {
 311     typedef uint32_t bits;
 312     typedef not_all_bits coverage;
 313
 314     BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
 315     BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
 316     BOOST_STATIC_CONSTANT(uint32_t, flag     = 0);
 317     BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);
 318
 319     static void init() {}
 320
 321     static void get_bits(long double x, uint32_t& a)
 322     {
 323         memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
 324     }
 325
 326     static void set_bits(long double& x, uint32_t a)
 327     {
 328         memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
 329     }
 330
 331 private:
 332
 333 #if defined(BOOST_BIG_ENDIAN)
 334     BOOST_STATIC_CONSTANT(int, offset_ = 0);
 335 #elif defined(BOOST_LITTLE_ENDIAN)
 336     BOOST_STATIC_CONSTANT(int, offset_ = 4);
 337 #else
 338     BOOST_STATIC_ASSERT(false);
 339 #endif
 340 };
 341
 342 //..............................................................................
 343
 344 #else
 345
 346 template<> struct fp_traits_impl<long double, double_precision_tag>
 347 {
 348     typedef uint64_t bits;
 349     typedef all_bits coverage;
 350
 351     static const uint64_t sign     = (uint64_t)0x80000000 << 32;
 352     static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
 353     static const uint64_t flag     = 0;
 354     static const uint64_t mantissa
 355         = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffff;
 356
 357     static void init() {}
 358     static void get_bits(long double x, uint64_t& a) { memcpy(&a, &x, 8); }
 359     static void set_bits(long double& x, uint64_t a) { memcpy(&x, &a, 8); }
 360 };
 361
 362 #endif
 363
 364
 365 // long double (>64 bits), x86 and x64 -----------------------------------------
 366
 367 #if defined(__i386) || defined(__i386__) || defined(_M_IX86) \
 368     || defined(__amd64) || defined(__amd64__)  || defined(_M_AMD64) \
 369     || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)
 370
 371 // Intel extended double precision format (80 bits)
 372
 373 template<> struct fp_traits_impl<long double, extended_double_precision_tag>
 374 {
 375     typedef uint32_t bits;
 376     typedef not_all_bits coverage;
 377
 378     BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
 379     BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
 380     BOOST_STATIC_CONSTANT(uint32_t, flag     = 0x00008000);
 381     BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x00007fff);
 382
 383     static void init() {}
 384
 385     static void get_bits(long double x, uint32_t& a)
 386     {
 387         memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + 6, 4);
 388     }
 389
 390     static void set_bits(long double& x, uint32_t a)
 391     {
 392         memcpy(reinterpret_cast<unsigned char*>(&x) + 6, &a, 4);
 393     }
 394 };
 395
 396
 397 // long double (>64 bits), Itanium ---------------------------------------------
 398
 399 #elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
 400
 401 // The floating point format is unknown at compile time
 402 // No template specialization is provided.
 403 // The generic definition is used.
 404
 405 // The Itanium supports both
 406 // the Intel extended double precision format (80 bits) and
 407 // the IEEE extended double precision format with 15 exponent bits (128 bits).
 408
 409
 410 // long double (>64 bits), PowerPC ---------------------------------------------
 411
 412 #elif defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) \
 413     || defined(__ppc) || defined(__ppc__) || defined(__PPC__)
 414
 415 // PowerPC extended double precision format (128 bits)
 416
 417 template<> struct fp_traits_impl<long double, extended_double_precision_tag>
 418 {
 419     typedef uint32_t bits;
 420     typedef not_all_bits coverage;
 421
 422     BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
 423     BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
 424     BOOST_STATIC_CONSTANT(uint32_t, flag     = 0x00000000);
 425     BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);
 426
 427     static void init() {}
 428
 429     static void get_bits(long double x, uint32_t& a)
 430     {
 431         memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
 432     }
 433
 434     static void set_bits(long double& x, uint32_t a)
 435     {
 436         memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
 437     }
 438
 439 private:
 440
 441 #if defined(BOOST_BIG_ENDIAN)
 442     BOOST_STATIC_CONSTANT(int, offset_ = 0);
 443 #elif defined(BOOST_LITTLE_ENDIAN)
 444     BOOST_STATIC_CONSTANT(int, offset_ = 12);
 445 #else
 446     BOOST_STATIC_ASSERT(false);
 447 #endif
 448 };
 449
 450
 451 // long double (>64 bits), Motorola 68K ----------------------------------------
 452
 453 #elif defined(__m68k) || defined(__m68k__) \
 454     || defined(__mc68000) || defined(__mc68000__) \
 455
 456 // Motorola extended double precision format (96 bits)
 457
 458 // It is the same format as the Intel extended double precision format,
 459 // except that 1) it is big-endian, 2) the 3rd and 4th byte are padding, and
 460 // 3) the flag bit is not set for infinity
 461
 462 template<> struct fp_traits_impl<long double, extended_double_precision_tag>
 463 {
 464     typedef uint32_t bits;
 465     typedef not_all_bits coverage;
 466
 467     BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
 468     BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
 469     BOOST_STATIC_CONSTANT(uint32_t, flag     = 0x00008000);
 470     BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x00007fff);
 471
 472     static void init() {}
 473
 474     // copy 1st, 2nd, 5th and 6th byte. 3rd and 4th byte are padding.
 475
 476     static void get_bits(long double x, uint32_t& a)
 477     {
 478         memcpy(&a, &x, 2);
 479         memcpy(reinterpret_cast<unsigned char*>(&a) + 2,
 480                reinterpret_cast<const unsigned char*>(&x) + 4, 2);
 481     }
 482
 483     static void set_bits(long double& x, uint32_t a)
 484     {
 485         memcpy(&x, &a, 2);
 486         memcpy(reinterpret_cast<unsigned char*>(&x) + 4,
 487                reinterpret_cast<const unsigned char*>(&a) + 2, 2);
 488     }
 489 };
 490
 491
 492 // long double (>64 bits), All other processors --------------------------------
 493
 494 #else
 495
 496 // IEEE extended double precision format with 15 exponent bits (128 bits)
 497
 498 template<> struct fp_traits_impl<long double, extended_double_precision_tag>
 499 {
 500     typedef uint32_t bits;
 501     typedef not_all_bits coverage;
 502
 503     BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
 504     BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
 505     BOOST_STATIC_CONSTANT(uint32_t, flag     = 0x00000000);
 506     BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x0000ffff);
 507
 508     static void init() {}
 509
 510     static void get_bits(long double x, uint32_t& a)
 511     {
 512         memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
 513     }
 514
 515     static void set_bits(long double& x, uint32_t a)
 516     {
 517         memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
 518     }
 519
 520 private:
 521
 522 #if defined(BOOST_BIG_ENDIAN)
 523     BOOST_STATIC_CONSTANT(int, offset_ = 0);
 524 #elif defined(BOOST_LITTLE_ENDIAN)
 525     BOOST_STATIC_CONSTANT(int, offset_ = 12);
 526 #else
 527     BOOST_STATIC_ASSERT(false);
 528 #endif
 529 };
 530
 531 #endif
 532
 533
 534 //------------------------------------------------------------------------------
 535
 536 // size_to_precision is a type switch for converting a C++ floating point type
 537 // to the corresponding precision type.
 538
 539 template<int n> struct size_to_precision;
 540
 541 template<> struct size_to_precision<4>
 542 {
 543     typedef single_precision_tag type;
 544 };
 545
 546 template<> struct size_to_precision<8>
 547 {
 548     typedef double_precision_tag type;
 549 };
 550
 551 template<> struct size_to_precision<10>
 552 {
 553     typedef extended_double_precision_tag type;
 554 };
 555
 556 template<> struct size_to_precision<12>
 557 {
 558     typedef extended_double_precision_tag type;
 559 };
 560
 561 template<> struct size_to_precision<16>
 562 {
 563     typedef extended_double_precision_tag type;
 564 };
 565
 566 // fp_traits is a type switch that selects the right fp_traits_impl
 567
 568 template<class T> struct fp_traits
 569 {
 570     BOOST_STATIC_ASSERT(boost::is_floating_point<T>::value);
 571     typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T)>::type precision;
 572     typedef fp_traits_impl<T, precision> type;
 573 };
 574
 575
 576 //------------------------------------------------------------------------------
 577
 578 }   // namespace detail
 579 }   // namespace math
 580 }   // namespace spirit
 581 }   // namespace boost
 582
 583 #endif