source: arduino-1-6-7/trunk/fuentes/arduino-ide-amd64/hardware/tools/avr/lib/gcc/avr/4.9.2/plugin/include/machmode.h @ 4837

Last change on this file since 4837 was 4837, checked in by daduve, 2 years ago

Adding new version

File size: 11.5 KB
Line 
1/* Machine mode definitions for GCC; included by rtl.h and tree.h.
2   Copyright (C) 1991-2014 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/* Get the size in bytes and bits of an object of mode MODE.  */
178
179extern CONST_MODE_SIZE unsigned char mode_size[NUM_MACHINE_MODES];
180#define GET_MODE_SIZE(MODE)    ((unsigned short) mode_size[MODE])
181#define GET_MODE_BITSIZE(MODE) \
182  ((unsigned short) (GET_MODE_SIZE (MODE) * BITS_PER_UNIT))
183
184/* Get the number of value bits of an object of mode MODE.  */
185extern const unsigned short mode_precision[NUM_MACHINE_MODES];
186#define GET_MODE_PRECISION(MODE)  mode_precision[MODE]
187
188/* Get the number of integral bits of an object of mode MODE.  */
189extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES];
190#define GET_MODE_IBIT(MODE) mode_ibit[MODE]
191
192/* Get the number of fractional bits of an object of mode MODE.  */
193extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES];
194#define GET_MODE_FBIT(MODE) mode_fbit[MODE]
195
196/* Get a bitmask containing 1 for all bits in a word
197   that fit within mode MODE.  */
198
199extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES];
200
201#define GET_MODE_MASK(MODE) mode_mask_array[MODE]
202
203/* Return the mode of the inner elements in a vector.  */
204
205extern const unsigned char mode_inner[NUM_MACHINE_MODES];
206#define GET_MODE_INNER(MODE) ((enum machine_mode) mode_inner[MODE])
207
208/* Get the size in bytes or bites of the basic parts of an
209   object of mode MODE.  */
210
211#define GET_MODE_UNIT_SIZE(MODE)                \
212  (GET_MODE_INNER (MODE) == VOIDmode            \
213   ? GET_MODE_SIZE (MODE)                       \
214   : GET_MODE_SIZE (GET_MODE_INNER (MODE)))
215
216#define GET_MODE_UNIT_BITSIZE(MODE) \
217  ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))
218
219#define GET_MODE_UNIT_PRECISION(MODE)           \
220  (GET_MODE_INNER (MODE) == VOIDmode            \
221   ? GET_MODE_PRECISION (MODE)                  \
222   : GET_MODE_PRECISION (GET_MODE_INNER (MODE)))
223
224/* Get the number of units in the object.  */
225
226extern const unsigned char mode_nunits[NUM_MACHINE_MODES];
227#define GET_MODE_NUNITS(MODE)  mode_nunits[MODE]
228
229/* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI).  */
230
231extern const unsigned char mode_wider[NUM_MACHINE_MODES];
232#define GET_MODE_WIDER_MODE(MODE) ((enum machine_mode) mode_wider[MODE])
233
234/* For scalars, this is a mode with twice the precision.  For vectors,
235   this is a mode with the same inner mode but with twice the elements.  */
236extern const unsigned char mode_2xwider[NUM_MACHINE_MODES];
237#define GET_MODE_2XWIDER_MODE(MODE) ((enum machine_mode) mode_2xwider[MODE])
238
239/* Return the mode for data of a given size SIZE and mode class CLASS.
240   If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
241   The value is BLKmode if no other mode is found.  */
242
243extern enum machine_mode mode_for_size (unsigned int, enum mode_class, int);
244
245/* Similar, but find the smallest mode for a given width.  */
246
247extern enum machine_mode smallest_mode_for_size (unsigned int,
248                                                 enum mode_class);
249
250
251/* Return an integer mode of the exact same size as the input mode,
252   or BLKmode on failure.  */
253
254extern enum machine_mode int_mode_for_mode (enum machine_mode);
255
256/* Return a mode that is suitable for representing a vector,
257   or BLKmode on failure.  */
258
259extern enum machine_mode mode_for_vector (enum machine_mode, unsigned);
260
261/* A class for iterating through possible bitfield modes.  */
262class bit_field_mode_iterator
263{
264public:
265  bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT,
266                           HOST_WIDE_INT, HOST_WIDE_INT,
267                           unsigned int, bool);
268  bool next_mode (enum machine_mode *);
269  bool prefer_smaller_modes ();
270
271private:
272  enum machine_mode m_mode;
273  /* We use signed values here because the bit position can be negative
274     for invalid input such as gcc.dg/pr48335-8.c.  */
275  HOST_WIDE_INT m_bitsize;
276  HOST_WIDE_INT m_bitpos;
277  HOST_WIDE_INT m_bitregion_start;
278  HOST_WIDE_INT m_bitregion_end;
279  unsigned int m_align;
280  bool m_volatilep;
281  int m_count;
282};
283
284/* Find the best mode to use to access a bit field.  */
285
286extern enum machine_mode get_best_mode (int, int,
287                                        unsigned HOST_WIDE_INT,
288                                        unsigned HOST_WIDE_INT,
289                                        unsigned int,
290                                        enum machine_mode, bool);
291
292/* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.  */
293
294extern CONST_MODE_BASE_ALIGN unsigned char mode_base_align[NUM_MACHINE_MODES];
295
296extern unsigned get_mode_alignment (enum machine_mode);
297
298#define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
299
300/* Get the precision of the mode or its inner mode if it has one.  */
301
302extern unsigned int element_precision (enum machine_mode);
303
304/* For each class, get the narrowest mode in that class.  */
305
306extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
307#define GET_CLASS_NARROWEST_MODE(CLASS) \
308  ((enum machine_mode) class_narrowest_mode[CLASS])
309
310/* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
311   and the mode whose class is Pmode and whose size is POINTER_SIZE.  */
312
313extern enum machine_mode byte_mode;
314extern enum machine_mode word_mode;
315extern enum machine_mode ptr_mode;
316
317/* Target-dependent machine mode initialization - in insn-modes.c.  */
318extern void init_adjust_machine_modes (void);
319
320#define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \
321  TRULY_NOOP_TRUNCATION (GET_MODE_PRECISION (MODE1), \
322                         GET_MODE_PRECISION (MODE2))
323
324#define HWI_COMPUTABLE_MODE_P(MODE) \
325  (SCALAR_INT_MODE_P (MODE) \
326   && GET_MODE_PRECISION (MODE) <= HOST_BITS_PER_WIDE_INT)
327
328#endif /* not HAVE_MACHINE_MODES */
Note: See TracBrowser for help on using the repository browser.