[AArch64] Fix gcc.target/aarch64/subs_compare_[12].c
[official-gcc.git] / gcc / machmode.h
blobb938eeaa26bfa6fa9460cf710a95cdf94e87a3ee
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 #define POINTER_BOUNDS_MODE_P(MODE) \
241 (GET_MODE_CLASS (MODE) == MODE_POINTER_BOUNDS)
243 /* An optional T (i.e. a T or nothing), where T is some form of mode class. */
244 template<typename T>
245 class opt_mode
247 public:
248 enum from_int { dummy = MAX_MACHINE_MODE };
250 ALWAYS_INLINE opt_mode () : m_mode (E_VOIDmode) {}
251 ALWAYS_INLINE opt_mode (const T &m) : m_mode (m) {}
252 template<typename U>
253 ALWAYS_INLINE opt_mode (const U &m) : m_mode (T (m)) {}
254 ALWAYS_INLINE opt_mode (from_int m) : m_mode (machine_mode (m)) {}
256 machine_mode else_void () const;
257 machine_mode else_blk () const;
258 T require () const;
260 bool exists () const;
261 template<typename U> bool exists (U *) const;
263 private:
264 machine_mode m_mode;
267 /* If the object contains a T, return its enum value, otherwise return
268 E_VOIDmode. */
270 template<typename T>
271 ALWAYS_INLINE machine_mode
272 opt_mode<T>::else_void () const
274 return m_mode;
277 /* If the T exists, return its enum value, otherwise return E_BLKmode. */
279 template<typename T>
280 inline machine_mode
281 opt_mode<T>::else_blk () const
283 return m_mode == E_VOIDmode ? E_BLKmode : m_mode;
286 /* Assert that the object contains a T and return it. */
288 template<typename T>
289 inline T
290 opt_mode<T>::require () const
292 gcc_checking_assert (m_mode != E_VOIDmode);
293 return typename mode_traits<T>::from_int (m_mode);
296 /* Return true if the object contains a T rather than nothing. */
298 template<typename T>
299 ALWAYS_INLINE bool
300 opt_mode<T>::exists () const
302 return m_mode != E_VOIDmode;
305 /* Return true if the object contains a T, storing it in *MODE if so. */
307 template<typename T>
308 template<typename U>
309 inline bool
310 opt_mode<T>::exists (U *mode) const
312 if (m_mode != E_VOIDmode)
314 *mode = T (typename mode_traits<T>::from_int (m_mode));
315 return true;
317 return false;
320 /* A POD version of mode class T. */
322 template<typename T>
323 struct pod_mode
325 typedef typename mode_traits<T>::from_int from_int;
326 typedef typename T::measurement_type measurement_type;
328 machine_mode m_mode;
329 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
330 ALWAYS_INLINE operator T () const { return from_int (m_mode); }
331 ALWAYS_INLINE pod_mode &operator = (const T &m) { m_mode = m; return *this; }
334 /* Return true if mode M has type T. */
336 template<typename T>
337 inline bool
338 is_a (machine_mode m)
340 return T::includes_p (m);
343 template<typename T, typename U>
344 inline bool
345 is_a (const opt_mode<U> &m)
347 return T::includes_p (m.else_void ());
350 /* Assert that mode M has type T, and return it in that form. */
352 template<typename T>
353 inline T
354 as_a (machine_mode m)
356 gcc_checking_assert (T::includes_p (m));
357 return typename mode_traits<T>::from_int (m);
360 template<typename T, typename U>
361 inline T
362 as_a (const opt_mode<U> &m)
364 return as_a <T> (m.else_void ());
367 /* Convert M to an opt_mode<T>. */
369 template<typename T>
370 inline opt_mode<T>
371 dyn_cast (machine_mode m)
373 if (T::includes_p (m))
374 return T (typename mode_traits<T>::from_int (m));
375 return opt_mode<T> ();
378 template<typename T, typename U>
379 inline opt_mode<T>
380 dyn_cast (const opt_mode<U> &m)
382 return dyn_cast <T> (m.else_void ());
385 /* Return true if mode M has type T, storing it as a T in *RESULT
386 if so. */
388 template<typename T, typename U>
389 inline bool
390 is_a (machine_mode m, U *result)
392 if (T::includes_p (m))
394 *result = T (typename mode_traits<T>::from_int (m));
395 return true;
397 return false;
400 /* Represents a machine mode that is known to be a SCALAR_INT_MODE_P. */
401 class scalar_int_mode
403 public:
404 typedef mode_traits<scalar_int_mode>::from_int from_int;
405 typedef unsigned short measurement_type;
407 ALWAYS_INLINE scalar_int_mode () {}
408 ALWAYS_INLINE scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {}
409 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
411 static bool includes_p (machine_mode);
413 protected:
414 machine_mode m_mode;
417 /* Return true if M is a scalar_int_mode. */
419 inline bool
420 scalar_int_mode::includes_p (machine_mode m)
422 return SCALAR_INT_MODE_P (m);
425 /* Represents a machine mode that is known to be a SCALAR_FLOAT_MODE_P. */
426 class scalar_float_mode
428 public:
429 typedef mode_traits<scalar_float_mode>::from_int from_int;
430 typedef unsigned short measurement_type;
432 ALWAYS_INLINE scalar_float_mode () {}
433 ALWAYS_INLINE scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {}
434 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
436 static bool includes_p (machine_mode);
438 protected:
439 machine_mode m_mode;
442 /* Return true if M is a scalar_float_mode. */
444 inline bool
445 scalar_float_mode::includes_p (machine_mode m)
447 return SCALAR_FLOAT_MODE_P (m);
450 /* Represents a machine mode that is known to be scalar. */
451 class scalar_mode
453 public:
454 typedef mode_traits<scalar_mode>::from_int from_int;
455 typedef unsigned short measurement_type;
457 ALWAYS_INLINE scalar_mode () {}
458 ALWAYS_INLINE scalar_mode (from_int m) : m_mode (machine_mode (m)) {}
459 ALWAYS_INLINE scalar_mode (const scalar_int_mode &m) : m_mode (m) {}
460 ALWAYS_INLINE scalar_mode (const scalar_float_mode &m) : m_mode (m) {}
461 ALWAYS_INLINE scalar_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
462 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
464 static bool includes_p (machine_mode);
466 protected:
467 machine_mode m_mode;
470 /* Return true if M represents some kind of scalar value. */
472 inline bool
473 scalar_mode::includes_p (machine_mode m)
475 switch (GET_MODE_CLASS (m))
477 case MODE_INT:
478 case MODE_PARTIAL_INT:
479 case MODE_FRACT:
480 case MODE_UFRACT:
481 case MODE_ACCUM:
482 case MODE_UACCUM:
483 case MODE_FLOAT:
484 case MODE_DECIMAL_FLOAT:
485 case MODE_POINTER_BOUNDS:
486 return true;
487 default:
488 return false;
492 /* Represents a machine mode that is known to be a COMPLEX_MODE_P. */
493 class complex_mode
495 public:
496 typedef mode_traits<complex_mode>::from_int from_int;
497 typedef unsigned short measurement_type;
499 ALWAYS_INLINE complex_mode () {}
500 ALWAYS_INLINE complex_mode (from_int m) : m_mode (machine_mode (m)) {}
501 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
503 static bool includes_p (machine_mode);
505 protected:
506 machine_mode m_mode;
509 /* Return true if M is a complex_mode. */
511 inline bool
512 complex_mode::includes_p (machine_mode m)
514 return COMPLEX_MODE_P (m);
517 /* Return the base GET_MODE_SIZE value for MODE. */
519 ALWAYS_INLINE poly_uint16
520 mode_to_bytes (machine_mode mode)
522 #if GCC_VERSION >= 4001
523 return (__builtin_constant_p (mode)
524 ? mode_size_inline (mode) : mode_size[mode]);
525 #else
526 return mode_size[mode];
527 #endif
530 /* Return the base GET_MODE_BITSIZE value for MODE. */
532 ALWAYS_INLINE poly_uint16
533 mode_to_bits (machine_mode mode)
535 return mode_to_bytes (mode) * BITS_PER_UNIT;
538 /* Return the base GET_MODE_PRECISION value for MODE. */
540 ALWAYS_INLINE poly_uint16
541 mode_to_precision (machine_mode mode)
543 return mode_precision[mode];
546 /* Return the base GET_MODE_INNER value for MODE. */
548 ALWAYS_INLINE scalar_mode
549 mode_to_inner (machine_mode mode)
551 #if GCC_VERSION >= 4001
552 return scalar_mode::from_int (__builtin_constant_p (mode)
553 ? mode_inner_inline (mode)
554 : mode_inner[mode]);
555 #else
556 return scalar_mode::from_int (mode_inner[mode]);
557 #endif
560 /* Return the base GET_MODE_UNIT_SIZE value for MODE. */
562 ALWAYS_INLINE unsigned char
563 mode_to_unit_size (machine_mode mode)
565 #if GCC_VERSION >= 4001
566 return (__builtin_constant_p (mode)
567 ? mode_unit_size_inline (mode) : mode_unit_size[mode]);
568 #else
569 return mode_unit_size[mode];
570 #endif
573 /* Return the base GET_MODE_UNIT_PRECISION value for MODE. */
575 ALWAYS_INLINE unsigned short
576 mode_to_unit_precision (machine_mode mode)
578 #if GCC_VERSION >= 4001
579 return (__builtin_constant_p (mode)
580 ? mode_unit_precision_inline (mode) : mode_unit_precision[mode]);
581 #else
582 return mode_unit_precision[mode];
583 #endif
586 /* Return the base GET_MODE_NUNITS value for MODE. */
588 ALWAYS_INLINE poly_uint16
589 mode_to_nunits (machine_mode mode)
591 #if GCC_VERSION >= 4001
592 return (__builtin_constant_p (mode)
593 ? mode_nunits_inline (mode) : mode_nunits[mode]);
594 #else
595 return mode_nunits[mode];
596 #endif
599 /* Get the size in bytes of an object of mode MODE. */
601 #if ONLY_FIXED_SIZE_MODES
602 #define GET_MODE_SIZE(MODE) ((unsigned short) mode_to_bytes (MODE).coeffs[0])
603 #else
604 ALWAYS_INLINE poly_uint16
605 GET_MODE_SIZE (machine_mode mode)
607 return mode_to_bytes (mode);
610 template<typename T>
611 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
612 GET_MODE_SIZE (const T &mode)
614 return mode_to_bytes (mode);
617 template<typename T>
618 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
619 GET_MODE_SIZE (const T &mode)
621 return mode_to_bytes (mode).coeffs[0];
623 #endif
625 /* Get the size in bits of an object of mode MODE. */
627 #if ONLY_FIXED_SIZE_MODES
628 #define GET_MODE_BITSIZE(MODE) ((unsigned short) mode_to_bits (MODE).coeffs[0])
629 #else
630 ALWAYS_INLINE poly_uint16
631 GET_MODE_BITSIZE (machine_mode mode)
633 return mode_to_bits (mode);
636 template<typename T>
637 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
638 GET_MODE_BITSIZE (const T &mode)
640 return mode_to_bits (mode);
643 template<typename T>
644 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
645 GET_MODE_BITSIZE (const T &mode)
647 return mode_to_bits (mode).coeffs[0];
649 #endif
651 /* Get the number of value bits of an object of mode MODE. */
653 #if ONLY_FIXED_SIZE_MODES
654 #define GET_MODE_PRECISION(MODE) \
655 ((unsigned short) mode_to_precision (MODE).coeffs[0])
656 #else
657 ALWAYS_INLINE poly_uint16
658 GET_MODE_PRECISION (machine_mode mode)
660 return mode_to_precision (mode);
663 template<typename T>
664 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
665 GET_MODE_PRECISION (const T &mode)
667 return mode_to_precision (mode);
670 template<typename T>
671 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
672 GET_MODE_PRECISION (const T &mode)
674 return mode_to_precision (mode).coeffs[0];
676 #endif
678 /* Get the number of integral bits of an object of mode MODE. */
679 extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES];
680 #define GET_MODE_IBIT(MODE) mode_ibit[MODE]
682 /* Get the number of fractional bits of an object of mode MODE. */
683 extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES];
684 #define GET_MODE_FBIT(MODE) mode_fbit[MODE]
686 /* Get a bitmask containing 1 for all bits in a word
687 that fit within mode MODE. */
689 extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES];
691 #define GET_MODE_MASK(MODE) mode_mask_array[MODE]
693 /* Return the mode of the basic parts of MODE. For vector modes this is the
694 mode of the vector elements. For complex modes it is the mode of the real
695 and imaginary parts. For other modes it is MODE itself. */
697 #define GET_MODE_INNER(MODE) (mode_to_inner (MODE))
699 /* Get the size in bytes or bits of the basic parts of an
700 object of mode MODE. */
702 #define GET_MODE_UNIT_SIZE(MODE) mode_to_unit_size (MODE)
704 #define GET_MODE_UNIT_BITSIZE(MODE) \
705 ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))
707 #define GET_MODE_UNIT_PRECISION(MODE) (mode_to_unit_precision (MODE))
709 /* Get the number of units in an object of mode MODE. This is 2 for
710 complex modes and the number of elements for vector modes. */
712 #if ONLY_FIXED_SIZE_MODES
713 #define GET_MODE_NUNITS(MODE) (mode_to_nunits (MODE).coeffs[0])
714 #else
715 ALWAYS_INLINE poly_uint16
716 GET_MODE_NUNITS (machine_mode mode)
718 return mode_to_nunits (mode);
721 template<typename T>
722 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
723 GET_MODE_NUNITS (const T &mode)
725 return mode_to_nunits (mode);
728 template<typename T>
729 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
730 GET_MODE_NUNITS (const T &mode)
732 return mode_to_nunits (mode).coeffs[0];
734 #endif
736 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI). */
738 template<typename T>
739 ALWAYS_INLINE opt_mode<T>
740 GET_MODE_WIDER_MODE (const T &m)
742 return typename opt_mode<T>::from_int (mode_wider[m]);
745 /* For scalars, this is a mode with twice the precision. For vectors,
746 this is a mode with the same inner mode but with twice the elements. */
748 template<typename T>
749 ALWAYS_INLINE opt_mode<T>
750 GET_MODE_2XWIDER_MODE (const T &m)
752 return typename opt_mode<T>::from_int (mode_2xwider[m]);
755 /* Get the complex mode from the component mode. */
756 extern const unsigned char mode_complex[NUM_MACHINE_MODES];
757 #define GET_MODE_COMPLEX_MODE(MODE) ((machine_mode) mode_complex[MODE])
759 /* Represents a machine mode that must have a fixed size. The main
760 use of this class is to represent the modes of objects that always
761 have static storage duration, such as constant pool entries.
762 (No current target supports the concept of variable-size static data.) */
763 class fixed_size_mode
765 public:
766 typedef mode_traits<fixed_size_mode>::from_int from_int;
767 typedef unsigned short measurement_type;
769 ALWAYS_INLINE fixed_size_mode () {}
770 ALWAYS_INLINE fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {}
771 ALWAYS_INLINE fixed_size_mode (const scalar_mode &m) : m_mode (m) {}
772 ALWAYS_INLINE fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {}
773 ALWAYS_INLINE fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {}
774 ALWAYS_INLINE fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {}
775 ALWAYS_INLINE fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
776 ALWAYS_INLINE fixed_size_mode (const complex_mode &m) : m_mode (m) {}
777 ALWAYS_INLINE operator machine_mode () const { return m_mode; }
779 static bool includes_p (machine_mode);
781 protected:
782 machine_mode m_mode;
785 /* Return true if MODE has a fixed size. */
787 inline bool
788 fixed_size_mode::includes_p (machine_mode mode)
790 return mode_to_bytes (mode).is_constant ();
793 /* Wrapper for mode arguments to target macros, so that if a target
794 doesn't need polynomial-sized modes, its header file can continue
795 to treat everything as fixed_size_mode. This should go away once
796 macros are moved to target hooks. It shouldn't be used in other
797 contexts. */
798 #if NUM_POLY_INT_COEFFS == 1
799 #define MACRO_MODE(MODE) (as_a <fixed_size_mode> (MODE))
800 #else
801 #define MACRO_MODE(MODE) (MODE)
802 #endif
804 extern opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int);
806 /* Return the machine mode to use for a MODE_INT of SIZE bits, if one
807 exists. If LIMIT is nonzero, modes wider than MAX_FIXED_MODE_SIZE
808 will not be used. */
810 inline opt_scalar_int_mode
811 int_mode_for_size (poly_uint64 size, int limit)
813 return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit));
816 /* Return the machine mode to use for a MODE_FLOAT of SIZE bits, if one
817 exists. */
819 inline opt_scalar_float_mode
820 float_mode_for_size (poly_uint64 size)
822 return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0));
825 /* Likewise for MODE_DECIMAL_FLOAT. */
827 inline opt_scalar_float_mode
828 decimal_float_mode_for_size (unsigned int size)
830 return dyn_cast <scalar_float_mode>
831 (mode_for_size (size, MODE_DECIMAL_FLOAT, 0));
834 extern machine_mode smallest_mode_for_size (poly_uint64, enum mode_class);
836 /* Find the narrowest integer mode that contains at least SIZE bits.
837 Such a mode must exist. */
839 inline scalar_int_mode
840 smallest_int_mode_for_size (poly_uint64 size)
842 return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT));
845 extern opt_scalar_int_mode int_mode_for_mode (machine_mode);
846 extern opt_machine_mode bitwise_mode_for_mode (machine_mode);
847 extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64);
848 extern opt_machine_mode mode_for_int_vector (unsigned int, poly_uint64);
850 /* Return the integer vector equivalent of MODE, if one exists. In other
851 words, return the mode for an integer vector that has the same number
852 of bits as MODE and the same number of elements as MODE, with the
853 latter being 1 if MODE is scalar. The returned mode can be either
854 an integer mode or a vector mode. */
856 inline opt_machine_mode
857 mode_for_int_vector (machine_mode mode)
859 return mode_for_int_vector (GET_MODE_UNIT_BITSIZE (mode),
860 GET_MODE_NUNITS (mode));
863 /* A class for iterating through possible bitfield modes. */
864 class bit_field_mode_iterator
866 public:
867 bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT,
868 poly_int64, poly_int64,
869 unsigned int, bool);
870 bool next_mode (scalar_int_mode *);
871 bool prefer_smaller_modes ();
873 private:
874 opt_scalar_int_mode m_mode;
875 /* We use signed values here because the bit position can be negative
876 for invalid input such as gcc.dg/pr48335-8.c. */
877 HOST_WIDE_INT m_bitsize;
878 HOST_WIDE_INT m_bitpos;
879 poly_int64 m_bitregion_start;
880 poly_int64 m_bitregion_end;
881 unsigned int m_align;
882 bool m_volatilep;
883 int m_count;
886 /* Find the best mode to use to access a bit field. */
888 extern bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int,
889 unsigned HOST_WIDE_INT, bool, scalar_int_mode *);
891 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT. */
893 extern CONST_MODE_BASE_ALIGN unsigned short mode_base_align[NUM_MACHINE_MODES];
895 extern unsigned get_mode_alignment (machine_mode);
897 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
899 /* For each class, get the narrowest mode in that class. */
901 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
902 #define GET_CLASS_NARROWEST_MODE(CLASS) \
903 ((machine_mode) class_narrowest_mode[CLASS])
905 /* The narrowest full integer mode available on the target. */
907 #define NARROWEST_INT_MODE \
908 (scalar_int_mode \
909 (scalar_int_mode::from_int (class_narrowest_mode[MODE_INT])))
911 /* Return the narrowest mode in T's class. */
913 template<typename T>
914 inline T
915 get_narrowest_mode (T mode)
917 return typename mode_traits<T>::from_int
918 (class_narrowest_mode[GET_MODE_CLASS (mode)]);
921 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
922 and the mode whose class is Pmode and whose size is POINTER_SIZE. */
924 extern scalar_int_mode byte_mode;
925 extern scalar_int_mode word_mode;
926 extern scalar_int_mode ptr_mode;
928 /* Target-dependent machine mode initialization - in insn-modes.c. */
929 extern void init_adjust_machine_modes (void);
931 #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \
932 (targetm.truly_noop_truncation (GET_MODE_PRECISION (MODE1), \
933 GET_MODE_PRECISION (MODE2)))
935 /* Return true if MODE is a scalar integer mode that fits in a
936 HOST_WIDE_INT. */
938 inline bool
939 HWI_COMPUTABLE_MODE_P (machine_mode mode)
941 machine_mode mme = mode;
942 return (SCALAR_INT_MODE_P (mme)
943 && mode_to_precision (mme).coeffs[0] <= HOST_BITS_PER_WIDE_INT);
946 inline bool
947 HWI_COMPUTABLE_MODE_P (scalar_int_mode mode)
949 return GET_MODE_PRECISION (mode) <= HOST_BITS_PER_WIDE_INT;
952 struct int_n_data_t {
953 /* These parts are initailized by genmodes output */
954 unsigned int bitsize;
955 scalar_int_mode_pod m;
956 /* RID_* is RID_INTN_BASE + index into this array */
959 /* This is also in tree.h. genmodes.c guarantees the're sorted from
960 smallest bitsize to largest bitsize. */
961 extern bool int_n_enabled_p[NUM_INT_N_ENTS];
962 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS];
964 /* Return true if MODE has class MODE_INT, storing it as a scalar_int_mode
965 in *INT_MODE if so. */
967 template<typename T>
968 inline bool
969 is_int_mode (machine_mode mode, T *int_mode)
971 if (GET_MODE_CLASS (mode) == MODE_INT)
973 *int_mode = scalar_int_mode (scalar_int_mode::from_int (mode));
974 return true;
976 return false;
979 /* Return true if MODE has class MODE_FLOAT, storing it as a
980 scalar_float_mode in *FLOAT_MODE if so. */
982 template<typename T>
983 inline bool
984 is_float_mode (machine_mode mode, T *float_mode)
986 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
988 *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode));
989 return true;
991 return false;
994 /* Return true if MODE has class MODE_COMPLEX_INT, storing it as
995 a complex_mode in *CMODE if so. */
997 template<typename T>
998 inline bool
999 is_complex_int_mode (machine_mode mode, T *cmode)
1001 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
1003 *cmode = complex_mode (complex_mode::from_int (mode));
1004 return true;
1006 return false;
1009 /* Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as
1010 a complex_mode in *CMODE if so. */
1012 template<typename T>
1013 inline bool
1014 is_complex_float_mode (machine_mode mode, T *cmode)
1016 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
1018 *cmode = complex_mode (complex_mode::from_int (mode));
1019 return true;
1021 return false;
1024 /* Return true if MODE is a scalar integer mode with a precision
1025 smaller than LIMIT's precision. */
1027 inline bool
1028 is_narrower_int_mode (machine_mode mode, scalar_int_mode limit)
1030 scalar_int_mode int_mode;
1031 return (is_a <scalar_int_mode> (mode, &int_mode)
1032 && GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit));
1035 namespace mode_iterator
1037 /* Start mode iterator *ITER at the first mode in class MCLASS, if any. */
1039 template<typename T>
1040 inline void
1041 start (opt_mode<T> *iter, enum mode_class mclass)
1043 if (GET_CLASS_NARROWEST_MODE (mclass) == E_VOIDmode)
1044 *iter = opt_mode<T> ();
1045 else
1046 *iter = as_a<T> (GET_CLASS_NARROWEST_MODE (mclass));
1049 inline void
1050 start (machine_mode *iter, enum mode_class mclass)
1052 *iter = GET_CLASS_NARROWEST_MODE (mclass);
1055 /* Return true if mode iterator *ITER has not reached the end. */
1057 template<typename T>
1058 inline bool
1059 iterate_p (opt_mode<T> *iter)
1061 return iter->exists ();
1064 inline bool
1065 iterate_p (machine_mode *iter)
1067 return *iter != E_VOIDmode;
1070 /* Set mode iterator *ITER to the next widest mode in the same class,
1071 if any. */
1073 template<typename T>
1074 inline void
1075 get_wider (opt_mode<T> *iter)
1077 *iter = GET_MODE_WIDER_MODE (iter->require ());
1080 inline void
1081 get_wider (machine_mode *iter)
1083 *iter = GET_MODE_WIDER_MODE (*iter).else_void ();
1086 /* Set mode iterator *ITER to the next widest mode in the same class.
1087 Such a mode is known to exist. */
1089 template<typename T>
1090 inline void
1091 get_known_wider (T *iter)
1093 *iter = GET_MODE_WIDER_MODE (*iter).require ();
1096 /* Set mode iterator *ITER to the mode that is two times wider than the
1097 current one, if such a mode exists. */
1099 template<typename T>
1100 inline void
1101 get_2xwider (opt_mode<T> *iter)
1103 *iter = GET_MODE_2XWIDER_MODE (iter->require ());
1106 inline void
1107 get_2xwider (machine_mode *iter)
1109 *iter = GET_MODE_2XWIDER_MODE (*iter).else_void ();
1113 /* Make ITERATOR iterate over all the modes in mode class CLASS,
1114 from narrowest to widest. */
1115 #define FOR_EACH_MODE_IN_CLASS(ITERATOR, CLASS) \
1116 for (mode_iterator::start (&(ITERATOR), CLASS); \
1117 mode_iterator::iterate_p (&(ITERATOR)); \
1118 mode_iterator::get_wider (&(ITERATOR)))
1120 /* Make ITERATOR iterate over all the modes in the range [START, END),
1121 in order of increasing width. */
1122 #define FOR_EACH_MODE(ITERATOR, START, END) \
1123 for ((ITERATOR) = (START); \
1124 (ITERATOR) != (END); \
1125 mode_iterator::get_known_wider (&(ITERATOR)))
1127 /* Make ITERATOR iterate over START and all wider modes in the same
1128 class, in order of increasing width. */
1129 #define FOR_EACH_MODE_FROM(ITERATOR, START) \
1130 for ((ITERATOR) = (START); \
1131 mode_iterator::iterate_p (&(ITERATOR)); \
1132 mode_iterator::get_wider (&(ITERATOR)))
1134 /* Make ITERATOR iterate over modes in the range [NARROWEST, END)
1135 in order of increasing width, where NARROWEST is the narrowest mode
1136 in END's class. */
1137 #define FOR_EACH_MODE_UNTIL(ITERATOR, END) \
1138 FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END)
1140 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1141 of increasing width. Start at the first mode wider than START,
1142 or don't iterate at all if there is no wider mode. */
1143 #define FOR_EACH_WIDER_MODE(ITERATOR, START) \
1144 for ((ITERATOR) = (START), mode_iterator::get_wider (&(ITERATOR)); \
1145 mode_iterator::iterate_p (&(ITERATOR)); \
1146 mode_iterator::get_wider (&(ITERATOR)))
1148 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1149 of increasing width, and with each mode being twice the width of the
1150 previous mode. Start at the mode that is two times wider than START,
1151 or don't iterate at all if there is no such mode. */
1152 #define FOR_EACH_2XWIDER_MODE(ITERATOR, START) \
1153 for ((ITERATOR) = (START), mode_iterator::get_2xwider (&(ITERATOR)); \
1154 mode_iterator::iterate_p (&(ITERATOR)); \
1155 mode_iterator::get_2xwider (&(ITERATOR)))
1157 template<typename T>
1158 void
1159 gt_ggc_mx (pod_mode<T> *)
1163 template<typename T>
1164 void
1165 gt_pch_nx (pod_mode<T> *)
1169 template<typename T>
1170 void
1171 gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *)
1175 #endif /* not HAVE_MACHINE_MODES */