Merge branch 'vendor/FILE'
[dragonfly.git] / contrib / gcc-3.4 / gcc / varray.h
1 /* Virtual array support.
2    Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004
3    Free Software Foundation, Inc.
4    Contributed by Cygnus Solutions.
5
6    This file is part of GCC.
7
8    GCC is free software; you can redistribute it and/or modify it
9    under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2, or (at your option)
11    any later version.
12
13    GCC is distributed in the hope that it will be useful, but WITHOUT
14    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16    License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with GCC; see the file COPYING.  If not, write to the Free
20    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
21    MA 02111-1307, USA.  */
22
23 #ifndef GCC_VARRAY_H
24 #define GCC_VARRAY_H
25
26 #ifndef HOST_WIDE_INT
27 #include "machmode.h"
28 #endif
29
30 #ifndef GCC_SYSTEM_H
31 #include "system.h"
32 #include "coretypes.h"
33 #include "tm.h"
34 #endif
35
36 /* Auxiliary structure used inside the varray structure, used for
37    function integration data.  */
38
39 struct const_equiv_data GTY(()) {
40   /* Map pseudo reg number in calling function to equivalent constant.  We
41      cannot in general substitute constants into parameter pseudo registers,
42      since some machine descriptions (many RISCs) won't always handle
43      the resulting insns.  So if an incoming parameter has a constant
44      equivalent, we record it here, and if the resulting insn is
45      recognizable, we go with it.
46
47      We also use this mechanism to convert references to incoming arguments
48      and stacked variables.  copy_rtx_and_substitute will replace the virtual
49      incoming argument and virtual stacked variables registers with new
50      pseudos that contain pointers into the replacement area allocated for
51      this inline instance.  These pseudos are then marked as being equivalent
52      to the appropriate address and substituted if valid.  */
53   rtx rtx;
54
55   /* Record the valid age for each entry.  The entry is invalid if its
56      age is less than const_age.  */
57   unsigned age;
58 };
59
60 /* Enum indicating what the varray contains.
61    If this is changed, `element' in varray.c needs to be updated.  */
62
63 enum varray_data_enum {
64   VARRAY_DATA_C,
65   VARRAY_DATA_UC,
66   VARRAY_DATA_S,
67   VARRAY_DATA_US,
68   VARRAY_DATA_I,
69   VARRAY_DATA_U,
70   VARRAY_DATA_L,
71   VARRAY_DATA_UL,
72   VARRAY_DATA_HINT,
73   VARRAY_DATA_UHINT,
74   VARRAY_DATA_GENERIC,
75   VARRAY_DATA_CPTR,
76   VARRAY_DATA_RTX,
77   VARRAY_DATA_RTVEC,
78   VARRAY_DATA_TREE,
79   VARRAY_DATA_BITMAP,
80   VARRAY_DATA_REG,
81   VARRAY_DATA_CONST_EQUIV,
82   VARRAY_DATA_BB,
83   VARRAY_DATA_TE,
84   NUM_VARRAY_DATA
85 };
86
87 /* Union of various array types that are used.  */
88 typedef union varray_data_tag GTY (()) {
89   char                    GTY ((length ("%0.num_elements"),
90                                 tag ("VARRAY_DATA_C")))         c[1];
91   unsigned char           GTY ((length ("%0.num_elements"),
92                                 tag ("VARRAY_DATA_UC")))        uc[1];
93   short                   GTY ((length ("%0.num_elements"),
94                                 tag ("VARRAY_DATA_S")))         s[1];
95   unsigned short          GTY ((length ("%0.num_elements"),
96                                 tag ("VARRAY_DATA_US")))        us[1];
97   int                     GTY ((length ("%0.num_elements"),
98                                 tag ("VARRAY_DATA_I")))         i[1];
99   unsigned int            GTY ((length ("%0.num_elements"),
100                                 tag ("VARRAY_DATA_U")))         u[1];
101   long                    GTY ((length ("%0.num_elements"),
102                                 tag ("VARRAY_DATA_L")))         l[1];
103   unsigned long           GTY ((length ("%0.num_elements"),
104                                 tag ("VARRAY_DATA_UL")))        ul[1];
105   HOST_WIDE_INT           GTY ((length ("%0.num_elements"),
106                                 tag ("VARRAY_DATA_HINT")))      hint[1];
107   unsigned HOST_WIDE_INT  GTY ((length ("%0.num_elements"),
108                                 tag ("VARRAY_DATA_UHINT")))     uhint[1];
109   PTR                     GTY ((length ("%0.num_elements"), use_param (""),
110                                 tag ("VARRAY_DATA_GENERIC")))   generic[1];
111   char                   *GTY ((length ("%0.num_elements"),
112                                 tag ("VARRAY_DATA_CPTR")))      cptr[1];
113   rtx                     GTY ((length ("%0.num_elements"),
114                                 tag ("VARRAY_DATA_RTX")))       rtx[1];
115   rtvec                   GTY ((length ("%0.num_elements"),
116                                 tag ("VARRAY_DATA_RTVEC")))     rtvec[1];
117   tree                    GTY ((length ("%0.num_elements"),
118                                 tag ("VARRAY_DATA_TREE")))      tree[1];
119   struct bitmap_head_def *GTY ((length ("%0.num_elements"),
120                                 tag ("VARRAY_DATA_BITMAP")))    bitmap[1];
121   struct reg_info_def    *GTY ((length ("%0.num_elements"), skip (""),
122                                 tag ("VARRAY_DATA_REG")))       reg[1];
123   struct const_equiv_data GTY ((length ("%0.num_elements"),
124                         tag ("VARRAY_DATA_CONST_EQUIV")))       const_equiv[1];
125   struct basic_block_def *GTY ((length ("%0.num_elements"), skip (""),
126                                 tag ("VARRAY_DATA_BB")))        bb[1];
127   struct elt_list        *GTY ((length ("%0.num_elements"),
128                                 tag ("VARRAY_DATA_TE")))        te[1];
129 } varray_data;
130
131 /* Virtual array of pointers header.  */
132 struct varray_head_tag GTY(()) {
133   size_t        num_elements;   /* Maximum element number allocated.  */
134   size_t        elements_used;  /* The number of elements used, if
135                                    using VARRAY_PUSH/VARRAY_POP.  */
136   enum varray_data_enum type;   /* The kind of elements in the varray.  */
137   const char   *name;           /* name of the varray for reporting errors */
138   varray_data   GTY ((desc ("%0.type"))) data;  /* The data elements follow,
139                                                    must be last.  */
140 };
141 typedef struct varray_head_tag *varray_type;
142
143 /* Allocate a virtual array with NUM elements, each of which is SIZE bytes
144    long, named NAME.  Array elements are zeroed.  */
145 extern varray_type varray_init (size_t, enum varray_data_enum, const char *);
146
147 #define VARRAY_CHAR_INIT(va, num, name) \
148   va = varray_init (num, VARRAY_DATA_C, name)
149
150 #define VARRAY_UCHAR_INIT(va, num, name) \
151   va = varray_init (num, VARRAY_DATA_UC, name)
152
153 #define VARRAY_SHORT_INIT(va, num, name) \
154   va = varray_init (num, VARRAY_DATA_S, name)
155
156 #define VARRAY_USHORT_INIT(va, num, name) \
157   va = varray_init (num, VARRAY_DATA_US, name)
158
159 #define VARRAY_INT_INIT(va, num, name) \
160   va = varray_init (num, VARRAY_DATA_I, name)
161
162 #define VARRAY_UINT_INIT(va, num, name) \
163   va = varray_init (num, VARRAY_DATA_U, name)
164
165 #define VARRAY_LONG_INIT(va, num, name) \
166   va = varray_init (num, VARRAY_DATA_L, name)
167
168 #define VARRAY_ULONG_INIT(va, num, name) \
169   va = varray_init (num, VARRAY_DATA_UL, name)
170
171 #define VARRAY_WIDE_INT_INIT(va, num, name) \
172   va = varray_init (num, VARRAY_DATA_HINT, name)
173
174 #define VARRAY_UWIDE_INT_INIT(va, num, name) \
175   va = varray_init (num, VARRAY_DATA_UHINT, name)
176
177 #define VARRAY_GENERIC_PTR_INIT(va, num, name) \
178   va = varray_init (num, VARRAY_DATA_GENERIC, name)
179
180 #define VARRAY_CHAR_PTR_INIT(va, num, name) \
181   va = varray_init (num, VARRAY_DATA_CPTR, name)
182
183 #define VARRAY_RTX_INIT(va, num, name) \
184   va = varray_init (num, VARRAY_DATA_RTX, name)
185
186 #define VARRAY_RTVEC_INIT(va, num, name) \
187   va = varray_init (num, VARRAY_DATA_RTVEC, name)
188
189 #define VARRAY_TREE_INIT(va, num, name) \
190   va = varray_init (num, VARRAY_DATA_TREE, name)
191
192 #define VARRAY_BITMAP_INIT(va, num, name) \
193   va = varray_init (num, VARRAY_DATA_BITMAP, name)
194
195 #define VARRAY_REG_INIT(va, num, name) \
196   va = varray_init (num, VARRAY_DATA_REG, name)
197
198 #define VARRAY_CONST_EQUIV_INIT(va, num, name) \
199   va = varray_init (num, VARRAY_DATA_CONST_EQUIV, name)
200
201 #define VARRAY_BB_INIT(va, num, name) \
202   va = varray_init (num, VARRAY_DATA_BB, name)
203
204 #define VARRAY_ELT_LIST_INIT(va, num, name) \
205   va = varray_init (num, VARRAY_DATA_TE, name)
206
207 /* Free up memory allocated by the virtual array, but do not free any of the
208    elements involved.  */
209 #define VARRAY_FREE(vp) \
210   do { if (vp) { free (vp); vp = (varray_type) 0; } } while (0)
211
212 /* Grow/shrink the virtual array VA to N elements.  */
213 extern varray_type varray_grow (varray_type, size_t);
214
215 #define VARRAY_GROW(VA, N) ((VA) = varray_grow (VA, N))
216
217 #define VARRAY_SIZE(VA) ((VA)->num_elements)
218
219 #define VARRAY_ACTIVE_SIZE(VA)  ((VA)->elements_used)
220 #define VARRAY_POP_ALL(VA)      ((VA)->elements_used = 0)
221
222 #define VARRAY_CLEAR(VA) varray_clear(VA)
223
224 extern void varray_clear (varray_type);
225
226 extern void dump_varray_statistics (void);
227
228 /* Check for VARRAY_xxx macros being in bound.  */
229 #if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
230 extern void varray_check_failed (varray_type, size_t, const char *, int,
231                                  const char *) ATTRIBUTE_NORETURN;
232 extern void varray_underflow (varray_type, const char *, int, const char *)
233      ATTRIBUTE_NORETURN;
234 #define VARRAY_CHECK(VA, N, T) __extension__                    \
235 (*({ varray_type const _va = (VA);                              \
236      const size_t _n = (N);                                     \
237      if (_n >= _va->num_elements)                               \
238        varray_check_failed (_va, _n, __FILE__, __LINE__, __FUNCTION__); \
239      &_va->data.T[_n]; }))
240
241 #define VARRAY_POP(VA) do {                                     \
242   varray_type const _va = (VA);                                 \
243   if (_va->elements_used == 0)                                  \
244     varray_underflow (_va, __FILE__, __LINE__, __FUNCTION__);   \
245   else                                                          \
246     _va->elements_used--;                                       \
247 } while (0)
248
249 #else
250 #define VARRAY_CHECK(VA, N, T) ((VA)->data.T[N])
251 /* Pop the top element of VA.  */
252 #define VARRAY_POP(VA) do { ((VA)->elements_used--); } while (0)
253 #endif
254
255 /* Push X onto VA.  T is the name of the field in varray_data
256    corresponding to the type of X.  */
257 #define VARRAY_PUSH(VA, T, X)                           \
258   do                                                    \
259     {                                                   \
260       if ((VA)->elements_used >= (VA)->num_elements)    \
261         VARRAY_GROW ((VA), 2 * (VA)->num_elements);     \
262       (VA)->data.T[(VA)->elements_used++] = (X);        \
263     }                                                   \
264   while (0)
265
266 #define VARRAY_CHAR(VA, N)              VARRAY_CHECK (VA, N, c)
267 #define VARRAY_UCHAR(VA, N)             VARRAY_CHECK (VA, N, uc)
268 #define VARRAY_SHORT(VA, N)             VARRAY_CHECK (VA, N, s)
269 #define VARRAY_USHORT(VA, N)            VARRAY_CHECK (VA, N, us)
270 #define VARRAY_INT(VA, N)               VARRAY_CHECK (VA, N, i)
271 #define VARRAY_UINT(VA, N)              VARRAY_CHECK (VA, N, u)
272 #define VARRAY_LONG(VA, N)              VARRAY_CHECK (VA, N, l)
273 #define VARRAY_ULONG(VA, N)             VARRAY_CHECK (VA, N, ul)
274 #define VARRAY_WIDE_INT(VA, N)          VARRAY_CHECK (VA, N, hint)
275 #define VARRAY_UWIDE_INT(VA, N)         VARRAY_CHECK (VA, N, uhint)
276 #define VARRAY_GENERIC_PTR(VA,N)        VARRAY_CHECK (VA, N, generic)
277 #define VARRAY_CHAR_PTR(VA,N)           VARRAY_CHECK (VA, N, cptr)
278 #define VARRAY_RTX(VA, N)               VARRAY_CHECK (VA, N, rtx)
279 #define VARRAY_RTVEC(VA, N)             VARRAY_CHECK (VA, N, rtvec)
280 #define VARRAY_TREE(VA, N)              VARRAY_CHECK (VA, N, tree)
281 #define VARRAY_BITMAP(VA, N)            VARRAY_CHECK (VA, N, bitmap)
282 #define VARRAY_REG(VA, N)               VARRAY_CHECK (VA, N, reg)
283 #define VARRAY_CONST_EQUIV(VA, N)       VARRAY_CHECK (VA, N, const_equiv)
284 #define VARRAY_BB(VA, N)                VARRAY_CHECK (VA, N, bb)
285 #define VARRAY_ELT_LIST(VA, N)          VARRAY_CHECK (VA, N, te)
286
287 /* Push a new element on the end of VA, extending it if necessary.  */
288 #define VARRAY_PUSH_CHAR(VA, X)         VARRAY_PUSH (VA, c, X)
289 #define VARRAY_PUSH_UCHAR(VA, X)        VARRAY_PUSH (VA, uc, X)
290 #define VARRAY_PUSH_SHORT(VA, X)        VARRAY_PUSH (VA, s, X)
291 #define VARRAY_PUSH_USHORT(VA, X)       VARRAY_PUSH (VA, us, X)
292 #define VARRAY_PUSH_INT(VA, X)          VARRAY_PUSH (VA, i, X)
293 #define VARRAY_PUSH_UINT(VA, X)         VARRAY_PUSH (VA, u, X)
294 #define VARRAY_PUSH_LONG(VA, X)         VARRAY_PUSH (VA, l, X)
295 #define VARRAY_PUSH_ULONG(VA, X)        VARRAY_PUSH (VA, ul, X)
296 #define VARRAY_PUSH_WIDE_INT(VA, X)     VARRAY_PUSH (VA, hint, X)
297 #define VARRAY_PUSH_UWIDE_INT(VA, X)    VARRAY_PUSH (VA, uhint, X)
298 #define VARRAY_PUSH_GENERIC_PTR(VA, X)  VARRAY_PUSH (VA, generic, X)
299 #define VARRAY_PUSH_CHAR_PTR(VA, X)     VARRAY_PUSH (VA, cptr, X)
300 #define VARRAY_PUSH_RTX(VA, X)          VARRAY_PUSH (VA, rtx, X)
301 #define VARRAY_PUSH_RTVEC(VA, X)        VARRAY_PUSH (VA, rtvec, X)
302 #define VARRAY_PUSH_TREE(VA, X)         VARRAY_PUSH (VA, tree, X)
303 #define VARRAY_PUSH_BITMAP(VA, X)       VARRAY_PUSH (VA, bitmap, X)
304 #define VARRAY_PUSH_REG(VA, X)          VARRAY_PUSH (VA, reg, X)
305 #define VARRAY_PUSH_CONST_EQUIV(VA, X)  VARRAY_PUSH (VA, const_equiv, X)
306 #define VARRAY_PUSH_BB(VA, X)           VARRAY_PUSH (VA, bb, X)
307
308 /* Return the last element of VA.  */
309 #define VARRAY_TOP(VA, T) VARRAY_CHECK(VA, (VA)->elements_used - 1, T)
310
311 #define VARRAY_TOP_CHAR(VA)             VARRAY_TOP (VA, c)
312 #define VARRAY_TOP_UCHAR(VA)            VARRAY_TOP (VA, uc)
313 #define VARRAY_TOP_SHORT(VA)            VARRAY_TOP (VA, s)
314 #define VARRAY_TOP_USHORT(VA)           VARRAY_TOP (VA, us)
315 #define VARRAY_TOP_INT(VA)              VARRAY_TOP (VA, i)
316 #define VARRAY_TOP_UINT(VA)             VARRAY_TOP (VA, u)
317 #define VARRAY_TOP_LONG(VA)             VARRAY_TOP (VA, l)
318 #define VARRAY_TOP_ULONG(VA)            VARRAY_TOP (VA, ul)
319 #define VARRAY_TOP_WIDE_INT(VA)         VARRAY_TOP (VA, hint)
320 #define VARRAY_TOP_UWIDE_INT(VA)        VARRAY_TOP (VA, uhint)
321 #define VARRAY_TOP_GENERIC_PTR(VA)      VARRAY_TOP (VA, generic)
322 #define VARRAY_TOP_CHAR_PTR(VA)         VARRAY_TOP (VA, cptr)
323 #define VARRAY_TOP_RTX(VA)              VARRAY_TOP (VA, rtx)
324 #define VARRAY_TOP_RTVEC(VA)            VARRAY_TOP (VA, rtvec)
325 #define VARRAY_TOP_TREE(VA)             VARRAY_TOP (VA, tree)
326 #define VARRAY_TOP_BITMAP(VA)           VARRAY_TOP (VA, bitmap)
327 #define VARRAY_TOP_REG(VA)              VARRAY_TOP (VA, reg)
328 #define VARRAY_TOP_CONST_EQUIV(VA)      VARRAY_TOP (VA, const_equiv)
329 #define VARRAY_TOP_BB(VA)               VARRAY_TOP (VA, bb)
330
331 #endif /* ! GCC_VARRAY_H */