1/* Machine mode definitions for GCC; included by rtl.h and tree.h.
2   Copyright (C) 1991-2015 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
23/* Make an enum class that gives all the machine modes.  */
24#include "insn-modes.h"
25
26/* Get the name of mode MODE as a string.  */
27
28extern const char * const mode_name[NUM_MACHINE_MODES];
29#define GET_MODE_NAME(MODE)  mode_name[MODE]
30
31/* Mode classes.  */
32
33#include "mode-classes.def"
34#define DEF_MODE_CLASS(M) M
35enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
36#undef DEF_MODE_CLASS
37#undef MODE_CLASSES
38
39/* Get the general kind of object that mode MODE represents
40   (integer, floating, complex, etc.)  */
41
42extern const unsigned char mode_class[NUM_MACHINE_MODES];
43#define GET_MODE_CLASS(MODE)  ((enum mode_class) mode_class[MODE])
44
45/* Nonzero if MODE is an integral mode.  */
46#define INTEGRAL_MODE_P(MODE)			\
47  (GET_MODE_CLASS (MODE) == MODE_INT		\
48   || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT \
49   || GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT \
50   || GET_MODE_CLASS (MODE) == MODE_VECTOR_INT)
51
52/* Nonzero if MODE is a floating-point mode.  */
53#define FLOAT_MODE_P(MODE)		\
54  (GET_MODE_CLASS (MODE) == MODE_FLOAT	\
55   || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT \
56   || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
57   || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT)
58
59/* Nonzero if MODE is a complex mode.  */
60#define COMPLEX_MODE_P(MODE)			\
61  (GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT	\
62   || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT)
63
64/* Nonzero if MODE is a vector mode.  */
65#define VECTOR_MODE_P(MODE)			\
66  (GET_MODE_CLASS (MODE) == MODE_VECTOR_INT	\
67   || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT	\
68   || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT	\
69   || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT	\
70   || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM	\
71   || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM)
72
73/* Nonzero if MODE is a scalar integral mode.  */
74#define SCALAR_INT_MODE_P(MODE)			\
75  (GET_MODE_CLASS (MODE) == MODE_INT		\
76   || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT)
77
78/* Nonzero if MODE is a scalar floating point mode.  */
79#define SCALAR_FLOAT_MODE_P(MODE)		\
80  (GET_MODE_CLASS (MODE) == MODE_FLOAT		\
81   || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
82
83/* Nonzero if MODE is a decimal floating point mode.  */
84#define DECIMAL_FLOAT_MODE_P(MODE)		\
85  (GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
86
87/* Nonzero if MODE is a scalar fract mode.  */
88#define SCALAR_FRACT_MODE_P(MODE)	\
89  (GET_MODE_CLASS (MODE) == MODE_FRACT)
90
91/* Nonzero if MODE is a scalar ufract mode.  */
92#define SCALAR_UFRACT_MODE_P(MODE)	\
93  (GET_MODE_CLASS (MODE) == MODE_UFRACT)
94
95/* Nonzero if MODE is a scalar fract or ufract mode.  */
96#define ALL_SCALAR_FRACT_MODE_P(MODE)	\
97  (SCALAR_FRACT_MODE_P (MODE) || SCALAR_UFRACT_MODE_P (MODE))
98
99/* Nonzero if MODE is a scalar accum mode.  */
100#define SCALAR_ACCUM_MODE_P(MODE)	\
101  (GET_MODE_CLASS (MODE) == MODE_ACCUM)
102
103/* Nonzero if MODE is a scalar uaccum mode.  */
104#define SCALAR_UACCUM_MODE_P(MODE)	\
105  (GET_MODE_CLASS (MODE) == MODE_UACCUM)
106
107/* Nonzero if MODE is a scalar accum or uaccum mode.  */
108#define ALL_SCALAR_ACCUM_MODE_P(MODE)	\
109  (SCALAR_ACCUM_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
110
111/* Nonzero if MODE is a scalar fract or accum mode.  */
112#define SIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)	\
113  (SCALAR_FRACT_MODE_P (MODE) || SCALAR_ACCUM_MODE_P (MODE))
114
115/* Nonzero if MODE is a scalar ufract or uaccum mode.  */
116#define UNSIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)	\
117  (SCALAR_UFRACT_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
118
119/* Nonzero if MODE is a scalar fract, ufract, accum or uaccum mode.  */
120#define ALL_SCALAR_FIXED_POINT_MODE_P(MODE)	\
121  (SIGNED_SCALAR_FIXED_POINT_MODE_P (MODE)	\
122   || UNSIGNED_SCALAR_FIXED_POINT_MODE_P (MODE))
123
124/* Nonzero if MODE is a scalar/vector fract mode.  */
125#define FRACT_MODE_P(MODE)		\
126  (GET_MODE_CLASS (MODE) == MODE_FRACT	\
127   || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT)
128
129/* Nonzero if MODE is a scalar/vector ufract mode.  */
130#define UFRACT_MODE_P(MODE)		\
131  (GET_MODE_CLASS (MODE) == MODE_UFRACT	\
132   || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT)
133
134/* Nonzero if MODE is a scalar/vector fract or ufract mode.  */
135#define ALL_FRACT_MODE_P(MODE)		\
136  (FRACT_MODE_P (MODE) || UFRACT_MODE_P (MODE))
137
138/* Nonzero if MODE is a scalar/vector accum mode.  */
139#define ACCUM_MODE_P(MODE)		\
140  (GET_MODE_CLASS (MODE) == MODE_ACCUM	\
141   || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM)
142
143/* Nonzero if MODE is a scalar/vector uaccum mode.  */
144#define UACCUM_MODE_P(MODE)		\
145  (GET_MODE_CLASS (MODE) == MODE_UACCUM	\
146   || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM)
147
148/* Nonzero if MODE is a scalar/vector accum or uaccum mode.  */
149#define ALL_ACCUM_MODE_P(MODE)		\
150  (ACCUM_MODE_P (MODE) || UACCUM_MODE_P (MODE))
151
152/* Nonzero if MODE is a scalar/vector fract or accum mode.  */
153#define SIGNED_FIXED_POINT_MODE_P(MODE)		\
154  (FRACT_MODE_P (MODE) || ACCUM_MODE_P (MODE))
155
156/* Nonzero if MODE is a scalar/vector ufract or uaccum mode.  */
157#define UNSIGNED_FIXED_POINT_MODE_P(MODE)	\
158  (UFRACT_MODE_P (MODE) || UACCUM_MODE_P (MODE))
159
160/* Nonzero if MODE is a scalar/vector fract, ufract, accum or uaccum mode.  */
161#define ALL_FIXED_POINT_MODE_P(MODE)		\
162  (SIGNED_FIXED_POINT_MODE_P (MODE)		\
163   || UNSIGNED_FIXED_POINT_MODE_P (MODE))
164
165/* Nonzero if CLASS modes can be widened.  */
166#define CLASS_HAS_WIDER_MODES_P(CLASS)         \
167  (CLASS == MODE_INT                           \
168   || CLASS == MODE_PARTIAL_INT                \
169   || CLASS == MODE_FLOAT                      \
170   || CLASS == MODE_DECIMAL_FLOAT              \
171   || CLASS == MODE_COMPLEX_FLOAT              \
172   || CLASS == MODE_FRACT                      \
173   || CLASS == MODE_UFRACT                     \
174   || CLASS == MODE_ACCUM                      \
175   || CLASS == MODE_UACCUM)
176
177#define POINTER_BOUNDS_MODE_P(MODE)      \
178  (GET_MODE_CLASS (MODE) == MODE_POINTER_BOUNDS)
179
180/* Get the size in bytes and bits of an object of mode MODE.  */
181
182extern CONST_MODE_SIZE unsigned char mode_size[NUM_MACHINE_MODES];
183#if GCC_VERSION >= 4001
184#define GET_MODE_SIZE(MODE) \
185  ((unsigned short) (__builtin_constant_p (MODE) \
186		     ? mode_size_inline (MODE) : mode_size[MODE]))
187#else
188#define GET_MODE_SIZE(MODE)    ((unsigned short) mode_size[MODE])
189#endif
190#define GET_MODE_BITSIZE(MODE) \
191  ((unsigned short) (GET_MODE_SIZE (MODE) * BITS_PER_UNIT))
192
193/* Get the number of value bits of an object of mode MODE.  */
194extern const unsigned short mode_precision[NUM_MACHINE_MODES];
195#define GET_MODE_PRECISION(MODE)  mode_precision[MODE]
196
197/* Get the number of integral bits of an object of mode MODE.  */
198extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES];
199#define GET_MODE_IBIT(MODE) mode_ibit[MODE]
200
201/* Get the number of fractional bits of an object of mode MODE.  */
202extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES];
203#define GET_MODE_FBIT(MODE) mode_fbit[MODE]
204
205/* Get a bitmask containing 1 for all bits in a word
206   that fit within mode MODE.  */
207
208extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES];
209
210#define GET_MODE_MASK(MODE) mode_mask_array[MODE]
211
212/* Return the mode of the inner elements in a vector.  */
213
214extern const unsigned char mode_inner[NUM_MACHINE_MODES];
215#if GCC_VERSION >= 4001
216#define GET_MODE_INNER(MODE) \
217  ((machine_mode) (__builtin_constant_p (MODE) \
218			? mode_inner_inline (MODE) : mode_inner[MODE]))
219#else
220#define GET_MODE_INNER(MODE) ((machine_mode) mode_inner[MODE])
221#endif
222
223/* Get the size in bytes or bites of the basic parts of an
224   object of mode MODE.  */
225
226#define GET_MODE_UNIT_SIZE(MODE)		\
227  (GET_MODE_INNER (MODE) == VOIDmode		\
228   ? GET_MODE_SIZE (MODE)			\
229   : GET_MODE_SIZE (GET_MODE_INNER (MODE)))
230
231#define GET_MODE_UNIT_BITSIZE(MODE) \
232  ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))
233
234#define GET_MODE_UNIT_PRECISION(MODE)		\
235  (GET_MODE_INNER (MODE) == VOIDmode		\
236   ? GET_MODE_PRECISION (MODE)			\
237   : GET_MODE_PRECISION (GET_MODE_INNER (MODE)))
238
239/* Get the number of units in the object.  */
240
241extern const unsigned char mode_nunits[NUM_MACHINE_MODES];
242#if GCC_VERSION >= 4001
243#define GET_MODE_NUNITS(MODE) \
244  ((unsigned char) (__builtin_constant_p (MODE) \
245		    ? mode_nunits_inline (MODE) : mode_nunits[MODE]))
246#else
247#define GET_MODE_NUNITS(MODE)  mode_nunits[MODE]
248#endif
249
250/* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI).  */
251
252extern const unsigned char mode_wider[NUM_MACHINE_MODES];
253#define GET_MODE_WIDER_MODE(MODE) ((machine_mode) mode_wider[MODE])
254
255/* For scalars, this is a mode with twice the precision.  For vectors,
256   this is a mode with the same inner mode but with twice the elements.  */
257extern const unsigned char mode_2xwider[NUM_MACHINE_MODES];
258#define GET_MODE_2XWIDER_MODE(MODE) ((machine_mode) mode_2xwider[MODE])
259
260/* Return the mode for data of a given size SIZE and mode class CLASS.
261   If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
262   The value is BLKmode if no other mode is found.  */
263
264extern machine_mode mode_for_size (unsigned int, enum mode_class, int);
265
266/* Similar, but find the smallest mode for a given width.  */
267
268extern machine_mode smallest_mode_for_size (unsigned int,
269						 enum mode_class);
270
271
272/* Return an integer mode of the exact same size as the input mode,
273   or BLKmode on failure.  */
274
275extern machine_mode int_mode_for_mode (machine_mode);
276
277extern machine_mode bitwise_mode_for_mode (machine_mode);
278
279/* Return a mode that is suitable for representing a vector,
280   or BLKmode on failure.  */
281
282extern machine_mode mode_for_vector (machine_mode, unsigned);
283
284/* A class for iterating through possible bitfield modes.  */
285class bit_field_mode_iterator
286{
287public:
288  bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT,
289			   HOST_WIDE_INT, HOST_WIDE_INT,
290			   unsigned int, bool);
291  bool next_mode (machine_mode *);
292  bool prefer_smaller_modes ();
293
294private:
295  machine_mode m_mode;
296  /* We use signed values here because the bit position can be negative
297     for invalid input such as gcc.dg/pr48335-8.c.  */
298  HOST_WIDE_INT m_bitsize;
299  HOST_WIDE_INT m_bitpos;
300  HOST_WIDE_INT m_bitregion_start;
301  HOST_WIDE_INT m_bitregion_end;
302  unsigned int m_align;
303  bool m_volatilep;
304  int m_count;
305};
306
307/* Find the best mode to use to access a bit field.  */
308
309extern machine_mode get_best_mode (int, int,
310					unsigned HOST_WIDE_INT,
311					unsigned HOST_WIDE_INT,
312					unsigned int,
313					machine_mode, bool);
314
315/* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.  */
316
317extern CONST_MODE_BASE_ALIGN unsigned char mode_base_align[NUM_MACHINE_MODES];
318
319extern unsigned get_mode_alignment (machine_mode);
320
321#define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
322
323/* Get the precision of the mode or its inner mode if it has one.  */
324
325extern unsigned int element_precision (machine_mode);
326
327/* For each class, get the narrowest mode in that class.  */
328
329extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
330#define GET_CLASS_NARROWEST_MODE(CLASS) \
331  ((machine_mode) class_narrowest_mode[CLASS])
332
333/* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
334   and the mode whose class is Pmode and whose size is POINTER_SIZE.  */
335
336extern machine_mode byte_mode;
337extern machine_mode word_mode;
338extern machine_mode ptr_mode;
339
340/* Target-dependent machine mode initialization - in insn-modes.c.  */
341extern void init_adjust_machine_modes (void);
342
343#define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \
344  TRULY_NOOP_TRUNCATION (GET_MODE_PRECISION (MODE1), \
345			 GET_MODE_PRECISION (MODE2))
346
347#define HWI_COMPUTABLE_MODE_P(MODE) \
348  (SCALAR_INT_MODE_P (MODE) \
349   && GET_MODE_PRECISION (MODE) <= HOST_BITS_PER_WIDE_INT)
350
351typedef struct {
352  /* These parts are initailized by genmodes output */
353  unsigned int bitsize;
354  machine_mode m;
355  /* RID_* is RID_INTN_BASE + index into this array */
356} int_n_data_t;
357
358/* This is also in tree.h.  genmodes.c guarantees the're sorted from
359   smallest bitsize to largest bitsize. */
360extern bool int_n_enabled_p[NUM_INT_N_ENTS];
361extern const int_n_data_t int_n_data[NUM_INT_N_ENTS];
362
363#endif /* not HAVE_MACHINE_MODES */
364