2018-10-23 Richard Biener <rguenther@suse.de>
[official-gcc.git] / gcc / machmode.h
blob239a9098f53a0f0c1221e40279b40c129615680b
1 /* Machine mode definitions for GCC; included by rtl.h and tree.h.
2 Copyright (C) 1991-2018 Free Software Foundation, Inc.
4 This file is part of GCC.
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.
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.
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/>. */
20 #ifndef HAVE_MACHINE_MODES
21 #define HAVE_MACHINE_MODES
23 typedef opt_mode<machine_mode> opt_machine_mode;
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];
34 template<typename T>
35 struct mode_traits
37 /* For use by the machmode support code only.
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:
44 return typename mode_traits<T>::from_int (mode);
46 when returning a T and:
48 res = T (typename mode_traits<T>::from_int (mode));
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.
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
72 template<>
73 struct mode_traits<machine_mode>
75 /* machine_mode itself needs no conversion. */
76 typedef machine_mode from_int;
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
87 /* Get the name of mode MODE as a string. */
89 extern const char * const mode_name[NUM_MACHINE_MODES];
90 #define GET_MODE_NAME(MODE) mode_name[MODE]
92 /* Mode classes. */
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
100 /* Get the general kind of object that mode MODE represents
101 (integer, floating, complex, etc.) */
103 extern const unsigned char mode_class[NUM_MACHINE_MODES];
104 #define GET_MODE_CLASS(MODE) ((enum mode_class) mode_class[MODE])
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)
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)
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)
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)
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)
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)
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)
150 /* Nonzero if MODE is a scalar fract mode. */
151 #define SCALAR_FRACT_MODE_P(MODE) \
152 (GET_MODE_CLASS (MODE) == MODE_FRACT)
154 /* Nonzero if MODE is a scalar ufract mode. */
155 #define SCALAR_UFRACT_MODE_P(MODE) \
156 (GET_MODE_CLASS (MODE) == MODE_UFRACT)
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))
162 /* Nonzero if MODE is a scalar accum mode. */
163 #define SCALAR_ACCUM_MODE_P(MODE) \
164 (GET_MODE_CLASS (MODE) == MODE_ACCUM)
166 /* Nonzero if MODE is a scalar uaccum mode. */
167 #define SCALAR_UACCUM_MODE_P(MODE) \
168 (GET_MODE_CLASS (MODE) == MODE_UACCUM)
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))
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))
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))
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))
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)
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)
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))
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)
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)
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))
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))
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))
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))
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)
240 /* An optional T (i.e. a T or nothing), where T is some form of mode class. */
241 template<typename T>
242 class opt_mode
244 public:
245 enum from_int { dummy = MAX_MACHINE_MODE };
247 ALWAYS_INLINE opt_mode () : m_mode (E_VOIDmode) {}
248 ALWAYS_INLINE opt_mode (const T &m) : m_mode (m) {}
249 template<typename U>
250 ALWAYS_INLINE opt_mode (const U &m) : m_mode (T (m)) {}
251 ALWAYS_INLINE opt_mode (from_int m) : m_mode (machine_mode (m)) {}
253 machine_mode else_void () const;
254 machine_mode else_blk () const;
255 T require () const;
257 bool exists () const;
258 template<typename U> bool exists (U *) const;
260 private:
261 machine_mode m_mode;
264 /* If the object contains a T, return its enum value, otherwise return
265 E_VOIDmode. */
267 template<typename T>
268 ALWAYS_INLINE machine_mode
269 opt_mode<T>::else_void () const
271 return m_mode;
274 /* If the T exists, return its enum value, otherwise return E_BLKmode. */
276 template<typename T>
277 inline machine_mode
278 opt_mode<T>::else_blk () const
280 return m_mode == E_VOIDmode ? E_BLKmode : m_mode;
283 /* Assert that the object contains a T and return it. */
285 template<typename T>
286 inline T
287 opt_mode<T>::require () const
289 gcc_checking_assert (m_mode != E_VOIDmode);
290 return typename mode_traits<T>::from_int (m_mode);
293 /* Return true if the object contains a T rather than nothing. */
295 template<typename T>
296 ALWAYS_INLINE bool
297 opt_mode<T>::exists () const
299 return m_mode != E_VOIDmode;
302 /* Return true if the object contains a T, storing it in *MODE if so. */
304 template<typename T>
305 template<typename U>
306 inline bool
307 opt_mode<T>::exists (U *mode) const
309 if (m_mode != E_VOIDmode)
311 *mode = T (typename mode_traits<T>::from_int (m_mode));
312 return true;
314 return false;
317 /* A POD version of mode class T. */
319 template<typename T>
320 struct pod_mode
322 typedef typename mode_traits<T>::from_int from_int;
323 typedef typename T::measurement_type measurement_type;
325 machine_mode m_mode;
326 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
327 ALWAYS_INLINE operator T () const { return from_int (m_mode); }
328 ALWAYS_INLINE pod_mode &operator = (const T &m) { m_mode = m; return *this; }
331 /* Return true if mode M has type T. */
333 template<typename T>
334 inline bool
335 is_a (machine_mode m)
337 return T::includes_p (m);
340 template<typename T, typename U>
341 inline bool
342 is_a (const opt_mode<U> &m)
344 return T::includes_p (m.else_void ());
347 /* Assert that mode M has type T, and return it in that form. */
349 template<typename T>
350 inline T
351 as_a (machine_mode m)
353 gcc_checking_assert (T::includes_p (m));
354 return typename mode_traits<T>::from_int (m);
357 template<typename T, typename U>
358 inline T
359 as_a (const opt_mode<U> &m)
361 return as_a <T> (m.else_void ());
364 /* Convert M to an opt_mode<T>. */
366 template<typename T>
367 inline opt_mode<T>
368 dyn_cast (machine_mode m)
370 if (T::includes_p (m))
371 return T (typename mode_traits<T>::from_int (m));
372 return opt_mode<T> ();
375 template<typename T, typename U>
376 inline opt_mode<T>
377 dyn_cast (const opt_mode<U> &m)
379 return dyn_cast <T> (m.else_void ());
382 /* Return true if mode M has type T, storing it as a T in *RESULT
383 if so. */
385 template<typename T, typename U>
386 inline bool
387 is_a (machine_mode m, U *result)
389 if (T::includes_p (m))
391 *result = T (typename mode_traits<T>::from_int (m));
392 return true;
394 return false;
397 /* Represents a machine mode that is known to be a SCALAR_INT_MODE_P. */
398 class scalar_int_mode
400 public:
401 typedef mode_traits<scalar_int_mode>::from_int from_int;
402 typedef unsigned short measurement_type;
404 ALWAYS_INLINE scalar_int_mode () {}
405 ALWAYS_INLINE scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {}
406 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
408 static bool includes_p (machine_mode);
410 protected:
411 machine_mode m_mode;
414 /* Return true if M is a scalar_int_mode. */
416 inline bool
417 scalar_int_mode::includes_p (machine_mode m)
419 return SCALAR_INT_MODE_P (m);
422 /* Represents a machine mode that is known to be a SCALAR_FLOAT_MODE_P. */
423 class scalar_float_mode
425 public:
426 typedef mode_traits<scalar_float_mode>::from_int from_int;
427 typedef unsigned short measurement_type;
429 ALWAYS_INLINE scalar_float_mode () {}
430 ALWAYS_INLINE scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {}
431 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
433 static bool includes_p (machine_mode);
435 protected:
436 machine_mode m_mode;
439 /* Return true if M is a scalar_float_mode. */
441 inline bool
442 scalar_float_mode::includes_p (machine_mode m)
444 return SCALAR_FLOAT_MODE_P (m);
447 /* Represents a machine mode that is known to be scalar. */
448 class scalar_mode
450 public:
451 typedef mode_traits<scalar_mode>::from_int from_int;
452 typedef unsigned short measurement_type;
454 ALWAYS_INLINE scalar_mode () {}
455 ALWAYS_INLINE scalar_mode (from_int m) : m_mode (machine_mode (m)) {}
456 ALWAYS_INLINE scalar_mode (const scalar_int_mode &m) : m_mode (m) {}
457 ALWAYS_INLINE scalar_mode (const scalar_float_mode &m) : m_mode (m) {}
458 ALWAYS_INLINE scalar_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
459 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
461 static bool includes_p (machine_mode);
463 protected:
464 machine_mode m_mode;
467 /* Return true if M represents some kind of scalar value. */
469 inline bool
470 scalar_mode::includes_p (machine_mode m)
472 switch (GET_MODE_CLASS (m))
474 case MODE_INT:
475 case MODE_PARTIAL_INT:
476 case MODE_FRACT:
477 case MODE_UFRACT:
478 case MODE_ACCUM:
479 case MODE_UACCUM:
480 case MODE_FLOAT:
481 case MODE_DECIMAL_FLOAT:
482 return true;
483 default:
484 return false;
488 /* Represents a machine mode that is known to be a COMPLEX_MODE_P. */
489 class complex_mode
491 public:
492 typedef mode_traits<complex_mode>::from_int from_int;
493 typedef unsigned short measurement_type;
495 ALWAYS_INLINE complex_mode () {}
496 ALWAYS_INLINE complex_mode (from_int m) : m_mode (machine_mode (m)) {}
497 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
499 static bool includes_p (machine_mode);
501 protected:
502 machine_mode m_mode;
505 /* Return true if M is a complex_mode. */
507 inline bool
508 complex_mode::includes_p (machine_mode m)
510 return COMPLEX_MODE_P (m);
513 /* Return the base GET_MODE_SIZE value for MODE. */
515 ALWAYS_INLINE poly_uint16
516 mode_to_bytes (machine_mode mode)
518 #if GCC_VERSION >= 4001
519 return (__builtin_constant_p (mode)
520 ? mode_size_inline (mode) : mode_size[mode]);
521 #else
522 return mode_size[mode];
523 #endif
526 /* Return the base GET_MODE_BITSIZE value for MODE. */
528 ALWAYS_INLINE poly_uint16
529 mode_to_bits (machine_mode mode)
531 return mode_to_bytes (mode) * BITS_PER_UNIT;
534 /* Return the base GET_MODE_PRECISION value for MODE. */
536 ALWAYS_INLINE poly_uint16
537 mode_to_precision (machine_mode mode)
539 return mode_precision[mode];
542 /* Return the base GET_MODE_INNER value for MODE. */
544 ALWAYS_INLINE scalar_mode
545 mode_to_inner (machine_mode mode)
547 #if GCC_VERSION >= 4001
548 return scalar_mode::from_int (__builtin_constant_p (mode)
549 ? mode_inner_inline (mode)
550 : mode_inner[mode]);
551 #else
552 return scalar_mode::from_int (mode_inner[mode]);
553 #endif
556 /* Return the base GET_MODE_UNIT_SIZE value for MODE. */
558 ALWAYS_INLINE unsigned char
559 mode_to_unit_size (machine_mode mode)
561 #if GCC_VERSION >= 4001
562 return (__builtin_constant_p (mode)
563 ? mode_unit_size_inline (mode) : mode_unit_size[mode]);
564 #else
565 return mode_unit_size[mode];
566 #endif
569 /* Return the base GET_MODE_UNIT_PRECISION value for MODE. */
571 ALWAYS_INLINE unsigned short
572 mode_to_unit_precision (machine_mode mode)
574 #if GCC_VERSION >= 4001
575 return (__builtin_constant_p (mode)
576 ? mode_unit_precision_inline (mode) : mode_unit_precision[mode]);
577 #else
578 return mode_unit_precision[mode];
579 #endif
582 /* Return the base GET_MODE_NUNITS value for MODE. */
584 ALWAYS_INLINE poly_uint16
585 mode_to_nunits (machine_mode mode)
587 #if GCC_VERSION >= 4001
588 return (__builtin_constant_p (mode)
589 ? mode_nunits_inline (mode) : mode_nunits[mode]);
590 #else
591 return mode_nunits[mode];
592 #endif
595 /* Get the size in bytes of an object of mode MODE. */
597 #if ONLY_FIXED_SIZE_MODES
598 #define GET_MODE_SIZE(MODE) ((unsigned short) mode_to_bytes (MODE).coeffs[0])
599 #else
600 ALWAYS_INLINE poly_uint16
601 GET_MODE_SIZE (machine_mode mode)
603 return mode_to_bytes (mode);
606 template<typename T>
607 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
608 GET_MODE_SIZE (const T &mode)
610 return mode_to_bytes (mode);
613 template<typename T>
614 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
615 GET_MODE_SIZE (const T &mode)
617 return mode_to_bytes (mode).coeffs[0];
619 #endif
621 /* Get the size in bits of an object of mode MODE. */
623 #if ONLY_FIXED_SIZE_MODES
624 #define GET_MODE_BITSIZE(MODE) ((unsigned short) mode_to_bits (MODE).coeffs[0])
625 #else
626 ALWAYS_INLINE poly_uint16
627 GET_MODE_BITSIZE (machine_mode mode)
629 return mode_to_bits (mode);
632 template<typename T>
633 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
634 GET_MODE_BITSIZE (const T &mode)
636 return mode_to_bits (mode);
639 template<typename T>
640 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
641 GET_MODE_BITSIZE (const T &mode)
643 return mode_to_bits (mode).coeffs[0];
645 #endif
647 /* Get the number of value bits of an object of mode MODE. */
649 #if ONLY_FIXED_SIZE_MODES
650 #define GET_MODE_PRECISION(MODE) \
651 ((unsigned short) mode_to_precision (MODE).coeffs[0])
652 #else
653 ALWAYS_INLINE poly_uint16
654 GET_MODE_PRECISION (machine_mode mode)
656 return mode_to_precision (mode);
659 template<typename T>
660 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
661 GET_MODE_PRECISION (const T &mode)
663 return mode_to_precision (mode);
666 template<typename T>
667 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
668 GET_MODE_PRECISION (const T &mode)
670 return mode_to_precision (mode).coeffs[0];
672 #endif
674 /* Get the number of integral bits of an object of mode MODE. */
675 extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES];
676 #define GET_MODE_IBIT(MODE) mode_ibit[MODE]
678 /* Get the number of fractional bits of an object of mode MODE. */
679 extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES];
680 #define GET_MODE_FBIT(MODE) mode_fbit[MODE]
682 /* Get a bitmask containing 1 for all bits in a word
683 that fit within mode MODE. */
685 extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES];
687 #define GET_MODE_MASK(MODE) mode_mask_array[MODE]
689 /* Return the mode of the basic parts of MODE. For vector modes this is the
690 mode of the vector elements. For complex modes it is the mode of the real
691 and imaginary parts. For other modes it is MODE itself. */
693 #define GET_MODE_INNER(MODE) (mode_to_inner (MODE))
695 /* Get the size in bytes or bits of the basic parts of an
696 object of mode MODE. */
698 #define GET_MODE_UNIT_SIZE(MODE) mode_to_unit_size (MODE)
700 #define GET_MODE_UNIT_BITSIZE(MODE) \
701 ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))
703 #define GET_MODE_UNIT_PRECISION(MODE) (mode_to_unit_precision (MODE))
705 /* Get the number of units in an object of mode MODE. This is 2 for
706 complex modes and the number of elements for vector modes. */
708 #if ONLY_FIXED_SIZE_MODES
709 #define GET_MODE_NUNITS(MODE) (mode_to_nunits (MODE).coeffs[0])
710 #else
711 ALWAYS_INLINE poly_uint16
712 GET_MODE_NUNITS (machine_mode mode)
714 return mode_to_nunits (mode);
717 template<typename T>
718 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
719 GET_MODE_NUNITS (const T &mode)
721 return mode_to_nunits (mode);
724 template<typename T>
725 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
726 GET_MODE_NUNITS (const T &mode)
728 return mode_to_nunits (mode).coeffs[0];
730 #endif
732 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI). */
734 template<typename T>
735 ALWAYS_INLINE opt_mode<T>
736 GET_MODE_WIDER_MODE (const T &m)
738 return typename opt_mode<T>::from_int (mode_wider[m]);
741 /* For scalars, this is a mode with twice the precision. For vectors,
742 this is a mode with the same inner mode but with twice the elements. */
744 template<typename T>
745 ALWAYS_INLINE opt_mode<T>
746 GET_MODE_2XWIDER_MODE (const T &m)
748 return typename opt_mode<T>::from_int (mode_2xwider[m]);
751 /* Get the complex mode from the component mode. */
752 extern const unsigned char mode_complex[NUM_MACHINE_MODES];
753 #define GET_MODE_COMPLEX_MODE(MODE) ((machine_mode) mode_complex[MODE])
755 /* Represents a machine mode that must have a fixed size. The main
756 use of this class is to represent the modes of objects that always
757 have static storage duration, such as constant pool entries.
758 (No current target supports the concept of variable-size static data.) */
759 class fixed_size_mode
761 public:
762 typedef mode_traits<fixed_size_mode>::from_int from_int;
763 typedef unsigned short measurement_type;
765 ALWAYS_INLINE fixed_size_mode () {}
766 ALWAYS_INLINE fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {}
767 ALWAYS_INLINE fixed_size_mode (const scalar_mode &m) : m_mode (m) {}
768 ALWAYS_INLINE fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {}
769 ALWAYS_INLINE fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {}
770 ALWAYS_INLINE fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {}
771 ALWAYS_INLINE fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
772 ALWAYS_INLINE fixed_size_mode (const complex_mode &m) : m_mode (m) {}
773 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
775 static bool includes_p (machine_mode);
777 protected:
778 machine_mode m_mode;
781 /* Return true if MODE has a fixed size. */
783 inline bool
784 fixed_size_mode::includes_p (machine_mode mode)
786 return mode_to_bytes (mode).is_constant ();
789 /* Wrapper for mode arguments to target macros, so that if a target
790 doesn't need polynomial-sized modes, its header file can continue
791 to treat everything as fixed_size_mode. This should go away once
792 macros are moved to target hooks. It shouldn't be used in other
793 contexts. */
794 #if NUM_POLY_INT_COEFFS == 1
795 #define MACRO_MODE(MODE) (as_a <fixed_size_mode> (MODE))
796 #else
797 #define MACRO_MODE(MODE) (MODE)
798 #endif
800 extern opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int);
802 /* Return the machine mode to use for a MODE_INT of SIZE bits, if one
803 exists. If LIMIT is nonzero, modes wider than MAX_FIXED_MODE_SIZE
804 will not be used. */
806 inline opt_scalar_int_mode
807 int_mode_for_size (poly_uint64 size, int limit)
809 return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit));
812 /* Return the machine mode to use for a MODE_FLOAT of SIZE bits, if one
813 exists. */
815 inline opt_scalar_float_mode
816 float_mode_for_size (poly_uint64 size)
818 return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0));
821 /* Likewise for MODE_DECIMAL_FLOAT. */
823 inline opt_scalar_float_mode
824 decimal_float_mode_for_size (unsigned int size)
826 return dyn_cast <scalar_float_mode>
827 (mode_for_size (size, MODE_DECIMAL_FLOAT, 0));
830 extern machine_mode smallest_mode_for_size (poly_uint64, enum mode_class);
832 /* Find the narrowest integer mode that contains at least SIZE bits.
833 Such a mode must exist. */
835 inline scalar_int_mode
836 smallest_int_mode_for_size (poly_uint64 size)
838 return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT));
841 extern opt_scalar_int_mode int_mode_for_mode (machine_mode);
842 extern opt_machine_mode bitwise_mode_for_mode (machine_mode);
843 extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64);
844 extern opt_machine_mode mode_for_int_vector (unsigned int, poly_uint64);
846 /* Return the integer vector equivalent of MODE, if one exists. In other
847 words, return the mode for an integer vector that has the same number
848 of bits as MODE and the same number of elements as MODE, with the
849 latter being 1 if MODE is scalar. The returned mode can be either
850 an integer mode or a vector mode. */
852 inline opt_machine_mode
853 mode_for_int_vector (machine_mode mode)
855 return mode_for_int_vector (GET_MODE_UNIT_BITSIZE (mode),
856 GET_MODE_NUNITS (mode));
859 /* A class for iterating through possible bitfield modes. */
860 class bit_field_mode_iterator
862 public:
863 bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT,
864 poly_int64, poly_int64,
865 unsigned int, bool);
866 bool next_mode (scalar_int_mode *);
867 bool prefer_smaller_modes ();
869 private:
870 opt_scalar_int_mode m_mode;
871 /* We use signed values here because the bit position can be negative
872 for invalid input such as gcc.dg/pr48335-8.c. */
873 HOST_WIDE_INT m_bitsize;
874 HOST_WIDE_INT m_bitpos;
875 poly_int64 m_bitregion_start;
876 poly_int64 m_bitregion_end;
877 unsigned int m_align;
878 bool m_volatilep;
879 int m_count;
882 /* Find the best mode to use to access a bit field. */
884 extern bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int,
885 unsigned HOST_WIDE_INT, bool, scalar_int_mode *);
887 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT. */
889 extern CONST_MODE_BASE_ALIGN unsigned short mode_base_align[NUM_MACHINE_MODES];
891 extern unsigned get_mode_alignment (machine_mode);
893 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
895 /* For each class, get the narrowest mode in that class. */
897 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
898 #define GET_CLASS_NARROWEST_MODE(CLASS) \
899 ((machine_mode) class_narrowest_mode[CLASS])
901 /* The narrowest full integer mode available on the target. */
903 #define NARROWEST_INT_MODE \
904 (scalar_int_mode \
905 (scalar_int_mode::from_int (class_narrowest_mode[MODE_INT])))
907 /* Return the narrowest mode in T's class. */
909 template<typename T>
910 inline T
911 get_narrowest_mode (T mode)
913 return typename mode_traits<T>::from_int
914 (class_narrowest_mode[GET_MODE_CLASS (mode)]);
917 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
918 and the mode whose class is Pmode and whose size is POINTER_SIZE. */
920 extern scalar_int_mode byte_mode;
921 extern scalar_int_mode word_mode;
922 extern scalar_int_mode ptr_mode;
924 /* Target-dependent machine mode initialization - in insn-modes.c. */
925 extern void init_adjust_machine_modes (void);
927 #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \
928 (targetm.truly_noop_truncation (GET_MODE_PRECISION (MODE1), \
929 GET_MODE_PRECISION (MODE2)))
931 /* Return true if MODE is a scalar integer mode that fits in a
932 HOST_WIDE_INT. */
934 inline bool
935 HWI_COMPUTABLE_MODE_P (machine_mode mode)
937 machine_mode mme = mode;
938 return (SCALAR_INT_MODE_P (mme)
939 && mode_to_precision (mme).coeffs[0] <= HOST_BITS_PER_WIDE_INT);
942 inline bool
943 HWI_COMPUTABLE_MODE_P (scalar_int_mode mode)
945 return GET_MODE_PRECISION (mode) <= HOST_BITS_PER_WIDE_INT;
948 struct int_n_data_t {
949 /* These parts are initailized by genmodes output */
950 unsigned int bitsize;
951 scalar_int_mode_pod m;
952 /* RID_* is RID_INTN_BASE + index into this array */
955 /* This is also in tree.h. genmodes.c guarantees the're sorted from
956 smallest bitsize to largest bitsize. */
957 extern bool int_n_enabled_p[NUM_INT_N_ENTS];
958 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS];
960 /* Return true if MODE has class MODE_INT, storing it as a scalar_int_mode
961 in *INT_MODE if so. */
963 template<typename T>
964 inline bool
965 is_int_mode (machine_mode mode, T *int_mode)
967 if (GET_MODE_CLASS (mode) == MODE_INT)
969 *int_mode = scalar_int_mode (scalar_int_mode::from_int (mode));
970 return true;
972 return false;
975 /* Return true if MODE has class MODE_FLOAT, storing it as a
976 scalar_float_mode in *FLOAT_MODE if so. */
978 template<typename T>
979 inline bool
980 is_float_mode (machine_mode mode, T *float_mode)
982 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
984 *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode));
985 return true;
987 return false;
990 /* Return true if MODE has class MODE_COMPLEX_INT, storing it as
991 a complex_mode in *CMODE if so. */
993 template<typename T>
994 inline bool
995 is_complex_int_mode (machine_mode mode, T *cmode)
997 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
999 *cmode = complex_mode (complex_mode::from_int (mode));
1000 return true;
1002 return false;
1005 /* Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as
1006 a complex_mode in *CMODE if so. */
1008 template<typename T>
1009 inline bool
1010 is_complex_float_mode (machine_mode mode, T *cmode)
1012 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
1014 *cmode = complex_mode (complex_mode::from_int (mode));
1015 return true;
1017 return false;
1020 /* Return true if MODE is a scalar integer mode with a precision
1021 smaller than LIMIT's precision. */
1023 inline bool
1024 is_narrower_int_mode (machine_mode mode, scalar_int_mode limit)
1026 scalar_int_mode int_mode;
1027 return (is_a <scalar_int_mode> (mode, &int_mode)
1028 && GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit));
1031 namespace mode_iterator
1033 /* Start mode iterator *ITER at the first mode in class MCLASS, if any. */
1035 template<typename T>
1036 inline void
1037 start (opt_mode<T> *iter, enum mode_class mclass)
1039 if (GET_CLASS_NARROWEST_MODE (mclass) == E_VOIDmode)
1040 *iter = opt_mode<T> ();
1041 else
1042 *iter = as_a<T> (GET_CLASS_NARROWEST_MODE (mclass));
1045 inline void
1046 start (machine_mode *iter, enum mode_class mclass)
1048 *iter = GET_CLASS_NARROWEST_MODE (mclass);
1051 /* Return true if mode iterator *ITER has not reached the end. */
1053 template<typename T>
1054 inline bool
1055 iterate_p (opt_mode<T> *iter)
1057 return iter->exists ();
1060 inline bool
1061 iterate_p (machine_mode *iter)
1063 return *iter != E_VOIDmode;
1066 /* Set mode iterator *ITER to the next widest mode in the same class,
1067 if any. */
1069 template<typename T>
1070 inline void
1071 get_wider (opt_mode<T> *iter)
1073 *iter = GET_MODE_WIDER_MODE (iter->require ());
1076 inline void
1077 get_wider (machine_mode *iter)
1079 *iter = GET_MODE_WIDER_MODE (*iter).else_void ();
1082 /* Set mode iterator *ITER to the next widest mode in the same class.
1083 Such a mode is known to exist. */
1085 template<typename T>
1086 inline void
1087 get_known_wider (T *iter)
1089 *iter = GET_MODE_WIDER_MODE (*iter).require ();
1092 /* Set mode iterator *ITER to the mode that is two times wider than the
1093 current one, if such a mode exists. */
1095 template<typename T>
1096 inline void
1097 get_2xwider (opt_mode<T> *iter)
1099 *iter = GET_MODE_2XWIDER_MODE (iter->require ());
1102 inline void
1103 get_2xwider (machine_mode *iter)
1105 *iter = GET_MODE_2XWIDER_MODE (*iter).else_void ();
1109 /* Make ITERATOR iterate over all the modes in mode class CLASS,
1110 from narrowest to widest. */
1111 #define FOR_EACH_MODE_IN_CLASS(ITERATOR, CLASS) \
1112 for (mode_iterator::start (&(ITERATOR), CLASS); \
1113 mode_iterator::iterate_p (&(ITERATOR)); \
1114 mode_iterator::get_wider (&(ITERATOR)))
1116 /* Make ITERATOR iterate over all the modes in the range [START, END),
1117 in order of increasing width. */
1118 #define FOR_EACH_MODE(ITERATOR, START, END) \
1119 for ((ITERATOR) = (START); \
1120 (ITERATOR) != (END); \
1121 mode_iterator::get_known_wider (&(ITERATOR)))
1123 /* Make ITERATOR iterate over START and all wider modes in the same
1124 class, in order of increasing width. */
1125 #define FOR_EACH_MODE_FROM(ITERATOR, START) \
1126 for ((ITERATOR) = (START); \
1127 mode_iterator::iterate_p (&(ITERATOR)); \
1128 mode_iterator::get_wider (&(ITERATOR)))
1130 /* Make ITERATOR iterate over modes in the range [NARROWEST, END)
1131 in order of increasing width, where NARROWEST is the narrowest mode
1132 in END's class. */
1133 #define FOR_EACH_MODE_UNTIL(ITERATOR, END) \
1134 FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END)
1136 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1137 of increasing width. Start at the first mode wider than START,
1138 or don't iterate at all if there is no wider mode. */
1139 #define FOR_EACH_WIDER_MODE(ITERATOR, START) \
1140 for ((ITERATOR) = (START), mode_iterator::get_wider (&(ITERATOR)); \
1141 mode_iterator::iterate_p (&(ITERATOR)); \
1142 mode_iterator::get_wider (&(ITERATOR)))
1144 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1145 of increasing width, and with each mode being twice the width of the
1146 previous mode. Start at the mode that is two times wider than START,
1147 or don't iterate at all if there is no such mode. */
1148 #define FOR_EACH_2XWIDER_MODE(ITERATOR, START) \
1149 for ((ITERATOR) = (START), mode_iterator::get_2xwider (&(ITERATOR)); \
1150 mode_iterator::iterate_p (&(ITERATOR)); \
1151 mode_iterator::get_2xwider (&(ITERATOR)))
1153 template<typename T>
1154 void
1155 gt_ggc_mx (pod_mode<T> *)
1159 template<typename T>
1160 void
1161 gt_pch_nx (pod_mode<T> *)
1165 template<typename T>
1166 void
1167 gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *)
1171 #endif /* not HAVE_MACHINE_MODES */