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