gcc/machmode.h

   1 /* Machine mode definitions for GCC; included by rtl.h and tree.h.
   2    Copyright (C) 1991-2018 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 #define POINTER_BOUNDS_MODE_P(MODE)      \
 241   (GET_MODE_CLASS (MODE) == MODE_POINTER_BOUNDS)
 242
 243 /* An optional T (i.e. a T or nothing), where T is some form of mode class.  */
 244 template<typename T>
 245 class opt_mode
 246 {
 247 public:
 248   enum from_int { dummy = MAX_MACHINE_MODE };
 249
 250   ALWAYS_INLINE opt_mode () : m_mode (E_VOIDmode) {}
 251   ALWAYS_INLINE opt_mode (const T &m) : m_mode (m) {}
 252   template<typename U>
 253   ALWAYS_INLINE opt_mode (const U &m) : m_mode (T (m)) {}
 254   ALWAYS_INLINE opt_mode (from_int m) : m_mode (machine_mode (m)) {}
 255
 256   machine_mode else_void () const;
 257   machine_mode else_blk () const;
 258   T require () const;
 259
 260   bool exists () const;
 261   template<typename U> bool exists (U *) const;
 262
 263 private:
 264   machine_mode m_mode;
 265 };
 266
 267 /* If the object contains a T, return its enum value, otherwise return
 268    E_VOIDmode.  */
 269
 270 template<typename T>
 271 ALWAYS_INLINE machine_mode
 272 opt_mode<T>::else_void () const
 273 {
 274   return m_mode;
 275 }
 276
 277 /* If the T exists, return its enum value, otherwise return E_BLKmode.  */
 278
 279 template<typename T>
 280 inline machine_mode
 281 opt_mode<T>::else_blk () const
 282 {
 283   return m_mode == E_VOIDmode ? E_BLKmode : m_mode;
 284 }
 285
 286 /* Assert that the object contains a T and return it.  */
 287
 288 template<typename T>
 289 inline T
 290 opt_mode<T>::require () const
 291 {
 292   gcc_checking_assert (m_mode != E_VOIDmode);
 293   return typename mode_traits<T>::from_int (m_mode);
 294 }
 295
 296 /* Return true if the object contains a T rather than nothing.  */
 297
 298 template<typename T>
 299 ALWAYS_INLINE bool
 300 opt_mode<T>::exists () const
 301 {
 302   return m_mode != E_VOIDmode;
 303 }
 304
 305 /* Return true if the object contains a T, storing it in *MODE if so.  */
 306
 307 template<typename T>
 308 template<typename U>
 309 inline bool
 310 opt_mode<T>::exists (U *mode) const
 311 {
 312   if (m_mode != E_VOIDmode)
 313     {
 314       *mode = T (typename mode_traits<T>::from_int (m_mode));
 315       return true;
 316     }
 317   return false;
 318 }
 319
 320 /* A POD version of mode class T.  */
 321
 322 template<typename T>
 323 struct pod_mode
 324 {
 325   typedef typename mode_traits<T>::from_int from_int;
 326   typedef typename T::measurement_type measurement_type;
 327
 328   machine_mode m_mode;
 329   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 330   ALWAYS_INLINE operator T () const { return from_int (m_mode); }
 331   ALWAYS_INLINE pod_mode &operator = (const T &m) { m_mode = m; return *this; }
 332 };
 333
 334 /* Return true if mode M has type T.  */
 335
 336 template<typename T>
 337 inline bool
 338 is_a (machine_mode m)
 339 {
 340   return T::includes_p (m);
 341 }
 342
 343 template<typename T, typename U>
 344 inline bool
 345 is_a (const opt_mode<U> &m)
 346 {
 347   return T::includes_p (m.else_void ());
 348 }
 349
 350 /* Assert that mode M has type T, and return it in that form.  */
 351
 352 template<typename T>
 353 inline T
 354 as_a (machine_mode m)
 355 {
 356   gcc_checking_assert (T::includes_p (m));
 357   return typename mode_traits<T>::from_int (m);
 358 }
 359
 360 template<typename T, typename U>
 361 inline T
 362 as_a (const opt_mode<U> &m)
 363 {
 364   return as_a <T> (m.else_void ());
 365 }
 366
 367 /* Convert M to an opt_mode<T>.  */
 368
 369 template<typename T>
 370 inline opt_mode<T>
 371 dyn_cast (machine_mode m)
 372 {
 373   if (T::includes_p (m))
 374     return T (typename mode_traits<T>::from_int (m));
 375   return opt_mode<T> ();
 376 }
 377
 378 template<typename T, typename U>
 379 inline opt_mode<T>
 380 dyn_cast (const opt_mode<U> &m)
 381 {
 382   return dyn_cast <T> (m.else_void ());
 383 }
 384
 385 /* Return true if mode M has type T, storing it as a T in *RESULT
 386    if so.  */
 387
 388 template<typename T, typename U>
 389 inline bool
 390 is_a (machine_mode m, U *result)
 391 {
 392   if (T::includes_p (m))
 393     {
 394       *result = T (typename mode_traits<T>::from_int (m));
 395       return true;
 396     }
 397   return false;
 398 }
 399
 400 /* Represents a machine mode that is known to be a SCALAR_INT_MODE_P.  */
 401 class scalar_int_mode
 402 {
 403 public:
 404   typedef mode_traits<scalar_int_mode>::from_int from_int;
 405   typedef unsigned short measurement_type;
 406
 407   ALWAYS_INLINE scalar_int_mode () {}
 408   ALWAYS_INLINE scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {}
 409   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 410
 411   static bool includes_p (machine_mode);
 412
 413 protected:
 414   machine_mode m_mode;
 415 };
 416
 417 /* Return true if M is a scalar_int_mode.  */
 418
 419 inline bool
 420 scalar_int_mode::includes_p (machine_mode m)
 421 {
 422   return SCALAR_INT_MODE_P (m);
 423 }
 424
 425 /* Represents a machine mode that is known to be a SCALAR_FLOAT_MODE_P.  */
 426 class scalar_float_mode
 427 {
 428 public:
 429   typedef mode_traits<scalar_float_mode>::from_int from_int;
 430   typedef unsigned short measurement_type;
 431
 432   ALWAYS_INLINE scalar_float_mode () {}
 433   ALWAYS_INLINE scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {}
 434   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 435
 436   static bool includes_p (machine_mode);
 437
 438 protected:
 439   machine_mode m_mode;
 440 };
 441
 442 /* Return true if M is a scalar_float_mode.  */
 443
 444 inline bool
 445 scalar_float_mode::includes_p (machine_mode m)
 446 {
 447   return SCALAR_FLOAT_MODE_P (m);
 448 }
 449
 450 /* Represents a machine mode that is known to be scalar.  */
 451 class scalar_mode
 452 {
 453 public:
 454   typedef mode_traits<scalar_mode>::from_int from_int;
 455   typedef unsigned short measurement_type;
 456
 457   ALWAYS_INLINE scalar_mode () {}
 458   ALWAYS_INLINE scalar_mode (from_int m) : m_mode (machine_mode (m)) {}
 459   ALWAYS_INLINE scalar_mode (const scalar_int_mode &m) : m_mode (m) {}
 460   ALWAYS_INLINE scalar_mode (const scalar_float_mode &m) : m_mode (m) {}
 461   ALWAYS_INLINE scalar_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
 462   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 463
 464   static bool includes_p (machine_mode);
 465
 466 protected:
 467   machine_mode m_mode;
 468 };
 469
 470 /* Return true if M represents some kind of scalar value.  */
 471
 472 inline bool
 473 scalar_mode::includes_p (machine_mode m)
 474 {
 475   switch (GET_MODE_CLASS (m))
 476     {
 477     case MODE_INT:
 478     case MODE_PARTIAL_INT:
 479     case MODE_FRACT:
 480     case MODE_UFRACT:
 481     case MODE_ACCUM:
 482     case MODE_UACCUM:
 483     case MODE_FLOAT:
 484     case MODE_DECIMAL_FLOAT:
 485     case MODE_POINTER_BOUNDS:
 486       return true;
 487     default:
 488       return false;
 489     }
 490 }
 491
 492 /* Represents a machine mode that is known to be a COMPLEX_MODE_P.  */
 493 class complex_mode
 494 {
 495 public:
 496   typedef mode_traits<complex_mode>::from_int from_int;
 497   typedef unsigned short measurement_type;
 498
 499   ALWAYS_INLINE complex_mode () {}
 500   ALWAYS_INLINE complex_mode (from_int m) : m_mode (machine_mode (m)) {}
 501   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 502
 503   static bool includes_p (machine_mode);
 504
 505 protected:
 506   machine_mode m_mode;
 507 };
 508
 509 /* Return true if M is a complex_mode.  */
 510
 511 inline bool
 512 complex_mode::includes_p (machine_mode m)
 513 {
 514   return COMPLEX_MODE_P (m);
 515 }
 516
 517 /* Return the base GET_MODE_SIZE value for MODE.  */
 518
 519 ALWAYS_INLINE poly_uint16
 520 mode_to_bytes (machine_mode mode)
 521 {
 522 #if GCC_VERSION >= 4001
 523   return (__builtin_constant_p (mode)
 524           ? mode_size_inline (mode) : mode_size[mode]);
 525 #else
 526   return mode_size[mode];
 527 #endif
 528 }
 529
 530 /* Return the base GET_MODE_BITSIZE value for MODE.  */
 531
 532 ALWAYS_INLINE poly_uint16
 533 mode_to_bits (machine_mode mode)
 534 {
 535   return mode_to_bytes (mode) * BITS_PER_UNIT;
 536 }
 537
 538 /* Return the base GET_MODE_PRECISION value for MODE.  */
 539
 540 ALWAYS_INLINE poly_uint16
 541 mode_to_precision (machine_mode mode)
 542 {
 543   return mode_precision[mode];
 544 }
 545
 546 /* Return the base GET_MODE_INNER value for MODE.  */
 547
 548 ALWAYS_INLINE scalar_mode
 549 mode_to_inner (machine_mode mode)
 550 {
 551 #if GCC_VERSION >= 4001
 552   return scalar_mode::from_int (__builtin_constant_p (mode)
 553                                 ? mode_inner_inline (mode)
 554                                 : mode_inner[mode]);
 555 #else
 556   return scalar_mode::from_int (mode_inner[mode]);
 557 #endif
 558 }
 559
 560 /* Return the base GET_MODE_UNIT_SIZE value for MODE.  */
 561
 562 ALWAYS_INLINE unsigned char
 563 mode_to_unit_size (machine_mode mode)
 564 {
 565 #if GCC_VERSION >= 4001
 566   return (__builtin_constant_p (mode)
 567           ? mode_unit_size_inline (mode) : mode_unit_size[mode]);
 568 #else
 569   return mode_unit_size[mode];
 570 #endif
 571 }
 572
 573 /* Return the base GET_MODE_UNIT_PRECISION value for MODE.  */
 574
 575 ALWAYS_INLINE unsigned short
 576 mode_to_unit_precision (machine_mode mode)
 577 {
 578 #if GCC_VERSION >= 4001
 579   return (__builtin_constant_p (mode)
 580           ? mode_unit_precision_inline (mode) : mode_unit_precision[mode]);
 581 #else
 582   return mode_unit_precision[mode];
 583 #endif
 584 }
 585
 586 /* Return the base GET_MODE_NUNITS value for MODE.  */
 587
 588 ALWAYS_INLINE poly_uint16
 589 mode_to_nunits (machine_mode mode)
 590 {
 591 #if GCC_VERSION >= 4001
 592   return (__builtin_constant_p (mode)
 593           ? mode_nunits_inline (mode) : mode_nunits[mode]);
 594 #else
 595   return mode_nunits[mode];
 596 #endif
 597 }
 598
 599 /* Get the size in bytes of an object of mode MODE.  */
 600
 601 #if ONLY_FIXED_SIZE_MODES
 602 #define GET_MODE_SIZE(MODE) ((unsigned short) mode_to_bytes (MODE).coeffs[0])
 603 #else
 604 ALWAYS_INLINE poly_uint16
 605 GET_MODE_SIZE (machine_mode mode)
 606 {
 607   return mode_to_bytes (mode);
 608 }
 609
 610 template<typename T>
 611 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 612 GET_MODE_SIZE (const T &mode)
 613 {
 614   return mode_to_bytes (mode);
 615 }
 616
 617 template<typename T>
 618 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 619 GET_MODE_SIZE (const T &mode)
 620 {
 621   return mode_to_bytes (mode).coeffs[0];
 622 }
 623 #endif
 624
 625 /* Get the size in bits of an object of mode MODE.  */
 626
 627 #if ONLY_FIXED_SIZE_MODES
 628 #define GET_MODE_BITSIZE(MODE) ((unsigned short) mode_to_bits (MODE).coeffs[0])
 629 #else
 630 ALWAYS_INLINE poly_uint16
 631 GET_MODE_BITSIZE (machine_mode mode)
 632 {
 633   return mode_to_bits (mode);
 634 }
 635
 636 template<typename T>
 637 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 638 GET_MODE_BITSIZE (const T &mode)
 639 {
 640   return mode_to_bits (mode);
 641 }
 642
 643 template<typename T>
 644 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 645 GET_MODE_BITSIZE (const T &mode)
 646 {
 647   return mode_to_bits (mode).coeffs[0];
 648 }
 649 #endif
 650
 651 /* Get the number of value bits of an object of mode MODE.  */
 652
 653 #if ONLY_FIXED_SIZE_MODES
 654 #define GET_MODE_PRECISION(MODE) \
 655   ((unsigned short) mode_to_precision (MODE).coeffs[0])
 656 #else
 657 ALWAYS_INLINE poly_uint16
 658 GET_MODE_PRECISION (machine_mode mode)
 659 {
 660   return mode_to_precision (mode);
 661 }
 662
 663 template<typename T>
 664 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 665 GET_MODE_PRECISION (const T &mode)
 666 {
 667   return mode_to_precision (mode);
 668 }
 669
 670 template<typename T>
 671 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 672 GET_MODE_PRECISION (const T &mode)
 673 {
 674   return mode_to_precision (mode).coeffs[0];
 675 }
 676 #endif
 677
 678 /* Get the number of integral bits of an object of mode MODE.  */
 679 extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES];
 680 #define GET_MODE_IBIT(MODE) mode_ibit[MODE]
 681
 682 /* Get the number of fractional bits of an object of mode MODE.  */
 683 extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES];
 684 #define GET_MODE_FBIT(MODE) mode_fbit[MODE]
 685
 686 /* Get a bitmask containing 1 for all bits in a word
 687    that fit within mode MODE.  */
 688
 689 extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES];
 690
 691 #define GET_MODE_MASK(MODE) mode_mask_array[MODE]
 692
 693 /* Return the mode of the basic parts of MODE.  For vector modes this is the
 694    mode of the vector elements.  For complex modes it is the mode of the real
 695    and imaginary parts.  For other modes it is MODE itself.  */
 696
 697 #define GET_MODE_INNER(MODE) (mode_to_inner (MODE))
 698
 699 /* Get the size in bytes or bits of the basic parts of an
 700    object of mode MODE.  */
 701
 702 #define GET_MODE_UNIT_SIZE(MODE) mode_to_unit_size (MODE)
 703
 704 #define GET_MODE_UNIT_BITSIZE(MODE) \
 705   ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))
 706
 707 #define GET_MODE_UNIT_PRECISION(MODE) (mode_to_unit_precision (MODE))
 708
 709 /* Get the number of units in an object of mode MODE.  This is 2 for
 710    complex modes and the number of elements for vector modes.  */
 711
 712 #if ONLY_FIXED_SIZE_MODES
 713 #define GET_MODE_NUNITS(MODE) (mode_to_nunits (MODE).coeffs[0])
 714 #else
 715 ALWAYS_INLINE poly_uint16
 716 GET_MODE_NUNITS (machine_mode mode)
 717 {
 718   return mode_to_nunits (mode);
 719 }
 720
 721 template<typename T>
 722 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 723 GET_MODE_NUNITS (const T &mode)
 724 {
 725   return mode_to_nunits (mode);
 726 }
 727
 728 template<typename T>
 729 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 730 GET_MODE_NUNITS (const T &mode)
 731 {
 732   return mode_to_nunits (mode).coeffs[0];
 733 }
 734 #endif
 735
 736 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI).  */
 737
 738 template<typename T>
 739 ALWAYS_INLINE opt_mode<T>
 740 GET_MODE_WIDER_MODE (const T &m)
 741 {
 742   return typename opt_mode<T>::from_int (mode_wider[m]);
 743 }
 744
 745 /* For scalars, this is a mode with twice the precision.  For vectors,
 746    this is a mode with the same inner mode but with twice the elements.  */
 747
 748 template<typename T>
 749 ALWAYS_INLINE opt_mode<T>
 750 GET_MODE_2XWIDER_MODE (const T &m)
 751 {
 752   return typename opt_mode<T>::from_int (mode_2xwider[m]);
 753 }
 754
 755 /* Get the complex mode from the component mode.  */
 756 extern const unsigned char mode_complex[NUM_MACHINE_MODES];
 757 #define GET_MODE_COMPLEX_MODE(MODE) ((machine_mode) mode_complex[MODE])
 758
 759 /* Represents a machine mode that must have a fixed size.  The main
 760    use of this class is to represent the modes of objects that always
 761    have static storage duration, such as constant pool entries.
 762    (No current target supports the concept of variable-size static data.)  */
 763 class fixed_size_mode
 764 {
 765 public:
 766   typedef mode_traits<fixed_size_mode>::from_int from_int;
 767   typedef unsigned short measurement_type;
 768
 769   ALWAYS_INLINE fixed_size_mode () {}
 770   ALWAYS_INLINE fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {}
 771   ALWAYS_INLINE fixed_size_mode (const scalar_mode &m) : m_mode (m) {}
 772   ALWAYS_INLINE fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {}
 773   ALWAYS_INLINE fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {}
 774   ALWAYS_INLINE fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {}
 775   ALWAYS_INLINE fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
 776   ALWAYS_INLINE fixed_size_mode (const complex_mode &m) : m_mode (m) {}
 777   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 778
 779   static bool includes_p (machine_mode);
 780
 781 protected:
 782   machine_mode m_mode;
 783 };
 784
 785 /* Return true if MODE has a fixed size.  */
 786
 787 inline bool
 788 fixed_size_mode::includes_p (machine_mode mode)
 789 {
 790   return mode_to_bytes (mode).is_constant ();
 791 }
 792
 793 /* Wrapper for mode arguments to target macros, so that if a target
 794    doesn't need polynomial-sized modes, its header file can continue
 795    to treat everything as fixed_size_mode.  This should go away once
 796    macros are moved to target hooks.  It shouldn't be used in other
 797    contexts.  */
 798 #if NUM_POLY_INT_COEFFS == 1
 799 #define MACRO_MODE(MODE) (as_a <fixed_size_mode> (MODE))
 800 #else
 801 #define MACRO_MODE(MODE) (MODE)
 802 #endif
 803
 804 extern opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int);
 805
 806 /* Return the machine mode to use for a MODE_INT of SIZE bits, if one
 807    exists.  If LIMIT is nonzero, modes wider than MAX_FIXED_MODE_SIZE
 808    will not be used.  */
 809
 810 inline opt_scalar_int_mode
 811 int_mode_for_size (poly_uint64 size, int limit)
 812 {
 813   return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit));
 814 }
 815
 816 /* Return the machine mode to use for a MODE_FLOAT of SIZE bits, if one
 817    exists.  */
 818
 819 inline opt_scalar_float_mode
 820 float_mode_for_size (poly_uint64 size)
 821 {
 822   return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0));
 823 }
 824
 825 /* Likewise for MODE_DECIMAL_FLOAT.  */
 826
 827 inline opt_scalar_float_mode
 828 decimal_float_mode_for_size (unsigned int size)
 829 {
 830   return dyn_cast <scalar_float_mode>
 831     (mode_for_size (size, MODE_DECIMAL_FLOAT, 0));
 832 }
 833
 834 extern machine_mode smallest_mode_for_size (poly_uint64, enum mode_class);
 835
 836 /* Find the narrowest integer mode that contains at least SIZE bits.
 837    Such a mode must exist.  */
 838
 839 inline scalar_int_mode
 840 smallest_int_mode_for_size (poly_uint64 size)
 841 {
 842   return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT));
 843 }
 844
 845 extern opt_scalar_int_mode int_mode_for_mode (machine_mode);
 846 extern opt_machine_mode bitwise_mode_for_mode (machine_mode);
 847 extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64);
 848 extern opt_machine_mode mode_for_int_vector (unsigned int, poly_uint64);
 849
 850 /* Return the integer vector equivalent of MODE, if one exists.  In other
 851    words, return the mode for an integer vector that has the same number
 852    of bits as MODE and the same number of elements as MODE, with the
 853    latter being 1 if MODE is scalar.  The returned mode can be either
 854    an integer mode or a vector mode.  */
 855
 856 inline opt_machine_mode
 857 mode_for_int_vector (machine_mode mode)
 858 {
 859   return mode_for_int_vector (GET_MODE_UNIT_BITSIZE (mode),
 860                               GET_MODE_NUNITS (mode));
 861 }
 862
 863 /* A class for iterating through possible bitfield modes.  */
 864 class bit_field_mode_iterator
 865 {
 866 public:
 867   bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT,
 868                            poly_int64, poly_int64,
 869                            unsigned int, bool);
 870   bool next_mode (scalar_int_mode *);
 871   bool prefer_smaller_modes ();
 872
 873 private:
 874   opt_scalar_int_mode m_mode;
 875   /* We use signed values here because the bit position can be negative
 876      for invalid input such as gcc.dg/pr48335-8.c.  */
 877   HOST_WIDE_INT m_bitsize;
 878   HOST_WIDE_INT m_bitpos;
 879   poly_int64 m_bitregion_start;
 880   poly_int64 m_bitregion_end;
 881   unsigned int m_align;
 882   bool m_volatilep;
 883   int m_count;
 884 };
 885
 886 /* Find the best mode to use to access a bit field.  */
 887
 888 extern bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int,
 889                            unsigned HOST_WIDE_INT, bool, scalar_int_mode *);
 890
 891 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.  */
 892
 893 extern CONST_MODE_BASE_ALIGN unsigned short mode_base_align[NUM_MACHINE_MODES];
 894
 895 extern unsigned get_mode_alignment (machine_mode);
 896
 897 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
 898
 899 /* For each class, get the narrowest mode in that class.  */
 900
 901 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
 902 #define GET_CLASS_NARROWEST_MODE(CLASS) \
 903   ((machine_mode) class_narrowest_mode[CLASS])
 904
 905 /* The narrowest full integer mode available on the target.  */
 906
 907 #define NARROWEST_INT_MODE \
 908   (scalar_int_mode \
 909    (scalar_int_mode::from_int (class_narrowest_mode[MODE_INT])))
 910
 911 /* Return the narrowest mode in T's class.  */
 912
 913 template<typename T>
 914 inline T
 915 get_narrowest_mode (T mode)
 916 {
 917   return typename mode_traits<T>::from_int
 918     (class_narrowest_mode[GET_MODE_CLASS (mode)]);
 919 }
 920
 921 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
 922    and the mode whose class is Pmode and whose size is POINTER_SIZE.  */
 923
 924 extern scalar_int_mode byte_mode;
 925 extern scalar_int_mode word_mode;
 926 extern scalar_int_mode ptr_mode;
 927
 928 /* Target-dependent machine mode initialization - in insn-modes.c.  */
 929 extern void init_adjust_machine_modes (void);
 930
 931 #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \
 932   (targetm.truly_noop_truncation (GET_MODE_PRECISION (MODE1), \
 933                                   GET_MODE_PRECISION (MODE2)))
 934
 935 /* Return true if MODE is a scalar integer mode that fits in a
 936    HOST_WIDE_INT.  */
 937
 938 inline bool
 939 HWI_COMPUTABLE_MODE_P (machine_mode mode)
 940 {
 941   machine_mode mme = mode;
 942   return (SCALAR_INT_MODE_P (mme)
 943           && mode_to_precision (mme).coeffs[0] <= HOST_BITS_PER_WIDE_INT);
 944 }
 945
 946 inline bool
 947 HWI_COMPUTABLE_MODE_P (scalar_int_mode mode)
 948 {
 949   return GET_MODE_PRECISION (mode) <= HOST_BITS_PER_WIDE_INT;
 950 }
 951
 952 struct int_n_data_t {
 953   /* These parts are initailized by genmodes output */
 954   unsigned int bitsize;
 955   scalar_int_mode_pod m;
 956   /* RID_* is RID_INTN_BASE + index into this array */
 957 };
 958
 959 /* This is also in tree.h.  genmodes.c guarantees the're sorted from
 960    smallest bitsize to largest bitsize. */
 961 extern bool int_n_enabled_p[NUM_INT_N_ENTS];
 962 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS];
 963
 964 /* Return true if MODE has class MODE_INT, storing it as a scalar_int_mode
 965    in *INT_MODE if so.  */
 966
 967 template<typename T>
 968 inline bool
 969 is_int_mode (machine_mode mode, T *int_mode)
 970 {
 971   if (GET_MODE_CLASS (mode) == MODE_INT)
 972     {
 973       *int_mode = scalar_int_mode (scalar_int_mode::from_int (mode));
 974       return true;
 975     }
 976   return false;
 977 }
 978
 979 /* Return true if MODE has class MODE_FLOAT, storing it as a
 980    scalar_float_mode in *FLOAT_MODE if so.  */
 981
 982 template<typename T>
 983 inline bool
 984 is_float_mode (machine_mode mode, T *float_mode)
 985 {
 986   if (GET_MODE_CLASS (mode) == MODE_FLOAT)
 987     {
 988       *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode));
 989       return true;
 990     }
 991   return false;
 992 }
 993
 994 /* Return true if MODE has class MODE_COMPLEX_INT, storing it as
 995    a complex_mode in *CMODE if so.  */
 996
 997 template<typename T>
 998 inline bool
 999 is_complex_int_mode (machine_mode mode, T *cmode)
1000 {
1001   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
1002     {
1003       *cmode = complex_mode (complex_mode::from_int (mode));
1004       return true;
1005     }
1006   return false;
1007 }
1008
1009 /* Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as
1010    a complex_mode in *CMODE if so.  */
1011
1012 template<typename T>
1013 inline bool
1014 is_complex_float_mode (machine_mode mode, T *cmode)
1015 {
1016   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
1017     {
1018       *cmode = complex_mode (complex_mode::from_int (mode));
1019       return true;
1020     }
1021   return false;
1022 }
1023
1024 /* Return true if MODE is a scalar integer mode with a precision
1025    smaller than LIMIT's precision.  */
1026
1027 inline bool
1028 is_narrower_int_mode (machine_mode mode, scalar_int_mode limit)
1029 {
1030   scalar_int_mode int_mode;
1031   return (is_a <scalar_int_mode> (mode, &int_mode)
1032           && GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit));
1033 }
1034
1035 namespace mode_iterator
1036 {
1037   /* Start mode iterator *ITER at the first mode in class MCLASS, if any.  */
1038
1039   template<typename T>
1040   inline void
1041   start (opt_mode<T> *iter, enum mode_class mclass)
1042   {
1043     if (GET_CLASS_NARROWEST_MODE (mclass) == E_VOIDmode)
1044       *iter = opt_mode<T> ();
1045     else
1046       *iter = as_a<T> (GET_CLASS_NARROWEST_MODE (mclass));
1047   }
1048
1049   inline void
1050   start (machine_mode *iter, enum mode_class mclass)
1051   {
1052     *iter = GET_CLASS_NARROWEST_MODE (mclass);
1053   }
1054
1055   /* Return true if mode iterator *ITER has not reached the end.  */
1056
1057   template<typename T>
1058   inline bool
1059   iterate_p (opt_mode<T> *iter)
1060   {
1061     return iter->exists ();
1062   }
1063
1064   inline bool
1065   iterate_p (machine_mode *iter)
1066   {
1067     return *iter != E_VOIDmode;
1068   }
1069
1070   /* Set mode iterator *ITER to the next widest mode in the same class,
1071      if any.  */
1072
1073   template<typename T>
1074   inline void
1075   get_wider (opt_mode<T> *iter)
1076   {
1077     *iter = GET_MODE_WIDER_MODE (iter->require ());
1078   }
1079
1080   inline void
1081   get_wider (machine_mode *iter)
1082   {
1083     *iter = GET_MODE_WIDER_MODE (*iter).else_void ();
1084   }
1085
1086   /* Set mode iterator *ITER to the next widest mode in the same class.
1087      Such a mode is known to exist.  */
1088
1089   template<typename T>
1090   inline void
1091   get_known_wider (T *iter)
1092   {
1093     *iter = GET_MODE_WIDER_MODE (*iter).require ();
1094   }
1095
1096   /* Set mode iterator *ITER to the mode that is two times wider than the
1097      current one, if such a mode exists.  */
1098
1099   template<typename T>
1100   inline void
1101   get_2xwider (opt_mode<T> *iter)
1102   {
1103     *iter = GET_MODE_2XWIDER_MODE (iter->require ());
1104   }
1105
1106   inline void
1107   get_2xwider (machine_mode *iter)
1108   {
1109     *iter = GET_MODE_2XWIDER_MODE (*iter).else_void ();
1110   }
1111 }
1112
1113 /* Make ITERATOR iterate over all the modes in mode class CLASS,
1114    from narrowest to widest.  */
1115 #define FOR_EACH_MODE_IN_CLASS(ITERATOR, CLASS)  \
1116   for (mode_iterator::start (&(ITERATOR), CLASS); \
1117        mode_iterator::iterate_p (&(ITERATOR)); \
1118        mode_iterator::get_wider (&(ITERATOR)))
1119
1120 /* Make ITERATOR iterate over all the modes in the range [START, END),
1121    in order of increasing width.  */
1122 #define FOR_EACH_MODE(ITERATOR, START, END) \
1123   for ((ITERATOR) = (START); \
1124        (ITERATOR) != (END); \
1125        mode_iterator::get_known_wider (&(ITERATOR)))
1126
1127 /* Make ITERATOR iterate over START and all wider modes in the same
1128    class, in order of increasing width.  */
1129 #define FOR_EACH_MODE_FROM(ITERATOR, START) \
1130   for ((ITERATOR) = (START); \
1131        mode_iterator::iterate_p (&(ITERATOR)); \
1132        mode_iterator::get_wider (&(ITERATOR)))
1133
1134 /* Make ITERATOR iterate over modes in the range [NARROWEST, END)
1135    in order of increasing width, where NARROWEST is the narrowest mode
1136    in END's class.  */
1137 #define FOR_EACH_MODE_UNTIL(ITERATOR, END) \
1138   FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END)
1139
1140 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1141    of increasing width.  Start at the first mode wider than START,
1142    or don't iterate at all if there is no wider mode.  */
1143 #define FOR_EACH_WIDER_MODE(ITERATOR, START) \
1144   for ((ITERATOR) = (START), mode_iterator::get_wider (&(ITERATOR)); \
1145        mode_iterator::iterate_p (&(ITERATOR)); \
1146        mode_iterator::get_wider (&(ITERATOR)))
1147
1148 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1149    of increasing width, and with each mode being twice the width of the
1150    previous mode.  Start at the mode that is two times wider than START,
1151    or don't iterate at all if there is no such mode.  */
1152 #define FOR_EACH_2XWIDER_MODE(ITERATOR, START) \
1153   for ((ITERATOR) = (START), mode_iterator::get_2xwider (&(ITERATOR)); \
1154        mode_iterator::iterate_p (&(ITERATOR)); \
1155        mode_iterator::get_2xwider (&(ITERATOR)))
1156
1157 template<typename T>
1158 void
1159 gt_ggc_mx (pod_mode<T> *)
1160 {
1161 }
1162
1163 template<typename T>
1164 void
1165 gt_pch_nx (pod_mode<T> *)
1166 {
1167 }
1168
1169 template<typename T>
1170 void
1171 gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *)
1172 {
1173 }
1174
1175 #endif /* not HAVE_MACHINE_MODES */