gcc/machmode.h

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