gcc/machmode.h

   1 /* Machine mode definitions for GCC; included by rtl.h and tree.h.
   2    Copyright (C) 1991-2017 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 unsigned short mode_size[NUM_MACHINE_MODES];
  26 extern const unsigned short mode_precision[NUM_MACHINE_MODES];
  27 extern const unsigned char mode_inner[NUM_MACHINE_MODES];
  28 extern const unsigned char 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 /* Get the name of mode MODE as a string.  */
  80
  81 extern const char * const mode_name[NUM_MACHINE_MODES];
  82 #define GET_MODE_NAME(MODE)  mode_name[MODE]
  83
  84 /* Mode classes.  */
  85
  86 #include "mode-classes.def"
  87 #define DEF_MODE_CLASS(M) M
  88 enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
  89 #undef DEF_MODE_CLASS
  90 #undef MODE_CLASSES
  91
  92 /* Get the general kind of object that mode MODE represents
  93    (integer, floating, complex, etc.)  */
  94
  95 extern const unsigned char mode_class[NUM_MACHINE_MODES];
  96 #define GET_MODE_CLASS(MODE)  ((enum mode_class) mode_class[MODE])
  97
  98 /* Nonzero if MODE is an integral mode.  */
  99 #define INTEGRAL_MODE_P(MODE)                   \
 100   (GET_MODE_CLASS (MODE) == MODE_INT            \
 101    || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT \
 102    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT \
 103    || GET_MODE_CLASS (MODE) == MODE_VECTOR_INT)
 104
 105 /* Nonzero if MODE is a floating-point mode.  */
 106 #define FLOAT_MODE_P(MODE)              \
 107   (GET_MODE_CLASS (MODE) == MODE_FLOAT  \
 108    || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT \
 109    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
 110    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT)
 111
 112 /* Nonzero if MODE is a complex mode.  */
 113 #define COMPLEX_MODE_P(MODE)                    \
 114   (GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT    \
 115    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT)
 116
 117 /* Nonzero if MODE is a vector mode.  */
 118 #define VECTOR_MODE_P(MODE)                     \
 119   (GET_MODE_CLASS (MODE) == MODE_VECTOR_INT     \
 120    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT        \
 121    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT        \
 122    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT       \
 123    || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM        \
 124    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM)
 125
 126 /* Nonzero if MODE is a scalar integral mode.  */
 127 #define SCALAR_INT_MODE_P(MODE)                 \
 128   (GET_MODE_CLASS (MODE) == MODE_INT            \
 129    || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT)
 130
 131 /* Nonzero if MODE is a scalar floating point mode.  */
 132 #define SCALAR_FLOAT_MODE_P(MODE)               \
 133   (GET_MODE_CLASS (MODE) == MODE_FLOAT          \
 134    || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
 135
 136 /* Nonzero if MODE is a decimal floating point mode.  */
 137 #define DECIMAL_FLOAT_MODE_P(MODE)              \
 138   (GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
 139
 140 /* Nonzero if MODE is a scalar fract mode.  */
 141 #define SCALAR_FRACT_MODE_P(MODE)       \
 142   (GET_MODE_CLASS (MODE) == MODE_FRACT)
 143
 144 /* Nonzero if MODE is a scalar ufract mode.  */
 145 #define SCALAR_UFRACT_MODE_P(MODE)      \
 146   (GET_MODE_CLASS (MODE) == MODE_UFRACT)
 147
 148 /* Nonzero if MODE is a scalar fract or ufract mode.  */
 149 #define ALL_SCALAR_FRACT_MODE_P(MODE)   \
 150   (SCALAR_FRACT_MODE_P (MODE) || SCALAR_UFRACT_MODE_P (MODE))
 151
 152 /* Nonzero if MODE is a scalar accum mode.  */
 153 #define SCALAR_ACCUM_MODE_P(MODE)       \
 154   (GET_MODE_CLASS (MODE) == MODE_ACCUM)
 155
 156 /* Nonzero if MODE is a scalar uaccum mode.  */
 157 #define SCALAR_UACCUM_MODE_P(MODE)      \
 158   (GET_MODE_CLASS (MODE) == MODE_UACCUM)
 159
 160 /* Nonzero if MODE is a scalar accum or uaccum mode.  */
 161 #define ALL_SCALAR_ACCUM_MODE_P(MODE)   \
 162   (SCALAR_ACCUM_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
 163
 164 /* Nonzero if MODE is a scalar fract or accum mode.  */
 165 #define SIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)  \
 166   (SCALAR_FRACT_MODE_P (MODE) || SCALAR_ACCUM_MODE_P (MODE))
 167
 168 /* Nonzero if MODE is a scalar ufract or uaccum mode.  */
 169 #define UNSIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)        \
 170   (SCALAR_UFRACT_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
 171
 172 /* Nonzero if MODE is a scalar fract, ufract, accum or uaccum mode.  */
 173 #define ALL_SCALAR_FIXED_POINT_MODE_P(MODE)     \
 174   (SIGNED_SCALAR_FIXED_POINT_MODE_P (MODE)      \
 175    || UNSIGNED_SCALAR_FIXED_POINT_MODE_P (MODE))
 176
 177 /* Nonzero if MODE is a scalar/vector fract mode.  */
 178 #define FRACT_MODE_P(MODE)              \
 179   (GET_MODE_CLASS (MODE) == MODE_FRACT  \
 180    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT)
 181
 182 /* Nonzero if MODE is a scalar/vector ufract mode.  */
 183 #define UFRACT_MODE_P(MODE)             \
 184   (GET_MODE_CLASS (MODE) == MODE_UFRACT \
 185    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT)
 186
 187 /* Nonzero if MODE is a scalar/vector fract or ufract mode.  */
 188 #define ALL_FRACT_MODE_P(MODE)          \
 189   (FRACT_MODE_P (MODE) || UFRACT_MODE_P (MODE))
 190
 191 /* Nonzero if MODE is a scalar/vector accum mode.  */
 192 #define ACCUM_MODE_P(MODE)              \
 193   (GET_MODE_CLASS (MODE) == MODE_ACCUM  \
 194    || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM)
 195
 196 /* Nonzero if MODE is a scalar/vector uaccum mode.  */
 197 #define UACCUM_MODE_P(MODE)             \
 198   (GET_MODE_CLASS (MODE) == MODE_UACCUM \
 199    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM)
 200
 201 /* Nonzero if MODE is a scalar/vector accum or uaccum mode.  */
 202 #define ALL_ACCUM_MODE_P(MODE)          \
 203   (ACCUM_MODE_P (MODE) || UACCUM_MODE_P (MODE))
 204
 205 /* Nonzero if MODE is a scalar/vector fract or accum mode.  */
 206 #define SIGNED_FIXED_POINT_MODE_P(MODE)         \
 207   (FRACT_MODE_P (MODE) || ACCUM_MODE_P (MODE))
 208
 209 /* Nonzero if MODE is a scalar/vector ufract or uaccum mode.  */
 210 #define UNSIGNED_FIXED_POINT_MODE_P(MODE)       \
 211   (UFRACT_MODE_P (MODE) || UACCUM_MODE_P (MODE))
 212
 213 /* Nonzero if MODE is a scalar/vector fract, ufract, accum or uaccum mode.  */
 214 #define ALL_FIXED_POINT_MODE_P(MODE)            \
 215   (SIGNED_FIXED_POINT_MODE_P (MODE)             \
 216    || UNSIGNED_FIXED_POINT_MODE_P (MODE))
 217
 218 /* Nonzero if CLASS modes can be widened.  */
 219 #define CLASS_HAS_WIDER_MODES_P(CLASS)         \
 220   (CLASS == MODE_INT                           \
 221    || CLASS == MODE_PARTIAL_INT                \
 222    || CLASS == MODE_FLOAT                      \
 223    || CLASS == MODE_DECIMAL_FLOAT              \
 224    || CLASS == MODE_COMPLEX_FLOAT              \
 225    || CLASS == MODE_FRACT                      \
 226    || CLASS == MODE_UFRACT                     \
 227    || CLASS == MODE_ACCUM                      \
 228    || CLASS == MODE_UACCUM)
 229
 230 #define POINTER_BOUNDS_MODE_P(MODE)      \
 231   (GET_MODE_CLASS (MODE) == MODE_POINTER_BOUNDS)
 232
 233 /* An optional T (i.e. a T or nothing), where T is some form of mode class.  */
 234 template<typename T>
 235 class opt_mode
 236 {
 237 public:
 238   enum from_int { dummy = MAX_MACHINE_MODE };
 239
 240   ALWAYS_INLINE opt_mode () : m_mode (E_VOIDmode) {}
 241   ALWAYS_INLINE opt_mode (const T &m) : m_mode (m) {}
 242   template<typename U>
 243   ALWAYS_INLINE opt_mode (const U &m) : m_mode (T (m)) {}
 244   ALWAYS_INLINE opt_mode (from_int m) : m_mode (machine_mode (m)) {}
 245
 246   machine_mode else_void () const;
 247   machine_mode else_blk () const;
 248   T require () const;
 249
 250   bool exists () const;
 251   template<typename U> bool exists (U *) const;
 252
 253 private:
 254   machine_mode m_mode;
 255 };
 256
 257 /* If the object contains a T, return its enum value, otherwise return
 258    E_VOIDmode.  */
 259
 260 template<typename T>
 261 ALWAYS_INLINE machine_mode
 262 opt_mode<T>::else_void () const
 263 {
 264   return m_mode;
 265 }
 266
 267 /* If the T exists, return its enum value, otherwise return E_BLKmode.  */
 268
 269 template<typename T>
 270 inline machine_mode
 271 opt_mode<T>::else_blk () const
 272 {
 273   return m_mode == E_VOIDmode ? E_BLKmode : m_mode;
 274 }
 275
 276 /* Assert that the object contains a T and return it.  */
 277
 278 template<typename T>
 279 inline T
 280 opt_mode<T>::require () const
 281 {
 282   gcc_checking_assert (m_mode != E_VOIDmode);
 283   return typename mode_traits<T>::from_int (m_mode);
 284 }
 285
 286 /* Return true if the object contains a T rather than nothing.  */
 287
 288 template<typename T>
 289 ALWAYS_INLINE bool
 290 opt_mode<T>::exists () const
 291 {
 292   return m_mode != E_VOIDmode;
 293 }
 294
 295 /* Return true if the object contains a T, storing it in *MODE if so.  */
 296
 297 template<typename T>
 298 template<typename U>
 299 inline bool
 300 opt_mode<T>::exists (U *mode) const
 301 {
 302   if (m_mode != E_VOIDmode)
 303     {
 304       *mode = T (typename mode_traits<T>::from_int (m_mode));
 305       return true;
 306     }
 307   return false;
 308 }
 309
 310 /* A POD version of mode class T.  */
 311
 312 template<typename T>
 313 struct pod_mode
 314 {
 315   typedef typename mode_traits<T>::from_int from_int;
 316
 317   machine_mode m_mode;
 318   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 319   ALWAYS_INLINE operator T () const { return from_int (m_mode); }
 320   ALWAYS_INLINE pod_mode &operator = (const T &m) { m_mode = m; return *this; }
 321 };
 322
 323 /* Return true if mode M has type T.  */
 324
 325 template<typename T>
 326 inline bool
 327 is_a (machine_mode m)
 328 {
 329   return T::includes_p (m);
 330 }
 331
 332 template<typename T, typename U>
 333 inline bool
 334 is_a (const opt_mode<U> &m)
 335 {
 336   return T::includes_p (m.else_void ());
 337 }
 338
 339 /* Assert that mode M has type T, and return it in that form.  */
 340
 341 template<typename T>
 342 inline T
 343 as_a (machine_mode m)
 344 {
 345   gcc_checking_assert (T::includes_p (m));
 346   return typename mode_traits<T>::from_int (m);
 347 }
 348
 349 template<typename T, typename U>
 350 inline T
 351 as_a (const opt_mode<U> &m)
 352 {
 353   return as_a <T> (m.else_void ());
 354 }
 355
 356 /* Convert M to an opt_mode<T>.  */
 357
 358 template<typename T>
 359 inline opt_mode<T>
 360 dyn_cast (machine_mode m)
 361 {
 362   if (T::includes_p (m))
 363     return T (typename mode_traits<T>::from_int (m));
 364   return opt_mode<T> ();
 365 }
 366
 367 template<typename T, typename U>
 368 inline opt_mode<T>
 369 dyn_cast (const opt_mode<U> &m)
 370 {
 371   return dyn_cast <T> (m.else_void ());
 372 }
 373
 374 /* Return true if mode M has type T, storing it as a T in *RESULT
 375    if so.  */
 376
 377 template<typename T, typename U>
 378 inline bool
 379 is_a (machine_mode m, U *result)
 380 {
 381   if (T::includes_p (m))
 382     {
 383       *result = T (typename mode_traits<T>::from_int (m));
 384       return true;
 385     }
 386   return false;
 387 }
 388
 389 /* Represents a machine mode that is known to be a SCALAR_INT_MODE_P.  */
 390 class scalar_int_mode
 391 {
 392 public:
 393   typedef mode_traits<scalar_int_mode>::from_int from_int;
 394
 395   ALWAYS_INLINE scalar_int_mode () {}
 396   ALWAYS_INLINE scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {}
 397   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 398
 399   static bool includes_p (machine_mode);
 400
 401 protected:
 402   machine_mode m_mode;
 403 };
 404
 405 /* Return true if M is a scalar_int_mode.  */
 406
 407 inline bool
 408 scalar_int_mode::includes_p (machine_mode m)
 409 {
 410   return SCALAR_INT_MODE_P (m);
 411 }
 412
 413 /* Represents a machine mode that is known to be a SCALAR_FLOAT_MODE_P.  */
 414 class scalar_float_mode
 415 {
 416 public:
 417   typedef mode_traits<scalar_float_mode>::from_int from_int;
 418
 419   ALWAYS_INLINE scalar_float_mode () {}
 420   ALWAYS_INLINE scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {}
 421   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 422
 423   static bool includes_p (machine_mode);
 424
 425 protected:
 426   machine_mode m_mode;
 427 };
 428
 429 /* Return true if M is a scalar_float_mode.  */
 430
 431 inline bool
 432 scalar_float_mode::includes_p (machine_mode m)
 433 {
 434   return SCALAR_FLOAT_MODE_P (m);
 435 }
 436
 437 /* Represents a machine mode that is known to be scalar.  */
 438 class scalar_mode
 439 {
 440 public:
 441   typedef mode_traits<scalar_mode>::from_int from_int;
 442
 443   ALWAYS_INLINE scalar_mode () {}
 444   ALWAYS_INLINE scalar_mode (from_int m) : m_mode (machine_mode (m)) {}
 445   ALWAYS_INLINE scalar_mode (const scalar_int_mode &m) : m_mode (m) {}
 446   ALWAYS_INLINE scalar_mode (const scalar_float_mode &m) : m_mode (m) {}
 447   ALWAYS_INLINE scalar_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
 448   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 449
 450   static bool includes_p (machine_mode);
 451
 452 protected:
 453   machine_mode m_mode;
 454 };
 455
 456 /* Return true if M represents some kind of scalar value.  */
 457
 458 inline bool
 459 scalar_mode::includes_p (machine_mode m)
 460 {
 461   switch (GET_MODE_CLASS (m))
 462     {
 463     case MODE_INT:
 464     case MODE_PARTIAL_INT:
 465     case MODE_FRACT:
 466     case MODE_UFRACT:
 467     case MODE_ACCUM:
 468     case MODE_UACCUM:
 469     case MODE_FLOAT:
 470     case MODE_DECIMAL_FLOAT:
 471     case MODE_POINTER_BOUNDS:
 472       return true;
 473     default:
 474       return false;
 475     }
 476 }
 477
 478 /* Represents a machine mode that is known to be a COMPLEX_MODE_P.  */
 479 class complex_mode
 480 {
 481 public:
 482   typedef mode_traits<complex_mode>::from_int from_int;
 483
 484   ALWAYS_INLINE complex_mode () {}
 485   ALWAYS_INLINE complex_mode (from_int m) : m_mode (machine_mode (m)) {}
 486   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 487
 488   static bool includes_p (machine_mode);
 489
 490 protected:
 491   machine_mode m_mode;
 492 };
 493
 494 /* Return true if M is a complex_mode.  */
 495
 496 inline bool
 497 complex_mode::includes_p (machine_mode m)
 498 {
 499   return COMPLEX_MODE_P (m);
 500 }
 501
 502 /* Return the base GET_MODE_SIZE value for MODE.  */
 503
 504 ALWAYS_INLINE unsigned short
 505 mode_to_bytes (machine_mode mode)
 506 {
 507 #if GCC_VERSION >= 4001
 508   return (__builtin_constant_p (mode)
 509           ? mode_size_inline (mode) : mode_size[mode]);
 510 #else
 511   return mode_size[mode];
 512 #endif
 513 }
 514
 515 /* Return the base GET_MODE_BITSIZE value for MODE.  */
 516
 517 ALWAYS_INLINE unsigned short
 518 mode_to_bits (machine_mode mode)
 519 {
 520   return mode_to_bytes (mode) * BITS_PER_UNIT;
 521 }
 522
 523 /* Return the base GET_MODE_PRECISION value for MODE.  */
 524
 525 ALWAYS_INLINE unsigned short
 526 mode_to_precision (machine_mode mode)
 527 {
 528   return mode_precision[mode];
 529 }
 530
 531 /* Return the base GET_MODE_INNER value for MODE.  */
 532
 533 ALWAYS_INLINE scalar_mode
 534 mode_to_inner (machine_mode mode)
 535 {
 536 #if GCC_VERSION >= 4001
 537   return scalar_mode::from_int (__builtin_constant_p (mode)
 538                                 ? mode_inner_inline (mode)
 539                                 : mode_inner[mode]);
 540 #else
 541   return scalar_mode::from_int (mode_inner[mode]);
 542 #endif
 543 }
 544
 545 /* Return the base GET_MODE_UNIT_SIZE value for MODE.  */
 546
 547 ALWAYS_INLINE unsigned char
 548 mode_to_unit_size (machine_mode mode)
 549 {
 550 #if GCC_VERSION >= 4001
 551   return (__builtin_constant_p (mode)
 552           ? mode_unit_size_inline (mode) : mode_unit_size[mode]);
 553 #else
 554   return mode_unit_size[mode];
 555 #endif
 556 }
 557
 558 /* Return the base GET_MODE_UNIT_PRECISION value for MODE.  */
 559
 560 ALWAYS_INLINE unsigned short
 561 mode_to_unit_precision (machine_mode mode)
 562 {
 563 #if GCC_VERSION >= 4001
 564   return (__builtin_constant_p (mode)
 565           ? mode_unit_precision_inline (mode) : mode_unit_precision[mode]);
 566 #else
 567   return mode_unit_precision[mode];
 568 #endif
 569 }
 570
 571 /* Return the base GET_MODE_NUNITS value for MODE.  */
 572
 573 ALWAYS_INLINE unsigned short
 574 mode_to_nunits (machine_mode mode)
 575 {
 576 #if GCC_VERSION >= 4001
 577   return (__builtin_constant_p (mode)
 578           ? mode_nunits_inline (mode) : mode_nunits[mode]);
 579 #else
 580   return mode_nunits[mode];
 581 #endif
 582 }
 583
 584 /* Get the size in bytes of an object of mode MODE.  */
 585
 586 #define GET_MODE_SIZE(MODE) (mode_to_bytes (MODE))
 587
 588 /* Get the size in bits of an object of mode MODE.  */
 589
 590 #define GET_MODE_BITSIZE(MODE) (mode_to_bits (MODE))
 591
 592 /* Get the number of value bits of an object of mode MODE.  */
 593
 594 #define GET_MODE_PRECISION(MODE) (mode_to_precision (MODE))
 595
 596 /* Get the number of integral bits of an object of mode MODE.  */
 597 extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES];
 598 #define GET_MODE_IBIT(MODE) mode_ibit[MODE]
 599
 600 /* Get the number of fractional bits of an object of mode MODE.  */
 601 extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES];
 602 #define GET_MODE_FBIT(MODE) mode_fbit[MODE]
 603
 604 /* Get a bitmask containing 1 for all bits in a word
 605    that fit within mode MODE.  */
 606
 607 extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES];
 608
 609 #define GET_MODE_MASK(MODE) mode_mask_array[MODE]
 610
 611 /* Return the mode of the basic parts of MODE.  For vector modes this is the
 612    mode of the vector elements.  For complex modes it is the mode of the real
 613    and imaginary parts.  For other modes it is MODE itself.  */
 614
 615 #define GET_MODE_INNER(MODE) (mode_to_inner (MODE))
 616
 617 /* Get the size in bytes or bits of the basic parts of an
 618    object of mode MODE.  */
 619
 620 #define GET_MODE_UNIT_SIZE(MODE) mode_to_unit_size (MODE)
 621
 622 #define GET_MODE_UNIT_BITSIZE(MODE) \
 623   ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))
 624
 625 #define GET_MODE_UNIT_PRECISION(MODE) (mode_to_unit_precision (MODE))
 626
 627 /* Get the number of units in an object of mode MODE.  This is 2 for
 628    complex modes and the number of elements for vector modes.  */
 629
 630 #define GET_MODE_NUNITS(MODE) (mode_to_nunits (MODE))
 631
 632 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI).  */
 633
 634 template<typename T>
 635 ALWAYS_INLINE opt_mode<T>
 636 GET_MODE_WIDER_MODE (const T &m)
 637 {
 638   return typename opt_mode<T>::from_int (mode_wider[m]);
 639 }
 640
 641 /* For scalars, this is a mode with twice the precision.  For vectors,
 642    this is a mode with the same inner mode but with twice the elements.  */
 643
 644 template<typename T>
 645 ALWAYS_INLINE opt_mode<T>
 646 GET_MODE_2XWIDER_MODE (const T &m)
 647 {
 648   return typename opt_mode<T>::from_int (mode_2xwider[m]);
 649 }
 650
 651 /* Get the complex mode from the component mode.  */
 652 extern const unsigned char mode_complex[NUM_MACHINE_MODES];
 653 #define GET_MODE_COMPLEX_MODE(MODE) ((machine_mode) mode_complex[MODE])
 654
 655 /* Represents a machine mode that must have a fixed size.  The main
 656    use of this class is to represent the modes of objects that always
 657    have static storage duration, such as constant pool entries.
 658    (No current target supports the concept of variable-size static data.)  */
 659 class fixed_size_mode
 660 {
 661 public:
 662   typedef mode_traits<fixed_size_mode>::from_int from_int;
 663
 664   ALWAYS_INLINE fixed_size_mode () {}
 665   ALWAYS_INLINE fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {}
 666   ALWAYS_INLINE fixed_size_mode (const scalar_mode &m) : m_mode (m) {}
 667   ALWAYS_INLINE fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {}
 668   ALWAYS_INLINE fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {}
 669   ALWAYS_INLINE fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {}
 670   ALWAYS_INLINE fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
 671   ALWAYS_INLINE fixed_size_mode (const complex_mode &m) : m_mode (m) {}
 672   ALWAYS_INLINE operator machine_mode () const { return m_mode; }
 673
 674   static bool includes_p (machine_mode);
 675
 676 protected:
 677   machine_mode m_mode;
 678 };
 679
 680 /* Return true if MODE has a fixed size.  */
 681
 682 inline bool
 683 fixed_size_mode::includes_p (machine_mode)
 684 {
 685   return true;
 686 }
 687
 688 extern opt_machine_mode mode_for_size (unsigned int, enum mode_class, int);
 689
 690 /* Return the machine mode to use for a MODE_INT of SIZE bits, if one
 691    exists.  If LIMIT is nonzero, modes wider than MAX_FIXED_MODE_SIZE
 692    will not be used.  */
 693
 694 inline opt_scalar_int_mode
 695 int_mode_for_size (unsigned int size, int limit)
 696 {
 697   return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit));
 698 }
 699
 700 /* Return the machine mode to use for a MODE_FLOAT of SIZE bits, if one
 701    exists.  */
 702
 703 inline opt_scalar_float_mode
 704 float_mode_for_size (unsigned int size)
 705 {
 706   return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0));
 707 }
 708
 709 /* Likewise for MODE_DECIMAL_FLOAT.  */
 710
 711 inline opt_scalar_float_mode
 712 decimal_float_mode_for_size (unsigned int size)
 713 {
 714   return dyn_cast <scalar_float_mode>
 715     (mode_for_size (size, MODE_DECIMAL_FLOAT, 0));
 716 }
 717
 718 extern machine_mode smallest_mode_for_size (unsigned int, enum mode_class);
 719
 720 /* Find the narrowest integer mode that contains at least SIZE bits.
 721    Such a mode must exist.  */
 722
 723 inline scalar_int_mode
 724 smallest_int_mode_for_size (unsigned int size)
 725 {
 726   return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT));
 727 }
 728
 729 extern opt_scalar_int_mode int_mode_for_mode (machine_mode);
 730 extern opt_machine_mode bitwise_mode_for_mode (machine_mode);
 731 extern opt_machine_mode mode_for_vector (scalar_mode, unsigned);
 732 extern opt_machine_mode mode_for_int_vector (unsigned int, unsigned int);
 733
 734 /* Return the integer vector equivalent of MODE, if one exists.  In other
 735    words, return the mode for an integer vector that has the same number
 736    of bits as MODE and the same number of elements as MODE, with the
 737    latter being 1 if MODE is scalar.  The returned mode can be either
 738    an integer mode or a vector mode.  */
 739
 740 inline opt_machine_mode
 741 mode_for_int_vector (machine_mode mode)
 742 {
 743   return mode_for_int_vector (GET_MODE_UNIT_BITSIZE (mode),
 744                               GET_MODE_NUNITS (mode));
 745 }
 746
 747 /* A class for iterating through possible bitfield modes.  */
 748 class bit_field_mode_iterator
 749 {
 750 public:
 751   bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT,
 752                            HOST_WIDE_INT, HOST_WIDE_INT,
 753                            unsigned int, bool);
 754   bool next_mode (scalar_int_mode *);
 755   bool prefer_smaller_modes ();
 756
 757 private:
 758   opt_scalar_int_mode m_mode;
 759   /* We use signed values here because the bit position can be negative
 760      for invalid input such as gcc.dg/pr48335-8.c.  */
 761   HOST_WIDE_INT m_bitsize;
 762   HOST_WIDE_INT m_bitpos;
 763   HOST_WIDE_INT m_bitregion_start;
 764   HOST_WIDE_INT m_bitregion_end;
 765   unsigned int m_align;
 766   bool m_volatilep;
 767   int m_count;
 768 };
 769
 770 /* Find the best mode to use to access a bit field.  */
 771
 772 extern bool get_best_mode (int, int, unsigned HOST_WIDE_INT,
 773                            unsigned HOST_WIDE_INT, unsigned int,
 774                            unsigned HOST_WIDE_INT, bool, scalar_int_mode *);
 775
 776 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.  */
 777
 778 extern CONST_MODE_BASE_ALIGN unsigned short mode_base_align[NUM_MACHINE_MODES];
 779
 780 extern unsigned get_mode_alignment (machine_mode);
 781
 782 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
 783
 784 /* For each class, get the narrowest mode in that class.  */
 785
 786 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
 787 #define GET_CLASS_NARROWEST_MODE(CLASS) \
 788   ((machine_mode) class_narrowest_mode[CLASS])
 789
 790 /* The narrowest full integer mode available on the target.  */
 791
 792 #define NARROWEST_INT_MODE \
 793   (scalar_int_mode \
 794    (scalar_int_mode::from_int (class_narrowest_mode[MODE_INT])))
 795
 796 /* Return the narrowest mode in T's class.  */
 797
 798 template<typename T>
 799 inline T
 800 get_narrowest_mode (T mode)
 801 {
 802   return typename mode_traits<T>::from_int
 803     (class_narrowest_mode[GET_MODE_CLASS (mode)]);
 804 }
 805
 806 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
 807    and the mode whose class is Pmode and whose size is POINTER_SIZE.  */
 808
 809 extern scalar_int_mode byte_mode;
 810 extern scalar_int_mode word_mode;
 811 extern scalar_int_mode ptr_mode;
 812
 813 /* Target-dependent machine mode initialization - in insn-modes.c.  */
 814 extern void init_adjust_machine_modes (void);
 815
 816 #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \
 817   (targetm.truly_noop_truncation (GET_MODE_PRECISION (MODE1), \
 818                                   GET_MODE_PRECISION (MODE2)))
 819
 820 #define HWI_COMPUTABLE_MODE_P(MODE) \
 821   (SCALAR_INT_MODE_P (MODE) \
 822    && GET_MODE_PRECISION (MODE) <= HOST_BITS_PER_WIDE_INT)
 823
 824 struct int_n_data_t {
 825   /* These parts are initailized by genmodes output */
 826   unsigned int bitsize;
 827   scalar_int_mode_pod m;
 828   /* RID_* is RID_INTN_BASE + index into this array */
 829 };
 830
 831 /* This is also in tree.h.  genmodes.c guarantees the're sorted from
 832    smallest bitsize to largest bitsize. */
 833 extern bool int_n_enabled_p[NUM_INT_N_ENTS];
 834 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS];
 835
 836 /* Return true if MODE has class MODE_INT, storing it as a scalar_int_mode
 837    in *INT_MODE if so.  */
 838
 839 template<typename T>
 840 inline bool
 841 is_int_mode (machine_mode mode, T *int_mode)
 842 {
 843   if (GET_MODE_CLASS (mode) == MODE_INT)
 844     {
 845       *int_mode = scalar_int_mode (scalar_int_mode::from_int (mode));
 846       return true;
 847     }
 848   return false;
 849 }
 850
 851 /* Return true if MODE has class MODE_FLOAT, storing it as a
 852    scalar_float_mode in *FLOAT_MODE if so.  */
 853
 854 template<typename T>
 855 inline bool
 856 is_float_mode (machine_mode mode, T *float_mode)
 857 {
 858   if (GET_MODE_CLASS (mode) == MODE_FLOAT)
 859     {
 860       *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode));
 861       return true;
 862     }
 863   return false;
 864 }
 865
 866 /* Return true if MODE has class MODE_COMPLEX_INT, storing it as
 867    a complex_mode in *CMODE if so.  */
 868
 869 template<typename T>
 870 inline bool
 871 is_complex_int_mode (machine_mode mode, T *cmode)
 872 {
 873   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
 874     {
 875       *cmode = complex_mode (complex_mode::from_int (mode));
 876       return true;
 877     }
 878   return false;
 879 }
 880
 881 /* Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as
 882    a complex_mode in *CMODE if so.  */
 883
 884 template<typename T>
 885 inline bool
 886 is_complex_float_mode (machine_mode mode, T *cmode)
 887 {
 888   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
 889     {
 890       *cmode = complex_mode (complex_mode::from_int (mode));
 891       return true;
 892     }
 893   return false;
 894 }
 895
 896 /* Return true if MODE is a scalar integer mode with a precision
 897    smaller than LIMIT's precision.  */
 898
 899 inline bool
 900 is_narrower_int_mode (machine_mode mode, scalar_int_mode limit)
 901 {
 902   scalar_int_mode int_mode;
 903   return (is_a <scalar_int_mode> (mode, &int_mode)
 904           && GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit));
 905 }
 906
 907 namespace mode_iterator
 908 {
 909   /* Start mode iterator *ITER at the first mode in class MCLASS, if any.  */
 910
 911   template<typename T>
 912   inline void
 913   start (opt_mode<T> *iter, enum mode_class mclass)
 914   {
 915     if (GET_CLASS_NARROWEST_MODE (mclass) == E_VOIDmode)
 916       *iter = opt_mode<T> ();
 917     else
 918       *iter = as_a<T> (GET_CLASS_NARROWEST_MODE (mclass));
 919   }
 920
 921   inline void
 922   start (machine_mode *iter, enum mode_class mclass)
 923   {
 924     *iter = GET_CLASS_NARROWEST_MODE (mclass);
 925   }
 926
 927   /* Return true if mode iterator *ITER has not reached the end.  */
 928
 929   template<typename T>
 930   inline bool
 931   iterate_p (opt_mode<T> *iter)
 932   {
 933     return iter->exists ();
 934   }
 935
 936   inline bool
 937   iterate_p (machine_mode *iter)
 938   {
 939     return *iter != E_VOIDmode;
 940   }
 941
 942   /* Set mode iterator *ITER to the next widest mode in the same class,
 943      if any.  */
 944
 945   template<typename T>
 946   inline void
 947   get_wider (opt_mode<T> *iter)
 948   {
 949     *iter = GET_MODE_WIDER_MODE (iter->require ());
 950   }
 951
 952   inline void
 953   get_wider (machine_mode *iter)
 954   {
 955     *iter = GET_MODE_WIDER_MODE (*iter).else_void ();
 956   }
 957
 958   /* Set mode iterator *ITER to the next widest mode in the same class.
 959      Such a mode is known to exist.  */
 960
 961   template<typename T>
 962   inline void
 963   get_known_wider (T *iter)
 964   {
 965     *iter = GET_MODE_WIDER_MODE (*iter).require ();
 966   }
 967
 968   /* Set mode iterator *ITER to the mode that is two times wider than the
 969      current one, if such a mode exists.  */
 970
 971   template<typename T>
 972   inline void
 973   get_2xwider (opt_mode<T> *iter)
 974   {
 975     *iter = GET_MODE_2XWIDER_MODE (iter->require ());
 976   }
 977
 978   inline void
 979   get_2xwider (machine_mode *iter)
 980   {
 981     *iter = GET_MODE_2XWIDER_MODE (*iter).else_void ();
 982   }
 983 }
 984
 985 /* Make ITERATOR iterate over all the modes in mode class CLASS,
 986    from narrowest to widest.  */
 987 #define FOR_EACH_MODE_IN_CLASS(ITERATOR, CLASS)  \
 988   for (mode_iterator::start (&(ITERATOR), CLASS); \
 989        mode_iterator::iterate_p (&(ITERATOR)); \
 990        mode_iterator::get_wider (&(ITERATOR)))
 991
 992 /* Make ITERATOR iterate over all the modes in the range [START, END),
 993    in order of increasing width.  */
 994 #define FOR_EACH_MODE(ITERATOR, START, END) \
 995   for ((ITERATOR) = (START); \
 996        (ITERATOR) != (END); \
 997        mode_iterator::get_known_wider (&(ITERATOR)))
 998
 999 /* Make ITERATOR iterate over START and all wider modes in the same
1000    class, in order of increasing width.  */
1001 #define FOR_EACH_MODE_FROM(ITERATOR, START) \
1002   for ((ITERATOR) = (START); \
1003        mode_iterator::iterate_p (&(ITERATOR)); \
1004        mode_iterator::get_wider (&(ITERATOR)))
1005
1006 /* Make ITERATOR iterate over modes in the range [NARROWEST, END)
1007    in order of increasing width, where NARROWEST is the narrowest mode
1008    in END's class.  */
1009 #define FOR_EACH_MODE_UNTIL(ITERATOR, END) \
1010   FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END)
1011
1012 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1013    of increasing width.  Start at the first mode wider than START,
1014    or don't iterate at all if there is no wider mode.  */
1015 #define FOR_EACH_WIDER_MODE(ITERATOR, START) \
1016   for ((ITERATOR) = (START), mode_iterator::get_wider (&(ITERATOR)); \
1017        mode_iterator::iterate_p (&(ITERATOR)); \
1018        mode_iterator::get_wider (&(ITERATOR)))
1019
1020 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1021    of increasing width, and with each mode being twice the width of the
1022    previous mode.  Start at the mode that is two times wider than START,
1023    or don't iterate at all if there is no such mode.  */
1024 #define FOR_EACH_2XWIDER_MODE(ITERATOR, START) \
1025   for ((ITERATOR) = (START), mode_iterator::get_2xwider (&(ITERATOR)); \
1026        mode_iterator::iterate_p (&(ITERATOR)); \
1027        mode_iterator::get_2xwider (&(ITERATOR)))
1028
1029 template<typename T>
1030 void
1031 gt_ggc_mx (pod_mode<T> *)
1032 {
1033 }
1034
1035 template<typename T>
1036 void
1037 gt_pch_nx (pod_mode<T> *)
1038 {
1039 }
1040
1041 template<typename T>
1042 void
1043 gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *)
1044 {
1045 }
1046
1047 #endif /* not HAVE_MACHINE_MODES */