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 extern opt_machine_mode mode_for_size (unsigned int, enum mode_class, int);
 656
 657 /* Return the machine mode to use for a MODE_INT of SIZE bits, if one
 658    exists.  If LIMIT is nonzero, modes wider than MAX_FIXED_MODE_SIZE
 659    will not be used.  */
 660
 661 inline opt_scalar_int_mode
 662 int_mode_for_size (unsigned int size, int limit)
 663 {
 664   return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit));
 665 }
 666
 667 /* Return the machine mode to use for a MODE_FLOAT of SIZE bits, if one
 668    exists.  */
 669
 670 inline opt_scalar_float_mode
 671 float_mode_for_size (unsigned int size)
 672 {
 673   return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0));
 674 }
 675
 676 /* Likewise for MODE_DECIMAL_FLOAT.  */
 677
 678 inline opt_scalar_float_mode
 679 decimal_float_mode_for_size (unsigned int size)
 680 {
 681   return dyn_cast <scalar_float_mode>
 682     (mode_for_size (size, MODE_DECIMAL_FLOAT, 0));
 683 }
 684
 685 /* Similar to mode_for_size, but find the smallest mode for a given width.  */
 686
 687 extern machine_mode smallest_mode_for_size (unsigned int, enum mode_class);
 688
 689 /* Find the narrowest integer mode that contains at least SIZE bits.
 690    Such a mode must exist.  */
 691
 692 inline scalar_int_mode
 693 smallest_int_mode_for_size (unsigned int size)
 694 {
 695   return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT));
 696 }
 697
 698 /* Return an integer mode of exactly the same size as the input mode.  */
 699
 700 extern opt_scalar_int_mode int_mode_for_mode (machine_mode);
 701
 702 extern machine_mode bitwise_mode_for_mode (machine_mode);
 703
 704 /* Return a mode that is suitable for representing a vector,
 705    or BLKmode on failure.  */
 706
 707 extern machine_mode mode_for_vector (scalar_mode, unsigned);
 708
 709 extern opt_machine_mode mode_for_int_vector (unsigned int, unsigned int);
 710
 711 /* Return the integer vector equivalent of MODE, if one exists.  In other
 712    words, return the mode for an integer vector that has the same number
 713    of bits as MODE and the same number of elements as MODE, with the
 714    latter being 1 if MODE is scalar.  The returned mode can be either
 715    an integer mode or a vector mode.  */
 716
 717 inline opt_machine_mode
 718 mode_for_int_vector (machine_mode mode)
 719 {
 720   return mode_for_int_vector (GET_MODE_UNIT_BITSIZE (mode),
 721                               GET_MODE_NUNITS (mode));
 722 }
 723
 724 /* A class for iterating through possible bitfield modes.  */
 725 class bit_field_mode_iterator
 726 {
 727 public:
 728   bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT,
 729                            HOST_WIDE_INT, HOST_WIDE_INT,
 730                            unsigned int, bool);
 731   bool next_mode (scalar_int_mode *);
 732   bool prefer_smaller_modes ();
 733
 734 private:
 735   opt_scalar_int_mode m_mode;
 736   /* We use signed values here because the bit position can be negative
 737      for invalid input such as gcc.dg/pr48335-8.c.  */
 738   HOST_WIDE_INT m_bitsize;
 739   HOST_WIDE_INT m_bitpos;
 740   HOST_WIDE_INT m_bitregion_start;
 741   HOST_WIDE_INT m_bitregion_end;
 742   unsigned int m_align;
 743   bool m_volatilep;
 744   int m_count;
 745 };
 746
 747 /* Find the best mode to use to access a bit field.  */
 748
 749 extern bool get_best_mode (int, int, unsigned HOST_WIDE_INT,
 750                            unsigned HOST_WIDE_INT, unsigned int,
 751                            unsigned HOST_WIDE_INT, bool, scalar_int_mode *);
 752
 753 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.  */
 754
 755 extern CONST_MODE_BASE_ALIGN unsigned short mode_base_align[NUM_MACHINE_MODES];
 756
 757 extern unsigned get_mode_alignment (machine_mode);
 758
 759 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
 760
 761 /* For each class, get the narrowest mode in that class.  */
 762
 763 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
 764 #define GET_CLASS_NARROWEST_MODE(CLASS) \
 765   ((machine_mode) class_narrowest_mode[CLASS])
 766
 767 /* The narrowest full integer mode available on the target.  */
 768
 769 #define NARROWEST_INT_MODE \
 770   (scalar_int_mode \
 771    (scalar_int_mode::from_int (class_narrowest_mode[MODE_INT])))
 772
 773 /* Return the narrowest mode in T's class.  */
 774
 775 template<typename T>
 776 inline T
 777 get_narrowest_mode (T mode)
 778 {
 779   return typename mode_traits<T>::from_int
 780     (class_narrowest_mode[GET_MODE_CLASS (mode)]);
 781 }
 782
 783 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
 784    and the mode whose class is Pmode and whose size is POINTER_SIZE.  */
 785
 786 extern scalar_int_mode byte_mode;
 787 extern scalar_int_mode word_mode;
 788 extern scalar_int_mode ptr_mode;
 789
 790 /* Target-dependent machine mode initialization - in insn-modes.c.  */
 791 extern void init_adjust_machine_modes (void);
 792
 793 #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \
 794   TRULY_NOOP_TRUNCATION (GET_MODE_PRECISION (MODE1), \
 795                          GET_MODE_PRECISION (MODE2))
 796
 797 #define HWI_COMPUTABLE_MODE_P(MODE) \
 798   (SCALAR_INT_MODE_P (MODE) \
 799    && GET_MODE_PRECISION (MODE) <= HOST_BITS_PER_WIDE_INT)
 800
 801 struct int_n_data_t {
 802   /* These parts are initailized by genmodes output */
 803   unsigned int bitsize;
 804   scalar_int_mode_pod m;
 805   /* RID_* is RID_INTN_BASE + index into this array */
 806 };
 807
 808 /* This is also in tree.h.  genmodes.c guarantees the're sorted from
 809    smallest bitsize to largest bitsize. */
 810 extern bool int_n_enabled_p[NUM_INT_N_ENTS];
 811 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS];
 812
 813 /* Return true if MODE has class MODE_INT, storing it as a scalar_int_mode
 814    in *INT_MODE if so.  */
 815
 816 template<typename T>
 817 inline bool
 818 is_int_mode (machine_mode mode, T *int_mode)
 819 {
 820   if (GET_MODE_CLASS (mode) == MODE_INT)
 821     {
 822       *int_mode = scalar_int_mode (scalar_int_mode::from_int (mode));
 823       return true;
 824     }
 825   return false;
 826 }
 827
 828 /* Return true if MODE has class MODE_FLOAT, storing it as a
 829    scalar_float_mode in *FLOAT_MODE if so.  */
 830
 831 template<typename T>
 832 inline bool
 833 is_float_mode (machine_mode mode, T *float_mode)
 834 {
 835   if (GET_MODE_CLASS (mode) == MODE_FLOAT)
 836     {
 837       *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode));
 838       return true;
 839     }
 840   return false;
 841 }
 842
 843 /* Return true if MODE has class MODE_COMPLEX_INT, storing it as
 844    a complex_mode in *CMODE if so.  */
 845
 846 template<typename T>
 847 inline bool
 848 is_complex_int_mode (machine_mode mode, T *cmode)
 849 {
 850   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
 851     {
 852       *cmode = complex_mode (complex_mode::from_int (mode));
 853       return true;
 854     }
 855   return false;
 856 }
 857
 858 /* Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as
 859    a complex_mode in *CMODE if so.  */
 860
 861 template<typename T>
 862 inline bool
 863 is_complex_float_mode (machine_mode mode, T *cmode)
 864 {
 865   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
 866     {
 867       *cmode = complex_mode (complex_mode::from_int (mode));
 868       return true;
 869     }
 870   return false;
 871 }
 872
 873 namespace mode_iterator
 874 {
 875   /* Start mode iterator *ITER at the first mode in class MCLASS, if any.  */
 876
 877   template<typename T>
 878   inline void
 879   start (opt_mode<T> *iter, enum mode_class mclass)
 880   {
 881     if (GET_CLASS_NARROWEST_MODE (mclass) == E_VOIDmode)
 882       *iter = opt_mode<T> ();
 883     else
 884       *iter = as_a<T> (GET_CLASS_NARROWEST_MODE (mclass));
 885   }
 886
 887   inline void
 888   start (machine_mode *iter, enum mode_class mclass)
 889   {
 890     *iter = GET_CLASS_NARROWEST_MODE (mclass);
 891   }
 892
 893   /* Return true if mode iterator *ITER has not reached the end.  */
 894
 895   template<typename T>
 896   inline bool
 897   iterate_p (opt_mode<T> *iter)
 898   {
 899     return iter->exists ();
 900   }
 901
 902   inline bool
 903   iterate_p (machine_mode *iter)
 904   {
 905     return *iter != E_VOIDmode;
 906   }
 907
 908   /* Set mode iterator *ITER to the next widest mode in the same class,
 909      if any.  */
 910
 911   template<typename T>
 912   inline void
 913   get_wider (opt_mode<T> *iter)
 914   {
 915     *iter = GET_MODE_WIDER_MODE (iter->require ());
 916   }
 917
 918   inline void
 919   get_wider (machine_mode *iter)
 920   {
 921     *iter = GET_MODE_WIDER_MODE (*iter).else_void ();
 922   }
 923
 924   /* Set mode iterator *ITER to the next widest mode in the same class.
 925      Such a mode is known to exist.  */
 926
 927   template<typename T>
 928   inline void
 929   get_known_wider (T *iter)
 930   {
 931     *iter = GET_MODE_WIDER_MODE (*iter).require ();
 932   }
 933
 934   /* Set mode iterator *ITER to the mode that is two times wider than the
 935      current one, if such a mode exists.  */
 936
 937   template<typename T>
 938   inline void
 939   get_2xwider (opt_mode<T> *iter)
 940   {
 941     *iter = GET_MODE_2XWIDER_MODE (iter->require ());
 942   }
 943
 944   inline void
 945   get_2xwider (machine_mode *iter)
 946   {
 947     *iter = GET_MODE_2XWIDER_MODE (*iter).else_void ();
 948   }
 949 }
 950
 951 /* Make ITERATOR iterate over all the modes in mode class CLASS,
 952    from narrowest to widest.  */
 953 #define FOR_EACH_MODE_IN_CLASS(ITERATOR, CLASS)  \
 954   for (mode_iterator::start (&(ITERATOR), CLASS); \
 955        mode_iterator::iterate_p (&(ITERATOR)); \
 956        mode_iterator::get_wider (&(ITERATOR)))
 957
 958 /* Make ITERATOR iterate over all the modes in the range [START, END),
 959    in order of increasing width.  */
 960 #define FOR_EACH_MODE(ITERATOR, START, END) \
 961   for ((ITERATOR) = (START); \
 962        (ITERATOR) != (END); \
 963        mode_iterator::get_known_wider (&(ITERATOR)))
 964
 965 /* Make ITERATOR iterate over START and all wider modes in the same
 966    class, in order of increasing width.  */
 967 #define FOR_EACH_MODE_FROM(ITERATOR, START) \
 968   for ((ITERATOR) = (START); \
 969        mode_iterator::iterate_p (&(ITERATOR)); \
 970        mode_iterator::get_wider (&(ITERATOR)))
 971
 972 /* Make ITERATOR iterate over modes in the range [NARROWEST, END)
 973    in order of increasing width, where NARROWEST is the narrowest mode
 974    in END's class.  */
 975 #define FOR_EACH_MODE_UNTIL(ITERATOR, END) \
 976   FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END)
 977
 978 /* Make ITERATOR iterate over modes in the same class as MODE, in order
 979    of increasing width.  Start at the first mode wider than START,
 980    or don't iterate at all if there is no wider mode.  */
 981 #define FOR_EACH_WIDER_MODE(ITERATOR, START) \
 982   for ((ITERATOR) = (START), mode_iterator::get_wider (&(ITERATOR)); \
 983        mode_iterator::iterate_p (&(ITERATOR)); \
 984        mode_iterator::get_wider (&(ITERATOR)))
 985
 986 /* Make ITERATOR iterate over modes in the same class as MODE, in order
 987    of increasing width, and with each mode being twice the width of the
 988    previous mode.  Start at the mode that is two times wider than START,
 989    or don't iterate at all if there is no such mode.  */
 990 #define FOR_EACH_2XWIDER_MODE(ITERATOR, START) \
 991   for ((ITERATOR) = (START), mode_iterator::get_2xwider (&(ITERATOR)); \
 992        mode_iterator::iterate_p (&(ITERATOR)); \
 993        mode_iterator::get_2xwider (&(ITERATOR)))
 994
 995 template<typename T>
 996 void
 997 gt_ggc_mx (pod_mode<T> *)
 998 {
 999 }
1000
1001 template<typename T>
1002 void
1003 gt_pch_nx (pod_mode<T> *)
1004 {
1005 }
1006
1007 template<typename T>
1008 void
1009 gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *)
1010 {
1011 }
1012
1013 #endif /* not HAVE_MACHINE_MODES */