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
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
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
];
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. */
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
57 typedef machine_mode from_int
;
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
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
};
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
84 #define ONLY_FIXED_SIZE_MODES 0
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]
94 #include "mode-classes.def"
95 #define DEF_MODE_CLASS(M) M
96 enum mode_class
{ MODE_CLASSES
, MAX_MODE_CLASS
};
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) \
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. */
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
) {}
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;
260 bool exists () const;
261 template<typename U
> bool exists (U
*) const;
267 /* If the object contains a T, return its enum value, otherwise return
271 ALWAYS_INLINE machine_mode
272 opt_mode
<T
>::else_void () const
277 /* If the T exists, return its enum value, otherwise return E_BLKmode. */
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. */
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. */
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. */
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
));
320 /* A POD version of mode class T. */
325 typedef typename mode_traits
<T
>::from_int from_int
;
326 typedef typename
T::measurement_type measurement_type
;
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. */
338 is_a (machine_mode m
)
340 return T::includes_p (m
);
343 template<typename T
, typename U
>
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. */
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
>
362 as_a (const opt_mode
<U
> &m
)
364 return as_a
<T
> (m
.else_void ());
367 /* Convert M to an 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
>
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
388 template<typename T
, typename U
>
390 is_a (machine_mode m
, U
*result
)
392 if (T::includes_p (m
))
394 *result
= T (typename mode_traits
<T
>::from_int (m
));
400 /* Represents a machine mode that is known to be a SCALAR_INT_MODE_P. */
401 class scalar_int_mode
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
);
417 /* Return true if M is a scalar_int_mode. */
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
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
);
442 /* Return true if M is a scalar_float_mode. */
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. */
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
);
470 /* Return true if M represents some kind of scalar value. */
473 scalar_mode::includes_p (machine_mode m
)
475 switch (GET_MODE_CLASS (m
))
478 case MODE_PARTIAL_INT
:
484 case MODE_DECIMAL_FLOAT
:
485 case MODE_POINTER_BOUNDS
:
492 /* Represents a machine mode that is known to be a COMPLEX_MODE_P. */
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
);
509 /* Return true if M is a complex_mode. */
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
]);
526 return mode_size
[mode
];
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
)
556 return scalar_mode::from_int (mode_inner
[mode
]);
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
]);
569 return mode_unit_size
[mode
];
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
]);
582 return mode_unit_precision
[mode
];
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
]);
595 return mode_nunits
[mode
];
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])
604 ALWAYS_INLINE poly_uint16
605 GET_MODE_SIZE (machine_mode mode
)
607 return mode_to_bytes (mode
);
611 ALWAYS_INLINE typename if_poly
<typename
T::measurement_type
>::type
612 GET_MODE_SIZE (const T
&mode
)
614 return mode_to_bytes (mode
);
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];
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])
630 ALWAYS_INLINE poly_uint16
631 GET_MODE_BITSIZE (machine_mode mode
)
633 return mode_to_bits (mode
);
637 ALWAYS_INLINE typename if_poly
<typename
T::measurement_type
>::type
638 GET_MODE_BITSIZE (const T
&mode
)
640 return mode_to_bits (mode
);
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];
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])
657 ALWAYS_INLINE poly_uint16
658 GET_MODE_PRECISION (machine_mode mode
)
660 return mode_to_precision (mode
);
664 ALWAYS_INLINE typename if_poly
<typename
T::measurement_type
>::type
665 GET_MODE_PRECISION (const T
&mode
)
667 return mode_to_precision (mode
);
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];
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])
715 ALWAYS_INLINE poly_uint16
716 GET_MODE_NUNITS (machine_mode mode
)
718 return mode_to_nunits (mode
);
722 ALWAYS_INLINE typename if_poly
<typename
T::measurement_type
>::type
723 GET_MODE_NUNITS (const T
&mode
)
725 return mode_to_nunits (mode
);
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];
736 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI). */
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. */
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
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
);
785 /* Return true if MODE has a fixed size. */
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
798 #if NUM_POLY_INT_COEFFS == 1
799 #define MACRO_MODE(MODE) (as_a <fixed_size_mode> (MODE))
801 #define MACRO_MODE(MODE) (MODE)
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
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
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
867 bit_field_mode_iterator (HOST_WIDE_INT
, HOST_WIDE_INT
,
868 poly_int64
, poly_int64
,
870 bool next_mode (scalar_int_mode
*);
871 bool prefer_smaller_modes ();
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
;
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 \
909 (scalar_int_mode::from_int (class_narrowest_mode[MODE_INT])))
911 /* Return the narrowest mode in T's class. */
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
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
);
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. */
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
));
979 /* Return true if MODE has class MODE_FLOAT, storing it as a
980 scalar_float_mode in *FLOAT_MODE if so. */
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
));
994 /* Return true if MODE has class MODE_COMPLEX_INT, storing it as
995 a complex_mode in *CMODE if so. */
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
));
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
>
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
));
1024 /* Return true if MODE is a scalar integer mode with a precision
1025 smaller than LIMIT's precision. */
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
>
1041 start (opt_mode
<T
> *iter
, enum mode_class mclass
)
1043 if (GET_CLASS_NARROWEST_MODE (mclass
) == E_VOIDmode
)
1044 *iter
= opt_mode
<T
> ();
1046 *iter
= as_a
<T
> (GET_CLASS_NARROWEST_MODE (mclass
));
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
>
1059 iterate_p (opt_mode
<T
> *iter
)
1061 return iter
->exists ();
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,
1073 template<typename T
>
1075 get_wider (opt_mode
<T
> *iter
)
1077 *iter
= GET_MODE_WIDER_MODE (iter
->require ());
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
>
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
>
1101 get_2xwider (opt_mode
<T
> *iter
)
1103 *iter
= GET_MODE_2XWIDER_MODE (iter
->require ());
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
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
>
1159 gt_ggc_mx (pod_mode
<T
> *)
1163 template<typename T
>
1165 gt_pch_nx (pod_mode
<T
> *)
1169 template<typename T
>
1171 gt_pch_nx (pod_mode
<T
> *, void (*) (void *, void *), void *)
1175 #endif /* not HAVE_MACHINE_MODES */