gcc/machmode.h

   1 /* Machine mode definitions for GCC; included by rtl.h and tree.h.
   2    Copyright (C) 1991-2020 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef HAVE_MACHINE_MODES
  21 #define HAVE_MACHINE_MODES
  22
  23 typedef opt_mode<machine_mode> opt_machine_mode;
  24
  25 extern CONST_MODE_SIZE poly_uint16_pod mode_size[NUM_MACHINE_MODES];
  26 extern CONST_MODE_PRECISION poly_uint16_pod mode_precision[NUM_MACHINE_MODES];
  27 extern const unsigned char mode_inner[NUM_MACHINE_MODES];
  28 extern CONST_MODE_NUNITS poly_uint16_pod mode_nunits[NUM_MACHINE_MODES];
  29 extern CONST_MODE_UNIT_SIZE unsigned char mode_unit_size[NUM_MACHINE_MODES];
  30 extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];
  31 extern const unsigned char mode_wider[NUM_MACHINE_MODES];
  32 extern const unsigned char mode_2xwider[NUM_MACHINE_MODES];
  33
  34 template<typename T>
  35 struct mode_traits
  36 {
  37   /* For use by the machmode support code only.
  38
  39      There are cases in which the machmode support code needs to forcibly
  40      convert a machine_mode to a specific mode class T, and in which the
  41      context guarantees that this is valid without the need for an assert.
  42      This can be done using:
  43
  44        return typename mode_traits<T>::from_int (mode);
  45
  46      when returning a T and:
  47
  48        res = T (typename mode_traits<T>::from_int (mode));
  49
  50      when assigning to a value RES that must be assignment-compatible
  51      with (but possibly not the same as) T.  */
  52 #ifdef USE_ENUM_MODES
  53   /* Allow direct conversion of enums to specific mode classes only
  54      when USE_ENUM_MODES is defined.  This is only intended for use
  55      by gencondmd, so that it can tell more easily when .md conditions
  56      are always false.  */
  57   typedef machine_mode from_int;
  58 #else
  59   /* Here we use an enum type distinct from machine_mode but with the
  60      same range as machine_mode.  T should have a constructor that
  61      accepts this enum type; it should not have a constructor that
  62      accepts machine_mode.
  63
  64      We use this somewhat indirect approach to avoid too many constructor
  65      calls when the compiler is built with -O0.  For example, even in
  66      unoptimized code, the return statement above would construct the
  67      returned T directly from the numerical value of MODE.  */
  68   enum from_int { dummy = MAX_MACHINE_MODE };
  69 #endif
  70 };
  71
  72 template<>
  73 struct mode_traits<machine_mode>
  74 {
  75   /* machine_mode itself needs no conversion.  */
  76   typedef machine_mode from_int;
  77 };
  78
  79 /* Always treat machine modes as fixed-size while compiling code specific
  80    to targets that have no variable-size modes.  */
  81 #if defined (IN_TARGET_CODE) && NUM_POLY_INT_COEFFS == 1
  82 #define ONLY_FIXED_SIZE_MODES 1
  83 #else
  84 #define ONLY_FIXED_SIZE_MODES 0
  85 #endif
  86
  87 /* Get the name of mode MODE as a string.  */
  88
  89 extern const char * const mode_name[NUM_MACHINE_MODES];
  90 #define GET_MODE_NAME(MODE)  mode_name[MODE]
  91
  92 /* Mode classes.  */
  93
  94 #include "mode-classes.def"
  95 #define DEF_MODE_CLASS(M) M
  96 enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
  97 #undef DEF_MODE_CLASS
  98 #undef MODE_CLASSES
  99
 100 /* Get the general kind of object that mode MODE represents
 101    (integer, floating, complex, etc.)  */
 102
 103 extern const unsigned char mode_class[NUM_MACHINE_MODES];
 104 #define GET_MODE_CLASS(MODE)  ((enum mode_class) mode_class[MODE])
 105
 106 /* Nonzero if MODE is an integral mode.  */
 107 #define INTEGRAL_MODE_P(MODE)                   \
 108   (GET_MODE_CLASS (MODE) == MODE_INT            \
 109    || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT \
 110    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT \
 111    || GET_MODE_CLASS (MODE) == MODE_VECTOR_BOOL \
 112    || GET_MODE_CLASS (MODE) == MODE_VECTOR_INT)
 113
 114 /* Nonzero if MODE is a floating-point mode.  */
 115 #define FLOAT_MODE_P(MODE)              \
 116   (GET_MODE_CLASS (MODE) == MODE_FLOAT  \
 117    || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT \
 118    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
 119    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT)
 120
 121 /* Nonzero if MODE is a complex mode.  */
 122 #define COMPLEX_MODE_P(MODE)                    \
 123   (GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT    \
 124    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT)
 125
 126 /* Nonzero if MODE is a vector mode.  */
 127 #define VECTOR_MODE_P(MODE)                             \
 128   (GET_MODE_CLASS (MODE) == MODE_VECTOR_BOOL            \
 129    || GET_MODE_CLASS (MODE) == MODE_VECTOR_INT          \
 130    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT        \
 131    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT        \
 132    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT       \
 133    || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM        \
 134    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM)
 135
 136 /* Nonzero if MODE is a scalar integral mode.  */
 137 #define SCALAR_INT_MODE_P(MODE)                 \
 138   (GET_MODE_CLASS (MODE) == MODE_INT            \
 139    || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT)
 140
 141 /* Nonzero if MODE is a scalar floating point mode.  */
 142 #define SCALAR_FLOAT_MODE_P(MODE)               \
 143   (GET_MODE_CLASS (MODE) == MODE_FLOAT          \
 144    || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
 145
 146 /* Nonzero if MODE is a decimal floating point mode.  */
 147 #define DECIMAL_FLOAT_MODE_P(MODE)              \
 148   (GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
 149
 150 /* Nonzero if MODE is a scalar fract mode.  */
 151 #define SCALAR_FRACT_MODE_P(MODE)       \
 152   (GET_MODE_CLASS (MODE) == MODE_FRACT)
 153
 154 /* Nonzero if MODE is a scalar ufract mode.  */
 155 #define SCALAR_UFRACT_MODE_P(MODE)      \
 156   (GET_MODE_CLASS (MODE) == MODE_UFRACT)
 157
 158 /* Nonzero if MODE is a scalar fract or ufract mode.  */
 159 #define ALL_SCALAR_FRACT_MODE_P(MODE)   \
 160   (SCALAR_FRACT_MODE_P (MODE) || SCALAR_UFRACT_MODE_P (MODE))
 161
 162 /* Nonzero if MODE is a scalar accum mode.  */
 163 #define SCALAR_ACCUM_MODE_P(MODE)       \
 164   (GET_MODE_CLASS (MODE) == MODE_ACCUM)
 165
 166 /* Nonzero if MODE is a scalar uaccum mode.  */
 167 #define SCALAR_UACCUM_MODE_P(MODE)      \
 168   (GET_MODE_CLASS (MODE) == MODE_UACCUM)
 169
 170 /* Nonzero if MODE is a scalar accum or uaccum mode.  */
 171 #define ALL_SCALAR_ACCUM_MODE_P(MODE)   \
 172   (SCALAR_ACCUM_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
 173
 174 /* Nonzero if MODE is a scalar fract or accum mode.  */
 175 #define SIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)  \
 176   (SCALAR_FRACT_MODE_P (MODE) || SCALAR_ACCUM_MODE_P (MODE))
 177
 178 /* Nonzero if MODE is a scalar ufract or uaccum mode.  */
 179 #define UNSIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)        \
 180   (SCALAR_UFRACT_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
 181
 182 /* Nonzero if MODE is a scalar fract, ufract, accum or uaccum mode.  */
 183 #define ALL_SCALAR_FIXED_POINT_MODE_P(MODE)     \
 184   (SIGNED_SCALAR_FIXED_POINT_MODE_P (MODE)      \
 185    || UNSIGNED_SCALAR_FIXED_POINT_MODE_P (MODE))
 186
 187 /* Nonzero if MODE is a scalar/vector fract mode.  */
 188 #define FRACT_MODE_P(MODE)              \
 189   (GET_MODE_CLASS (MODE) == MODE_FRACT  \
 190    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT)
 191
 192 /* Nonzero if MODE is a scalar/vector ufract mode.  */
 193 #define UFRACT_MODE_P(MODE)             \
 194   (GET_MODE_CLASS (MODE) == MODE_UFRACT \
 195    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT)
 196
 197 /* Nonzero if MODE is a scalar/vector fract or ufract mode.  */
 198 #define ALL_FRACT_MODE_P(MODE)          \
 199   (FRACT_MODE_P (MODE) || UFRACT_MODE_P (MODE))
 200
 201 /* Nonzero if MODE is a scalar/vector accum mode.  */
 202 #define ACCUM_MODE_P(MODE)              \
 203   (GET_MODE_CLASS (MODE) == MODE_ACCUM  \
 204    || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM)
 205
 206 /* Nonzero if MODE is a scalar/vector uaccum mode.  */
 207 #define UACCUM_MODE_P(MODE)             \
 208   (GET_MODE_CLASS (MODE) == MODE_UACCUM \
 209    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM)
 210
 211 /* Nonzero if MODE is a scalar/vector accum or uaccum mode.  */
 212 #define ALL_ACCUM_MODE_P(MODE)          \
 213   (ACCUM_MODE_P (MODE) || UACCUM_MODE_P (MODE))
 214
 215 /* Nonzero if MODE is a scalar/vector fract or accum mode.  */
 216 #define SIGNED_FIXED_POINT_MODE_P(MODE)         \
 217   (FRACT_MODE_P (MODE) || ACCUM_MODE_P (MODE))
 218
 219 /* Nonzero if MODE is a scalar/vector ufract or uaccum mode.  */
 220 #define UNSIGNED_FIXED_POINT_MODE_P(MODE)       \
 221   (UFRACT_MODE_P (MODE) || UACCUM_MODE_P (MODE))
 222
 223 /* Nonzero if MODE is a scalar/vector fract, ufract, accum or uaccum mode.  */
 224 #define ALL_FIXED_POINT_MODE_P(MODE)            \
 225   (SIGNED_FIXED_POINT_MODE_P (MODE)             \
 226    || UNSIGNED_FIXED_POINT_MODE_P (MODE))
 227
 228 /* Nonzero if CLASS modes can be widened.  */
 229 #define CLASS_HAS_WIDER_MODES_P(CLASS)         \
 230   (CLASS == MODE_INT                           \
 231    || CLASS == MODE_PARTIAL_INT                \
 232    || CLASS == MODE_FLOAT                      \
 233    || CLASS == MODE_DECIMAL_FLOAT              \
 234    || CLASS == MODE_COMPLEX_FLOAT              \
 235    || CLASS == MODE_FRACT                      \
 236    || CLASS == MODE_UFRACT                     \
 237    || CLASS == MODE_ACCUM                      \
 238    || CLASS == MODE_UACCUM)
 239
 240 /* An optional T (i.e. a T or nothing), where T is some form of mode class.  */
 241 template<typename T>
 242 class opt_mode
 243 {
 244 public:
 245   enum from_int { dummy = MAX_MACHINE_MODE };
 246
 247   ALWAYS_INLINE CONSTEXPR opt_mode () : m_mode (E_VOIDmode) {}
 248   ALWAYS_INLINE CONSTEXPR opt_mode (const T &m) : m_mode (m) {}
 249   template<typename U>
 250   ALWAYS_INLINE CONSTEXPR opt_mode (const U &m) : m_mode (T (m)) {}
 251   ALWAYS_INLINE CONSTEXPR opt_mode (from_int m) : m_mode (machine_mode (m)) {}
 252
 253   machine_mode else_void () const;
 254   machine_mode else_blk () const { return else_mode (BLKmode); }
 255   machine_mode else_mode (machine_mode) const;
 256   T require () const;
 257
 258   bool exists () const;
 259   template<typename U> bool exists (U *) const;
 260
 261   bool operator== (const T &m) const { return m_mode == m; }
 262   bool operator!= (const T &m) const { return m_mode != m; }
 263
 264 private:
 265   machine_mode m_mode;
 266 };
 267
 268 /* If the object contains a T, return its enum value, otherwise return
 269    E_VOIDmode.  */
 270
 271 template<typename T>
 272 ALWAYS_INLINE machine_mode
 273 opt_mode<T>::else_void () const
 274 {
 275   return m_mode;
 276 }
 277
 278 /* If the T exists, return its enum value, otherwise return FALLBACK.  */
 279
 280 template<typename T>
 281 inline machine_mode
 282 opt_mode<T>::else_mode (machine_mode fallback) const
 283 {
 284   return m_mode == E_VOIDmode ? fallback : m_mode;
 285 }
 286
 287 /* Assert that the object contains a T and return it.  */
 288
 289 template<typename T>
 290 inline T
 291 opt_mode<T>::require () const
 292 {
 293   gcc_checking_assert (m_mode != E_VOIDmode);
 294   return typename mode_traits<T>::from_int (m_mode);
 295 }
 296
 297 /* Return true if the object contains a T rather than nothing.  */
 298
 299 template<typename T>
 300 ALWAYS_INLINE bool
 301 opt_mode<T>::exists () const
 302 {
 303   return m_mode != E_VOIDmode;
 304 }
 305
 306 /* Return true if the object contains a T, storing it in *MODE if so.  */
 307
 308 template<typename T>
 309 template<typename U>
 310 inline bool
 311 opt_mode<T>::exists (U *mode) const
 312 {
 313   if (m_mode != E_VOIDmode)
 314     {
 315       *mode = T (typename mode_traits<T>::from_int (m_mode));
 316       return true;
 317     }
 318   return false;
 319 }
 320
 321 /* A POD version of mode class T.  */
 322
 323 template<typename T>
 324 struct pod_mode
 325 {
 326   typedef typename mode_traits<T>::from_int from_int;
 327   typedef typename T::measurement_type measurement_type;
 328
 329   machine_mode m_mode;
 330   ALWAYS_INLINE CONSTEXPR
 331   operator machine_mode () const { return m_mode; }
 332
 333   ALWAYS_INLINE CONSTEXPR
 334   operator T () const { return from_int (m_mode); }
 335
 336   ALWAYS_INLINE pod_mode &operator = (const T &m) { m_mode = m; return *this; }
 337 };
 338
 339 /* Return true if mode M has type T.  */
 340
 341 template<typename T>
 342 inline bool
 343 is_a (machine_mode m)
 344 {
 345   return T::includes_p (m);
 346 }
 347
 348 template<typename T, typename U>
 349 inline bool
 350 is_a (const opt_mode<U> &m)
 351 {
 352   return T::includes_p (m.else_void ());
 353 }
 354
 355 /* Assert that mode M has type T, and return it in that form.  */
 356
 357 template<typename T>
 358 inline T
 359 as_a (machine_mode m)
 360 {
 361   gcc_checking_assert (T::includes_p (m));
 362   return typename mode_traits<T>::from_int (m);
 363 }
 364
 365 template<typename T, typename U>
 366 inline T
 367 as_a (const opt_mode<U> &m)
 368 {
 369   return as_a <T> (m.else_void ());
 370 }
 371
 372 /* Convert M to an opt_mode<T>.  */
 373
 374 template<typename T>
 375 inline opt_mode<T>
 376 dyn_cast (machine_mode m)
 377 {
 378   if (T::includes_p (m))
 379     return T (typename mode_traits<T>::from_int (m));
 380   return opt_mode<T> ();
 381 }
 382
 383 template<typename T, typename U>
 384 inline opt_mode<T>
 385 dyn_cast (const opt_mode<U> &m)
 386 {
 387   return dyn_cast <T> (m.else_void ());
 388 }
 389
 390 /* Return true if mode M has type T, storing it as a T in *RESULT
 391    if so.  */
 392
 393 template<typename T, typename U>
 394 inline bool
 395 is_a (machine_mode m, U *result)
 396 {
 397   if (T::includes_p (m))
 398     {
 399       *result = T (typename mode_traits<T>::from_int (m));
 400       return true;
 401     }
 402   return false;
 403 }
 404
 405 /* Represents a machine mode that is known to be a SCALAR_INT_MODE_P.  */
 406 class scalar_int_mode
 407 {
 408 public:
 409   typedef mode_traits<scalar_int_mode>::from_int from_int;
 410   typedef unsigned short measurement_type;
 411
 412   ALWAYS_INLINE scalar_int_mode () {}
 413
 414   ALWAYS_INLINE CONSTEXPR
 415   scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {}
 416
 417   ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; }
 418
 419   static bool includes_p (machine_mode);
 420
 421 protected:
 422   machine_mode m_mode;
 423 };
 424
 425 /* Return true if M is a scalar_int_mode.  */
 426
 427 inline bool
 428 scalar_int_mode::includes_p (machine_mode m)
 429 {
 430   return SCALAR_INT_MODE_P (m);
 431 }
 432
 433 /* Represents a machine mode that is known to be a SCALAR_FLOAT_MODE_P.  */
 434 class scalar_float_mode
 435 {
 436 public:
 437   typedef mode_traits<scalar_float_mode>::from_int from_int;
 438   typedef unsigned short measurement_type;
 439
 440   ALWAYS_INLINE scalar_float_mode () {}
 441
 442   ALWAYS_INLINE CONSTEXPR
 443   scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {}
 444
 445   ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; }
 446
 447   static bool includes_p (machine_mode);
 448
 449 protected:
 450   machine_mode m_mode;
 451 };
 452
 453 /* Return true if M is a scalar_float_mode.  */
 454
 455 inline bool
 456 scalar_float_mode::includes_p (machine_mode m)
 457 {
 458   return SCALAR_FLOAT_MODE_P (m);
 459 }
 460
 461 /* Represents a machine mode that is known to be scalar.  */
 462 class scalar_mode
 463 {
 464 public:
 465   typedef mode_traits<scalar_mode>::from_int from_int;
 466   typedef unsigned short measurement_type;
 467
 468   ALWAYS_INLINE scalar_mode () {}
 469
 470   ALWAYS_INLINE CONSTEXPR
 471   scalar_mode (from_int m) : m_mode (machine_mode (m)) {}
 472
 473   ALWAYS_INLINE CONSTEXPR
 474   scalar_mode (const scalar_int_mode &m) : m_mode (m) {}
 475
 476   ALWAYS_INLINE CONSTEXPR
 477   scalar_mode (const scalar_float_mode &m) : m_mode (m) {}
 478
 479   ALWAYS_INLINE CONSTEXPR
 480   scalar_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
 481
 482   ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; }
 483
 484   static bool includes_p (machine_mode);
 485
 486 protected:
 487   machine_mode m_mode;
 488 };
 489
 490 /* Return true if M represents some kind of scalar value.  */
 491
 492 inline bool
 493 scalar_mode::includes_p (machine_mode m)
 494 {
 495   switch (GET_MODE_CLASS (m))
 496     {
 497     case MODE_INT:
 498     case MODE_PARTIAL_INT:
 499     case MODE_FRACT:
 500     case MODE_UFRACT:
 501     case MODE_ACCUM:
 502     case MODE_UACCUM:
 503     case MODE_FLOAT:
 504     case MODE_DECIMAL_FLOAT:
 505       return true;
 506     default:
 507       return false;
 508     }
 509 }
 510
 511 /* Represents a machine mode that is known to be a COMPLEX_MODE_P.  */
 512 class complex_mode
 513 {
 514 public:
 515   typedef mode_traits<complex_mode>::from_int from_int;
 516   typedef unsigned short measurement_type;
 517
 518   ALWAYS_INLINE complex_mode () {}
 519
 520   ALWAYS_INLINE CONSTEXPR
 521   complex_mode (from_int m) : m_mode (machine_mode (m)) {}
 522
 523   ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; }
 524
 525   static bool includes_p (machine_mode);
 526
 527 protected:
 528   machine_mode m_mode;
 529 };
 530
 531 /* Return true if M is a complex_mode.  */
 532
 533 inline bool
 534 complex_mode::includes_p (machine_mode m)
 535 {
 536   return COMPLEX_MODE_P (m);
 537 }
 538
 539 /* Return the base GET_MODE_SIZE value for MODE.  */
 540
 541 ALWAYS_INLINE poly_uint16
 542 mode_to_bytes (machine_mode mode)
 543 {
 544 #if GCC_VERSION >= 4001
 545   return (__builtin_constant_p (mode)
 546           ? mode_size_inline (mode) : mode_size[mode]);
 547 #else
 548   return mode_size[mode];
 549 #endif
 550 }
 551
 552 /* Return the base GET_MODE_BITSIZE value for MODE.  */
 553
 554 ALWAYS_INLINE poly_uint16
 555 mode_to_bits (machine_mode mode)
 556 {
 557   return mode_to_bytes (mode) * BITS_PER_UNIT;
 558 }
 559
 560 /* Return the base GET_MODE_PRECISION value for MODE.  */
 561
 562 ALWAYS_INLINE poly_uint16
 563 mode_to_precision (machine_mode mode)
 564 {
 565   return mode_precision[mode];
 566 }
 567
 568 /* Return the base GET_MODE_INNER value for MODE.  */
 569
 570 ALWAYS_INLINE scalar_mode
 571 mode_to_inner (machine_mode mode)
 572 {
 573 #if GCC_VERSION >= 4001
 574   return scalar_mode::from_int (__builtin_constant_p (mode)
 575                                 ? mode_inner_inline (mode)
 576                                 : mode_inner[mode]);
 577 #else
 578   return scalar_mode::from_int (mode_inner[mode]);
 579 #endif
 580 }
 581
 582 /* Return the base GET_MODE_UNIT_SIZE value for MODE.  */
 583
 584 ALWAYS_INLINE unsigned char
 585 mode_to_unit_size (machine_mode mode)
 586 {
 587 #if GCC_VERSION >= 4001
 588   return (__builtin_constant_p (mode)
 589           ? mode_unit_size_inline (mode) : mode_unit_size[mode]);
 590 #else
 591   return mode_unit_size[mode];
 592 #endif
 593 }
 594
 595 /* Return the base GET_MODE_UNIT_PRECISION value for MODE.  */
 596
 597 ALWAYS_INLINE unsigned short
 598 mode_to_unit_precision (machine_mode mode)
 599 {
 600 #if GCC_VERSION >= 4001
 601   return (__builtin_constant_p (mode)
 602           ? mode_unit_precision_inline (mode) : mode_unit_precision[mode]);
 603 #else
 604   return mode_unit_precision[mode];
 605 #endif
 606 }
 607
 608 /* Return the base GET_MODE_NUNITS value for MODE.  */
 609
 610 ALWAYS_INLINE poly_uint16
 611 mode_to_nunits (machine_mode mode)
 612 {
 613 #if GCC_VERSION >= 4001
 614   return (__builtin_constant_p (mode)
 615           ? mode_nunits_inline (mode) : mode_nunits[mode]);
 616 #else
 617   return mode_nunits[mode];
 618 #endif
 619 }
 620
 621 /* Get the size in bytes of an object of mode MODE.  */
 622
 623 #if ONLY_FIXED_SIZE_MODES
 624 #define GET_MODE_SIZE(MODE) ((unsigned short) mode_to_bytes (MODE).coeffs[0])
 625 #else
 626 ALWAYS_INLINE poly_uint16
 627 GET_MODE_SIZE (machine_mode mode)
 628 {
 629   return mode_to_bytes (mode);
 630 }
 631
 632 template<typename T>
 633 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 634 GET_MODE_SIZE (const T &mode)
 635 {
 636   return mode_to_bytes (mode);
 637 }
 638
 639 template<typename T>
 640 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 641 GET_MODE_SIZE (const T &mode)
 642 {
 643   return mode_to_bytes (mode).coeffs[0];
 644 }
 645 #endif
 646
 647 /* Get the size in bits of an object of mode MODE.  */
 648
 649 #if ONLY_FIXED_SIZE_MODES
 650 #define GET_MODE_BITSIZE(MODE) ((unsigned short) mode_to_bits (MODE).coeffs[0])
 651 #else
 652 ALWAYS_INLINE poly_uint16
 653 GET_MODE_BITSIZE (machine_mode mode)
 654 {
 655   return mode_to_bits (mode);
 656 }
 657
 658 template<typename T>
 659 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 660 GET_MODE_BITSIZE (const T &mode)
 661 {
 662   return mode_to_bits (mode);
 663 }
 664
 665 template<typename T>
 666 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 667 GET_MODE_BITSIZE (const T &mode)
 668 {
 669   return mode_to_bits (mode).coeffs[0];
 670 }
 671 #endif
 672
 673 /* Get the number of value bits of an object of mode MODE.  */
 674
 675 #if ONLY_FIXED_SIZE_MODES
 676 #define GET_MODE_PRECISION(MODE) \
 677   ((unsigned short) mode_to_precision (MODE).coeffs[0])
 678 #else
 679 ALWAYS_INLINE poly_uint16
 680 GET_MODE_PRECISION (machine_mode mode)
 681 {
 682   return mode_to_precision (mode);
 683 }
 684
 685 template<typename T>
 686 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 687 GET_MODE_PRECISION (const T &mode)
 688 {
 689   return mode_to_precision (mode);
 690 }
 691
 692 template<typename T>
 693 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 694 GET_MODE_PRECISION (const T &mode)
 695 {
 696   return mode_to_precision (mode).coeffs[0];
 697 }
 698 #endif
 699
 700 /* Get the number of integral bits of an object of mode MODE.  */
 701 extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES];
 702 #define GET_MODE_IBIT(MODE) mode_ibit[MODE]
 703
 704 /* Get the number of fractional bits of an object of mode MODE.  */
 705 extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES];
 706 #define GET_MODE_FBIT(MODE) mode_fbit[MODE]
 707
 708 /* Get a bitmask containing 1 for all bits in a word
 709    that fit within mode MODE.  */
 710
 711 extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES];
 712
 713 #define GET_MODE_MASK(MODE) mode_mask_array[MODE]
 714
 715 /* Return the mode of the basic parts of MODE.  For vector modes this is the
 716    mode of the vector elements.  For complex modes it is the mode of the real
 717    and imaginary parts.  For other modes it is MODE itself.  */
 718
 719 #define GET_MODE_INNER(MODE) (mode_to_inner (MODE))
 720
 721 /* Get the size in bytes or bits of the basic parts of an
 722    object of mode MODE.  */
 723
 724 #define GET_MODE_UNIT_SIZE(MODE) mode_to_unit_size (MODE)
 725
 726 #define GET_MODE_UNIT_BITSIZE(MODE) \
 727   ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))
 728
 729 #define GET_MODE_UNIT_PRECISION(MODE) (mode_to_unit_precision (MODE))
 730
 731 /* Get the number of units in an object of mode MODE.  This is 2 for
 732    complex modes and the number of elements for vector modes.  */
 733
 734 #if ONLY_FIXED_SIZE_MODES
 735 #define GET_MODE_NUNITS(MODE) (mode_to_nunits (MODE).coeffs[0])
 736 #else
 737 ALWAYS_INLINE poly_uint16
 738 GET_MODE_NUNITS (machine_mode mode)
 739 {
 740   return mode_to_nunits (mode);
 741 }
 742
 743 template<typename T>
 744 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 745 GET_MODE_NUNITS (const T &mode)
 746 {
 747   return mode_to_nunits (mode);
 748 }
 749
 750 template<typename T>
 751 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 752 GET_MODE_NUNITS (const T &mode)
 753 {
 754   return mode_to_nunits (mode).coeffs[0];
 755 }
 756 #endif
 757
 758 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI).  */
 759
 760 template<typename T>
 761 ALWAYS_INLINE opt_mode<T>
 762 GET_MODE_WIDER_MODE (const T &m)
 763 {
 764   return typename opt_mode<T>::from_int (mode_wider[m]);
 765 }
 766
 767 /* For scalars, this is a mode with twice the precision.  For vectors,
 768    this is a mode with the same inner mode but with twice the elements.  */
 769
 770 template<typename T>
 771 ALWAYS_INLINE opt_mode<T>
 772 GET_MODE_2XWIDER_MODE (const T &m)
 773 {
 774   return typename opt_mode<T>::from_int (mode_2xwider[m]);
 775 }
 776
 777 /* Get the complex mode from the component mode.  */
 778 extern const unsigned char mode_complex[NUM_MACHINE_MODES];
 779 #define GET_MODE_COMPLEX_MODE(MODE) ((machine_mode) mode_complex[MODE])
 780
 781 /* Represents a machine mode that must have a fixed size.  The main
 782    use of this class is to represent the modes of objects that always
 783    have static storage duration, such as constant pool entries.
 784    (No current target supports the concept of variable-size static data.)  */
 785 class fixed_size_mode
 786 {
 787 public:
 788   typedef mode_traits<fixed_size_mode>::from_int from_int;
 789   typedef unsigned short measurement_type;
 790
 791   ALWAYS_INLINE fixed_size_mode () {}
 792
 793   ALWAYS_INLINE CONSTEXPR
 794   fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {}
 795
 796   ALWAYS_INLINE CONSTEXPR
 797   fixed_size_mode (const scalar_mode &m) : m_mode (m) {}
 798
 799   ALWAYS_INLINE CONSTEXPR
 800   fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {}
 801
 802   ALWAYS_INLINE CONSTEXPR
 803   fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {}
 804
 805   ALWAYS_INLINE CONSTEXPR
 806   fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {}
 807
 808   ALWAYS_INLINE CONSTEXPR
 809   fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
 810
 811   ALWAYS_INLINE CONSTEXPR
 812   fixed_size_mode (const complex_mode &m) : m_mode (m) {}
 813
 814   ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; }
 815
 816   static bool includes_p (machine_mode);
 817
 818 protected:
 819   machine_mode m_mode;
 820 };
 821
 822 /* Return true if MODE has a fixed size.  */
 823
 824 inline bool
 825 fixed_size_mode::includes_p (machine_mode mode)
 826 {
 827   return mode_to_bytes (mode).is_constant ();
 828 }
 829
 830 /* Wrapper for mode arguments to target macros, so that if a target
 831    doesn't need polynomial-sized modes, its header file can continue
 832    to treat everything as fixed_size_mode.  This should go away once
 833    macros are moved to target hooks.  It shouldn't be used in other
 834    contexts.  */
 835 #if NUM_POLY_INT_COEFFS == 1
 836 #define MACRO_MODE(MODE) (as_a <fixed_size_mode> (MODE))
 837 #else
 838 #define MACRO_MODE(MODE) (MODE)
 839 #endif
 840
 841 extern opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int);
 842
 843 /* Return the machine mode to use for a MODE_INT of SIZE bits, if one
 844    exists.  If LIMIT is nonzero, modes wider than MAX_FIXED_MODE_SIZE
 845    will not be used.  */
 846
 847 inline opt_scalar_int_mode
 848 int_mode_for_size (poly_uint64 size, int limit)
 849 {
 850   return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit));
 851 }
 852
 853 /* Return the machine mode to use for a MODE_FLOAT of SIZE bits, if one
 854    exists.  */
 855
 856 inline opt_scalar_float_mode
 857 float_mode_for_size (poly_uint64 size)
 858 {
 859   return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0));
 860 }
 861
 862 /* Likewise for MODE_DECIMAL_FLOAT.  */
 863
 864 inline opt_scalar_float_mode
 865 decimal_float_mode_for_size (unsigned int size)
 866 {
 867   return dyn_cast <scalar_float_mode>
 868     (mode_for_size (size, MODE_DECIMAL_FLOAT, 0));
 869 }
 870
 871 extern machine_mode smallest_mode_for_size (poly_uint64, enum mode_class);
 872
 873 /* Find the narrowest integer mode that contains at least SIZE bits.
 874    Such a mode must exist.  */
 875
 876 inline scalar_int_mode
 877 smallest_int_mode_for_size (poly_uint64 size)
 878 {
 879   return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT));
 880 }
 881
 882 extern opt_scalar_int_mode int_mode_for_mode (machine_mode);
 883 extern opt_machine_mode bitwise_mode_for_mode (machine_mode);
 884 extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64);
 885 extern opt_machine_mode related_vector_mode (machine_mode, scalar_mode,
 886                                              poly_uint64 = 0);
 887 extern opt_machine_mode related_int_vector_mode (machine_mode);
 888
 889 /* A class for iterating through possible bitfield modes.  */
 890 class bit_field_mode_iterator
 891 {
 892 public:
 893   bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT,
 894                            poly_int64, poly_int64,
 895                            unsigned int, bool);
 896   bool next_mode (scalar_int_mode *);
 897   bool prefer_smaller_modes ();
 898
 899 private:
 900   opt_scalar_int_mode m_mode;
 901   /* We use signed values here because the bit position can be negative
 902      for invalid input such as gcc.dg/pr48335-8.c.  */
 903   HOST_WIDE_INT m_bitsize;
 904   HOST_WIDE_INT m_bitpos;
 905   poly_int64 m_bitregion_start;
 906   poly_int64 m_bitregion_end;
 907   unsigned int m_align;
 908   bool m_volatilep;
 909   int m_count;
 910 };
 911
 912 /* Find the best mode to use to access a bit field.  */
 913
 914 extern bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int,
 915                            unsigned HOST_WIDE_INT, bool, scalar_int_mode *);
 916
 917 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.  */
 918
 919 extern CONST_MODE_BASE_ALIGN unsigned short mode_base_align[NUM_MACHINE_MODES];
 920
 921 extern unsigned get_mode_alignment (machine_mode);
 922
 923 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
 924
 925 /* For each class, get the narrowest mode in that class.  */
 926
 927 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
 928 #define GET_CLASS_NARROWEST_MODE(CLASS) \
 929   ((machine_mode) class_narrowest_mode[CLASS])
 930
 931 /* The narrowest full integer mode available on the target.  */
 932
 933 #define NARROWEST_INT_MODE \
 934   (scalar_int_mode \
 935    (scalar_int_mode::from_int (class_narrowest_mode[MODE_INT])))
 936
 937 /* Return the narrowest mode in T's class.  */
 938
 939 template<typename T>
 940 inline T
 941 get_narrowest_mode (T mode)
 942 {
 943   return typename mode_traits<T>::from_int
 944     (class_narrowest_mode[GET_MODE_CLASS (mode)]);
 945 }
 946
 947 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
 948    and the mode whose class is Pmode and whose size is POINTER_SIZE.  */
 949
 950 extern scalar_int_mode byte_mode;
 951 extern scalar_int_mode word_mode;
 952 extern scalar_int_mode ptr_mode;
 953
 954 /* Target-dependent machine mode initialization - in insn-modes.c.  */
 955 extern void init_adjust_machine_modes (void);
 956
 957 #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \
 958   (targetm.truly_noop_truncation (GET_MODE_PRECISION (MODE1), \
 959                                   GET_MODE_PRECISION (MODE2)))
 960
 961 /* Return true if MODE is a scalar integer mode that fits in a
 962    HOST_WIDE_INT.  */
 963
 964 inline bool
 965 HWI_COMPUTABLE_MODE_P (machine_mode mode)
 966 {
 967   machine_mode mme = mode;
 968   return (SCALAR_INT_MODE_P (mme)
 969           && mode_to_precision (mme).coeffs[0] <= HOST_BITS_PER_WIDE_INT);
 970 }
 971
 972 inline bool
 973 HWI_COMPUTABLE_MODE_P (scalar_int_mode mode)
 974 {
 975   return GET_MODE_PRECISION (mode) <= HOST_BITS_PER_WIDE_INT;
 976 }
 977
 978 struct int_n_data_t {
 979   /* These parts are initailized by genmodes output */
 980   unsigned int bitsize;
 981   scalar_int_mode_pod m;
 982   /* RID_* is RID_INTN_BASE + index into this array */
 983 };
 984
 985 /* This is also in tree.h.  genmodes.c guarantees the're sorted from
 986    smallest bitsize to largest bitsize. */
 987 extern bool int_n_enabled_p[NUM_INT_N_ENTS];
 988 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS];
 989
 990 /* Return true if MODE has class MODE_INT, storing it as a scalar_int_mode
 991    in *INT_MODE if so.  */
 992
 993 template<typename T>
 994 inline bool
 995 is_int_mode (machine_mode mode, T *int_mode)
 996 {
 997   if (GET_MODE_CLASS (mode) == MODE_INT)
 998     {
 999       *int_mode = scalar_int_mode (scalar_int_mode::from_int (mode));
1000       return true;
1001     }
1002   return false;
1003 }
1004
1005 /* Return true if MODE has class MODE_FLOAT, storing it as a
1006    scalar_float_mode in *FLOAT_MODE if so.  */
1007
1008 template<typename T>
1009 inline bool
1010 is_float_mode (machine_mode mode, T *float_mode)
1011 {
1012   if (GET_MODE_CLASS (mode) == MODE_FLOAT)
1013     {
1014       *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode));
1015       return true;
1016     }
1017   return false;
1018 }
1019
1020 /* Return true if MODE has class MODE_COMPLEX_INT, storing it as
1021    a complex_mode in *CMODE if so.  */
1022
1023 template<typename T>
1024 inline bool
1025 is_complex_int_mode (machine_mode mode, T *cmode)
1026 {
1027   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
1028     {
1029       *cmode = complex_mode (complex_mode::from_int (mode));
1030       return true;
1031     }
1032   return false;
1033 }
1034
1035 /* Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as
1036    a complex_mode in *CMODE if so.  */
1037
1038 template<typename T>
1039 inline bool
1040 is_complex_float_mode (machine_mode mode, T *cmode)
1041 {
1042   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
1043     {
1044       *cmode = complex_mode (complex_mode::from_int (mode));
1045       return true;
1046     }
1047   return false;
1048 }
1049
1050 /* Return true if MODE is a scalar integer mode with a precision
1051    smaller than LIMIT's precision.  */
1052
1053 inline bool
1054 is_narrower_int_mode (machine_mode mode, scalar_int_mode limit)
1055 {
1056   scalar_int_mode int_mode;
1057   return (is_a <scalar_int_mode> (mode, &int_mode)
1058           && GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit));
1059 }
1060
1061 namespace mode_iterator
1062 {
1063   /* Start mode iterator *ITER at the first mode in class MCLASS, if any.  */
1064
1065   template<typename T>
1066   inline void
1067   start (opt_mode<T> *iter, enum mode_class mclass)
1068   {
1069     if (GET_CLASS_NARROWEST_MODE (mclass) == E_VOIDmode)
1070       *iter = opt_mode<T> ();
1071     else
1072       *iter = as_a<T> (GET_CLASS_NARROWEST_MODE (mclass));
1073   }
1074
1075   inline void
1076   start (machine_mode *iter, enum mode_class mclass)
1077   {
1078     *iter = GET_CLASS_NARROWEST_MODE (mclass);
1079   }
1080
1081   /* Return true if mode iterator *ITER has not reached the end.  */
1082
1083   template<typename T>
1084   inline bool
1085   iterate_p (opt_mode<T> *iter)
1086   {
1087     return iter->exists ();
1088   }
1089
1090   inline bool
1091   iterate_p (machine_mode *iter)
1092   {
1093     return *iter != E_VOIDmode;
1094   }
1095
1096   /* Set mode iterator *ITER to the next widest mode in the same class,
1097      if any.  */
1098
1099   template<typename T>
1100   inline void
1101   get_wider (opt_mode<T> *iter)
1102   {
1103     *iter = GET_MODE_WIDER_MODE (iter->require ());
1104   }
1105
1106   inline void
1107   get_wider (machine_mode *iter)
1108   {
1109     *iter = GET_MODE_WIDER_MODE (*iter).else_void ();
1110   }
1111
1112   /* Set mode iterator *ITER to the next widest mode in the same class.
1113      Such a mode is known to exist.  */
1114
1115   template<typename T>
1116   inline void
1117   get_known_wider (T *iter)
1118   {
1119     *iter = GET_MODE_WIDER_MODE (*iter).require ();
1120   }
1121
1122   /* Set mode iterator *ITER to the mode that is two times wider than the
1123      current one, if such a mode exists.  */
1124
1125   template<typename T>
1126   inline void
1127   get_2xwider (opt_mode<T> *iter)
1128   {
1129     *iter = GET_MODE_2XWIDER_MODE (iter->require ());
1130   }
1131
1132   inline void
1133   get_2xwider (machine_mode *iter)
1134   {
1135     *iter = GET_MODE_2XWIDER_MODE (*iter).else_void ();
1136   }
1137 }
1138
1139 /* Make ITERATOR iterate over all the modes in mode class CLASS,
1140    from narrowest to widest.  */
1141 #define FOR_EACH_MODE_IN_CLASS(ITERATOR, CLASS)  \
1142   for (mode_iterator::start (&(ITERATOR), CLASS); \
1143        mode_iterator::iterate_p (&(ITERATOR)); \
1144        mode_iterator::get_wider (&(ITERATOR)))
1145
1146 /* Make ITERATOR iterate over all the modes in the range [START, END),
1147    in order of increasing width.  */
1148 #define FOR_EACH_MODE(ITERATOR, START, END) \
1149   for ((ITERATOR) = (START); \
1150        (ITERATOR) != (END); \
1151        mode_iterator::get_known_wider (&(ITERATOR)))
1152
1153 /* Make ITERATOR iterate over START and all wider modes in the same
1154    class, in order of increasing width.  */
1155 #define FOR_EACH_MODE_FROM(ITERATOR, START) \
1156   for ((ITERATOR) = (START); \
1157        mode_iterator::iterate_p (&(ITERATOR)); \
1158        mode_iterator::get_wider (&(ITERATOR)))
1159
1160 /* Make ITERATOR iterate over modes in the range [NARROWEST, END)
1161    in order of increasing width, where NARROWEST is the narrowest mode
1162    in END's class.  */
1163 #define FOR_EACH_MODE_UNTIL(ITERATOR, END) \
1164   FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END)
1165
1166 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1167    of increasing width.  Start at the first mode wider than START,
1168    or don't iterate at all if there is no wider mode.  */
1169 #define FOR_EACH_WIDER_MODE(ITERATOR, START) \
1170   for ((ITERATOR) = (START), mode_iterator::get_wider (&(ITERATOR)); \
1171        mode_iterator::iterate_p (&(ITERATOR)); \
1172        mode_iterator::get_wider (&(ITERATOR)))
1173
1174 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1175    of increasing width, and with each mode being twice the width of the
1176    previous mode.  Start at the mode that is two times wider than START,
1177    or don't iterate at all if there is no such mode.  */
1178 #define FOR_EACH_2XWIDER_MODE(ITERATOR, START) \
1179   for ((ITERATOR) = (START), mode_iterator::get_2xwider (&(ITERATOR)); \
1180        mode_iterator::iterate_p (&(ITERATOR)); \
1181        mode_iterator::get_2xwider (&(ITERATOR)))
1182
1183 template<typename T>
1184 void
1185 gt_ggc_mx (pod_mode<T> *)
1186 {
1187 }
1188
1189 template<typename T>
1190 void
1191 gt_pch_nx (pod_mode<T> *)
1192 {
1193 }
1194
1195 template<typename T>
1196 void
1197 gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *)
1198 {
1199 }
1200
1201 #endif /* not HAVE_MACHINE_MODES */