]>
Commit | Line | Data |
---|---|---|
848205e6 | 1 | /* Virtual array support. |
9dcd6f09 | 2 | Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004, 2007 |
2e1eedd6 | 3 | Free Software Foundation, Inc. |
848205e6 MM |
4 | Contributed by Cygnus Solutions. |
5 | ||
1322177d | 6 | This file is part of GCC. |
848205e6 | 7 | |
1322177d | 8 | GCC is free software; you can redistribute it and/or modify it |
848205e6 | 9 | under the terms of the GNU General Public License as published by |
9dcd6f09 | 10 | the Free Software Foundation; either version 3, or (at your option) |
848205e6 MM |
11 | any later version. |
12 | ||
1322177d LB |
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. | |
848205e6 MM |
17 | |
18 | You should have received a copy of the GNU General Public License | |
9dcd6f09 NC |
19 | along with GCC; see the file COPYING3. If not see |
20 | <http://www.gnu.org/licenses/>. */ | |
848205e6 | 21 | |
88657302 RH |
22 | #ifndef GCC_VARRAY_H |
23 | #define GCC_VARRAY_H | |
848205e6 | 24 | |
848205e6 MM |
25 | #ifndef HOST_WIDE_INT |
26 | #include "machmode.h" | |
27 | #endif | |
28 | ||
88657302 | 29 | #ifndef GCC_SYSTEM_H |
4dfb04c6 | 30 | #include "system.h" |
4977bab6 ZW |
31 | #include "coretypes.h" |
32 | #include "tm.h" | |
4dfb04c6 MM |
33 | #endif |
34 | ||
2e1eedd6 | 35 | /* Enum indicating what the varray contains. |
19a7414e | 36 | If this is changed, `element' in varray.c needs to be updated. */ |
e2500fed GK |
37 | |
38 | enum varray_data_enum { | |
39 | VARRAY_DATA_C, | |
40 | VARRAY_DATA_UC, | |
41 | VARRAY_DATA_S, | |
42 | VARRAY_DATA_US, | |
43 | VARRAY_DATA_I, | |
44 | VARRAY_DATA_U, | |
45 | VARRAY_DATA_L, | |
46 | VARRAY_DATA_UL, | |
47 | VARRAY_DATA_HINT, | |
48 | VARRAY_DATA_UHINT, | |
49 | VARRAY_DATA_GENERIC, | |
6de9cd9a | 50 | VARRAY_DATA_GENERIC_NOGC, |
e2500fed GK |
51 | VARRAY_DATA_CPTR, |
52 | VARRAY_DATA_RTX, | |
53 | VARRAY_DATA_RTVEC, | |
54 | VARRAY_DATA_TREE, | |
55 | VARRAY_DATA_BITMAP, | |
56 | VARRAY_DATA_REG, | |
e2500fed GK |
57 | VARRAY_DATA_BB, |
58 | VARRAY_DATA_TE, | |
6de9cd9a DN |
59 | VARRAY_DATA_EDGE, |
60 | VARRAY_DATA_TREE_PTR, | |
e2500fed GK |
61 | NUM_VARRAY_DATA |
62 | }; | |
63 | ||
848205e6 | 64 | /* Union of various array types that are used. */ |
d1b38208 | 65 | typedef union GTY (()) varray_data_tag { |
e2500fed | 66 | char GTY ((length ("%0.num_elements"), |
c981d223 | 67 | tag ("VARRAY_DATA_C"))) vdt_c[1]; |
e2500fed | 68 | unsigned char GTY ((length ("%0.num_elements"), |
c981d223 | 69 | tag ("VARRAY_DATA_UC"))) vdt_uc[1]; |
e2500fed | 70 | short GTY ((length ("%0.num_elements"), |
c981d223 | 71 | tag ("VARRAY_DATA_S"))) vdt_s[1]; |
e2500fed | 72 | unsigned short GTY ((length ("%0.num_elements"), |
c981d223 | 73 | tag ("VARRAY_DATA_US"))) vdt_us[1]; |
e2500fed | 74 | int GTY ((length ("%0.num_elements"), |
c981d223 | 75 | tag ("VARRAY_DATA_I"))) vdt_i[1]; |
e2500fed | 76 | unsigned int GTY ((length ("%0.num_elements"), |
c981d223 | 77 | tag ("VARRAY_DATA_U"))) vdt_u[1]; |
e2500fed | 78 | long GTY ((length ("%0.num_elements"), |
c981d223 | 79 | tag ("VARRAY_DATA_L"))) vdt_l[1]; |
e2500fed | 80 | unsigned long GTY ((length ("%0.num_elements"), |
c981d223 | 81 | tag ("VARRAY_DATA_UL"))) vdt_ul[1]; |
e2500fed | 82 | HOST_WIDE_INT GTY ((length ("%0.num_elements"), |
c981d223 | 83 | tag ("VARRAY_DATA_HINT"))) vdt_hint[1]; |
e2500fed | 84 | unsigned HOST_WIDE_INT GTY ((length ("%0.num_elements"), |
c981d223 | 85 | tag ("VARRAY_DATA_UHINT"))) vdt_uhint[1]; |
1431042e | 86 | PTR GTY ((length ("%0.num_elements"), use_param, |
c981d223 | 87 | tag ("VARRAY_DATA_GENERIC"))) vdt_generic[1]; |
6de9cd9a | 88 | PTR GTY ((length ("%0.num_elements"), skip (""), |
c981d223 | 89 | tag ("VARRAY_DATA_GENERIC_NOGC"))) vdt_generic_nogc[1]; |
e2500fed | 90 | char *GTY ((length ("%0.num_elements"), |
c981d223 | 91 | tag ("VARRAY_DATA_CPTR"))) vdt_cptr[1]; |
bcda12f4 | 92 | rtx GTY ((length ("%0.num_elements"), |
c981d223 | 93 | tag ("VARRAY_DATA_RTX"))) vdt_rtx[1]; |
bcda12f4 | 94 | rtvec GTY ((length ("%0.num_elements"), |
c981d223 | 95 | tag ("VARRAY_DATA_RTVEC"))) vdt_rtvec[1]; |
bcda12f4 | 96 | tree GTY ((length ("%0.num_elements"), |
c981d223 | 97 | tag ("VARRAY_DATA_TREE"))) vdt_tree[1]; |
e2500fed | 98 | struct bitmap_head_def *GTY ((length ("%0.num_elements"), |
c981d223 | 99 | tag ("VARRAY_DATA_BITMAP"))) vdt_bitmap[1]; |
1431042e | 100 | struct reg_info_def *GTY ((length ("%0.num_elements"), skip, |
c981d223 | 101 | tag ("VARRAY_DATA_REG"))) vdt_reg[1]; |
1431042e | 102 | struct basic_block_def *GTY ((length ("%0.num_elements"), skip, |
c981d223 | 103 | tag ("VARRAY_DATA_BB"))) vdt_bb[1]; |
e2500fed | 104 | struct elt_list *GTY ((length ("%0.num_elements"), |
c981d223 | 105 | tag ("VARRAY_DATA_TE"))) vdt_te[1]; |
6de9cd9a | 106 | struct edge_def *GTY ((length ("%0.num_elements"), |
c981d223 | 107 | tag ("VARRAY_DATA_EDGE"))) vdt_e[1]; |
6de9cd9a | 108 | tree *GTY ((length ("%0.num_elements"), skip (""), |
c981d223 | 109 | tag ("VARRAY_DATA_TREE_PTR"))) vdt_tp[1]; |
848205e6 MM |
110 | } varray_data; |
111 | ||
112 | /* Virtual array of pointers header. */ | |
d1b38208 | 113 | struct GTY(()) varray_head_tag { |
e2500fed GK |
114 | size_t num_elements; /* Maximum element number allocated. */ |
115 | size_t elements_used; /* The number of elements used, if | |
a6873608 | 116 | using VARRAY_PUSH/VARRAY_POP. */ |
e2500fed | 117 | enum varray_data_enum type; /* The kind of elements in the varray. */ |
848205e6 | 118 | const char *name; /* name of the varray for reporting errors */ |
2e1eedd6 | 119 | varray_data GTY ((desc ("%0.type"))) data; /* The data elements follow, |
e2500fed GK |
120 | must be last. */ |
121 | }; | |
122 | typedef struct varray_head_tag *varray_type; | |
848205e6 MM |
123 | |
124 | /* Allocate a virtual array with NUM elements, each of which is SIZE bytes | |
125 | long, named NAME. Array elements are zeroed. */ | |
2e1eedd6 | 126 | extern varray_type varray_init (size_t, enum varray_data_enum, const char *); |
848205e6 MM |
127 | |
128 | #define VARRAY_CHAR_INIT(va, num, name) \ | |
e2500fed | 129 | va = varray_init (num, VARRAY_DATA_C, name) |
848205e6 MM |
130 | |
131 | #define VARRAY_UCHAR_INIT(va, num, name) \ | |
e2500fed | 132 | va = varray_init (num, VARRAY_DATA_UC, name) |
848205e6 MM |
133 | |
134 | #define VARRAY_SHORT_INIT(va, num, name) \ | |
e2500fed | 135 | va = varray_init (num, VARRAY_DATA_S, name) |
848205e6 MM |
136 | |
137 | #define VARRAY_USHORT_INIT(va, num, name) \ | |
e2500fed | 138 | va = varray_init (num, VARRAY_DATA_US, name) |
848205e6 MM |
139 | |
140 | #define VARRAY_INT_INIT(va, num, name) \ | |
e2500fed | 141 | va = varray_init (num, VARRAY_DATA_I, name) |
848205e6 MM |
142 | |
143 | #define VARRAY_UINT_INIT(va, num, name) \ | |
e2500fed | 144 | va = varray_init (num, VARRAY_DATA_U, name) |
848205e6 MM |
145 | |
146 | #define VARRAY_LONG_INIT(va, num, name) \ | |
e2500fed | 147 | va = varray_init (num, VARRAY_DATA_L, name) |
848205e6 MM |
148 | |
149 | #define VARRAY_ULONG_INIT(va, num, name) \ | |
e2500fed | 150 | va = varray_init (num, VARRAY_DATA_UL, name) |
848205e6 MM |
151 | |
152 | #define VARRAY_WIDE_INT_INIT(va, num, name) \ | |
e2500fed | 153 | va = varray_init (num, VARRAY_DATA_HINT, name) |
848205e6 MM |
154 | |
155 | #define VARRAY_UWIDE_INT_INIT(va, num, name) \ | |
e2500fed | 156 | va = varray_init (num, VARRAY_DATA_UHINT, name) |
848205e6 MM |
157 | |
158 | #define VARRAY_GENERIC_PTR_INIT(va, num, name) \ | |
e2500fed | 159 | va = varray_init (num, VARRAY_DATA_GENERIC, name) |
848205e6 | 160 | |
6de9cd9a DN |
161 | #define VARRAY_GENERIC_PTR_NOGC_INIT(va, num, name) \ |
162 | va = varray_init (num, VARRAY_DATA_GENERIC_NOGC, name) | |
163 | ||
848205e6 | 164 | #define VARRAY_CHAR_PTR_INIT(va, num, name) \ |
e2500fed | 165 | va = varray_init (num, VARRAY_DATA_CPTR, name) |
848205e6 MM |
166 | |
167 | #define VARRAY_RTX_INIT(va, num, name) \ | |
e2500fed | 168 | va = varray_init (num, VARRAY_DATA_RTX, name) |
848205e6 MM |
169 | |
170 | #define VARRAY_RTVEC_INIT(va, num, name) \ | |
e2500fed | 171 | va = varray_init (num, VARRAY_DATA_RTVEC, name) |
848205e6 MM |
172 | |
173 | #define VARRAY_TREE_INIT(va, num, name) \ | |
e2500fed | 174 | va = varray_init (num, VARRAY_DATA_TREE, name) |
848205e6 MM |
175 | |
176 | #define VARRAY_BITMAP_INIT(va, num, name) \ | |
e2500fed | 177 | va = varray_init (num, VARRAY_DATA_BITMAP, name) |
848205e6 MM |
178 | |
179 | #define VARRAY_REG_INIT(va, num, name) \ | |
e2500fed | 180 | va = varray_init (num, VARRAY_DATA_REG, name) |
848205e6 | 181 | |
e881bb1b | 182 | #define VARRAY_BB_INIT(va, num, name) \ |
e2500fed | 183 | va = varray_init (num, VARRAY_DATA_BB, name) |
e881bb1b | 184 | |
eab5c70a | 185 | #define VARRAY_ELT_LIST_INIT(va, num, name) \ |
e2500fed | 186 | va = varray_init (num, VARRAY_DATA_TE, name) |
eab5c70a | 187 | |
6de9cd9a DN |
188 | #define VARRAY_EDGE_INIT(va, num, name) \ |
189 | va = varray_init (num, VARRAY_DATA_EDGE, name) | |
190 | ||
191 | #define VARRAY_TREE_PTR_INIT(va, num, name) \ | |
192 | va = varray_init (num, VARRAY_DATA_TREE_PTR, name) | |
193 | ||
848205e6 MM |
194 | /* Free up memory allocated by the virtual array, but do not free any of the |
195 | elements involved. */ | |
804a4e13 | 196 | #define VARRAY_FREE(vp) \ |
e9d1b155 | 197 | do { if (vp) { free (vp); vp = (varray_type) 0; } } while (0) |
848205e6 MM |
198 | |
199 | /* Grow/shrink the virtual array VA to N elements. */ | |
2e1eedd6 | 200 | extern varray_type varray_grow (varray_type, size_t); |
848205e6 MM |
201 | |
202 | #define VARRAY_GROW(VA, N) ((VA) = varray_grow (VA, N)) | |
203 | ||
c68da89c KR |
204 | #define VARRAY_SIZE(VA) ((VA)->num_elements) |
205 | ||
4c85a96d RH |
206 | #define VARRAY_ACTIVE_SIZE(VA) ((VA)->elements_used) |
207 | #define VARRAY_POP_ALL(VA) ((VA)->elements_used = 0) | |
208 | ||
e2500fed GK |
209 | #define VARRAY_CLEAR(VA) varray_clear(VA) |
210 | ||
2e1eedd6 | 211 | extern void varray_clear (varray_type); |
9b57b627 JH |
212 | extern void dump_varray_statistics (void); |
213 | ||
987009bf | 214 | /* Check for VARRAY_xxx macros being in bound. */ |
6c9821b7 | 215 | #if defined ENABLE_CHECKING && (GCC_VERSION >= 2007) |
2e1eedd6 AJ |
216 | extern void varray_check_failed (varray_type, size_t, const char *, int, |
217 | const char *) ATTRIBUTE_NORETURN; | |
12a08b40 ZW |
218 | extern void varray_underflow (varray_type, const char *, int, const char *) |
219 | ATTRIBUTE_NORETURN; | |
8784fdcd | 220 | #define VARRAY_CHECK(VA, N, T) __extension__ \ |
d8750784 | 221 | (*({ varray_type const _va = (VA); \ |
2e1eedd6 | 222 | const size_t _n = (N); \ |
987009bf | 223 | if (_n >= _va->num_elements) \ |
fbfc1192 | 224 | varray_check_failed (_va, _n, __FILE__, __LINE__, __FUNCTION__); \ |
987009bf | 225 | &_va->data.T[_n]; })) |
12a08b40 ZW |
226 | |
227 | #define VARRAY_POP(VA) do { \ | |
228 | varray_type const _va = (VA); \ | |
229 | if (_va->elements_used == 0) \ | |
230 | varray_underflow (_va, __FILE__, __LINE__, __FUNCTION__); \ | |
231 | else \ | |
232 | _va->elements_used--; \ | |
233 | } while (0) | |
234 | ||
848205e6 | 235 | #else |
987009bf | 236 | #define VARRAY_CHECK(VA, N, T) ((VA)->data.T[N]) |
12a08b40 ZW |
237 | /* Pop the top element of VA. */ |
238 | #define VARRAY_POP(VA) do { ((VA)->elements_used--); } while (0) | |
848205e6 MM |
239 | #endif |
240 | ||
a6873608 MM |
241 | /* Push X onto VA. T is the name of the field in varray_data |
242 | corresponding to the type of X. */ | |
41077ce4 KH |
243 | #define VARRAY_PUSH(VA, T, X) \ |
244 | do \ | |
a6873608 MM |
245 | { \ |
246 | if ((VA)->elements_used >= (VA)->num_elements) \ | |
247 | VARRAY_GROW ((VA), 2 * (VA)->num_elements); \ | |
248 | (VA)->data.T[(VA)->elements_used++] = (X); \ | |
249 | } \ | |
250 | while (0) | |
251 | ||
c981d223 GDR |
252 | #define VARRAY_CHAR(VA, N) VARRAY_CHECK (VA, N, vdt_c) |
253 | #define VARRAY_UCHAR(VA, N) VARRAY_CHECK (VA, N, vdt_uc) | |
254 | #define VARRAY_SHORT(VA, N) VARRAY_CHECK (VA, N, vdt_s) | |
255 | #define VARRAY_USHORT(VA, N) VARRAY_CHECK (VA, N, vdt_us) | |
256 | #define VARRAY_INT(VA, N) VARRAY_CHECK (VA, N, vdt_i) | |
257 | #define VARRAY_UINT(VA, N) VARRAY_CHECK (VA, N, vdt_u) | |
258 | #define VARRAY_LONG(VA, N) VARRAY_CHECK (VA, N, vdt_l) | |
259 | #define VARRAY_ULONG(VA, N) VARRAY_CHECK (VA, N, vdt_ul) | |
260 | #define VARRAY_WIDE_INT(VA, N) VARRAY_CHECK (VA, N, vdt_hint) | |
261 | #define VARRAY_UWIDE_INT(VA, N) VARRAY_CHECK (VA, N, vdt_uhint) | |
262 | #define VARRAY_GENERIC_PTR(VA,N) VARRAY_CHECK (VA, N, vdt_generic) | |
263 | #define VARRAY_GENERIC_PTR_NOGC(VA,N) VARRAY_CHECK (VA, N, vdt_generic_nogc) | |
264 | #define VARRAY_CHAR_PTR(VA,N) VARRAY_CHECK (VA, N, vdt_cptr) | |
265 | #define VARRAY_RTX(VA, N) VARRAY_CHECK (VA, N, vdt_rtx) | |
266 | #define VARRAY_RTVEC(VA, N) VARRAY_CHECK (VA, N, vdt_rtvec) | |
267 | #define VARRAY_TREE(VA, N) VARRAY_CHECK (VA, N, vdt_tree) | |
268 | #define VARRAY_BITMAP(VA, N) VARRAY_CHECK (VA, N, vdt_bitmap) | |
269 | #define VARRAY_REG(VA, N) VARRAY_CHECK (VA, N, vdt_reg) | |
270 | #define VARRAY_BB(VA, N) VARRAY_CHECK (VA, N, vdt_bb) | |
271 | #define VARRAY_ELT_LIST(VA, N) VARRAY_CHECK (VA, N, vdt_te) | |
272 | #define VARRAY_EDGE(VA, N) VARRAY_CHECK (VA, N, vdt_e) | |
273 | #define VARRAY_TREE_PTR(VA, N) VARRAY_CHECK (VA, N, vdt_tp) | |
848205e6 | 274 | |
a6873608 | 275 | /* Push a new element on the end of VA, extending it if necessary. */ |
c981d223 GDR |
276 | #define VARRAY_PUSH_CHAR(VA, X) VARRAY_PUSH (VA, vdt_c, X) |
277 | #define VARRAY_PUSH_UCHAR(VA, X) VARRAY_PUSH (VA, vdt_uc, X) | |
278 | #define VARRAY_PUSH_SHORT(VA, X) VARRAY_PUSH (VA, vdt_s, X) | |
279 | #define VARRAY_PUSH_USHORT(VA, X) VARRAY_PUSH (VA, vdt_us, X) | |
280 | #define VARRAY_PUSH_INT(VA, X) VARRAY_PUSH (VA, vdt_i, X) | |
281 | #define VARRAY_PUSH_UINT(VA, X) VARRAY_PUSH (VA, vdt_u, X) | |
282 | #define VARRAY_PUSH_LONG(VA, X) VARRAY_PUSH (VA, vdt_l, X) | |
283 | #define VARRAY_PUSH_ULONG(VA, X) VARRAY_PUSH (VA, vdt_ul, X) | |
284 | #define VARRAY_PUSH_WIDE_INT(VA, X) VARRAY_PUSH (VA, vdt_hint, X) | |
285 | #define VARRAY_PUSH_UWIDE_INT(VA, X) VARRAY_PUSH (VA, vdt_uhint, X) | |
286 | #define VARRAY_PUSH_GENERIC_PTR(VA, X) VARRAY_PUSH (VA, vdt_generic, X) | |
287 | #define VARRAY_PUSH_GENERIC_PTR_NOGC(VA, X) VARRAY_PUSH (VA, vdt_generic_nogc, X) | |
288 | #define VARRAY_PUSH_CHAR_PTR(VA, X) VARRAY_PUSH (VA, vdt_cptr, X) | |
289 | #define VARRAY_PUSH_RTX(VA, X) VARRAY_PUSH (VA, vdt_rtx, X) | |
290 | #define VARRAY_PUSH_RTVEC(VA, X) VARRAY_PUSH (VA, vdt_rtvec, X) | |
291 | #define VARRAY_PUSH_TREE(VA, X) VARRAY_PUSH (VA, vdt_tree, X) | |
292 | #define VARRAY_PUSH_BITMAP(VA, X) VARRAY_PUSH (VA, vdt_bitmap, X) | |
293 | #define VARRAY_PUSH_REG(VA, X) VARRAY_PUSH (VA, vdt_reg, X) | |
294 | #define VARRAY_PUSH_BB(VA, X) VARRAY_PUSH (VA, vdt_bb, X) | |
295 | #define VARRAY_PUSH_EDGE(VA, X) VARRAY_PUSH (VA, vdt_e, X) | |
296 | #define VARRAY_PUSH_TREE_PTR(VA, X) VARRAY_PUSH (VA, vdt_tp, X) | |
a6873608 MM |
297 | |
298 | /* Return the last element of VA. */ | |
12a08b40 ZW |
299 | #define VARRAY_TOP(VA, T) VARRAY_CHECK(VA, (VA)->elements_used - 1, T) |
300 | ||
c981d223 GDR |
301 | #define VARRAY_TOP_CHAR(VA) VARRAY_TOP (VA, vdt_c) |
302 | #define VARRAY_TOP_UCHAR(VA) VARRAY_TOP (VA, vdt_uc) | |
303 | #define VARRAY_TOP_SHORT(VA) VARRAY_TOP (VA, vdt_s) | |
304 | #define VARRAY_TOP_USHORT(VA) VARRAY_TOP (VA, vdt_us) | |
305 | #define VARRAY_TOP_INT(VA) VARRAY_TOP (VA, vdt_i) | |
306 | #define VARRAY_TOP_UINT(VA) VARRAY_TOP (VA, vdt_u) | |
307 | #define VARRAY_TOP_LONG(VA) VARRAY_TOP (VA, vdt_l) | |
308 | #define VARRAY_TOP_ULONG(VA) VARRAY_TOP (VA, vdt_ul) | |
309 | #define VARRAY_TOP_WIDE_INT(VA) VARRAY_TOP (VA, vdt_hint) | |
310 | #define VARRAY_TOP_UWIDE_INT(VA) VARRAY_TOP (VA, vdt_uhint) | |
311 | #define VARRAY_TOP_GENERIC_PTR(VA) VARRAY_TOP (VA, vdt_generic) | |
312 | #define VARRAY_TOP_GENERIC_PTR_NOGC(VA) VARRAY_TOP (VA, vdt_generic_nogc) | |
313 | #define VARRAY_TOP_CHAR_PTR(VA) VARRAY_TOP (VA, vdt_cptr) | |
314 | #define VARRAY_TOP_RTX(VA) VARRAY_TOP (VA, vdt_rtx) | |
315 | #define VARRAY_TOP_RTVEC(VA) VARRAY_TOP (VA, vdt_rtvec) | |
316 | #define VARRAY_TOP_TREE(VA) VARRAY_TOP (VA, vdt_tree) | |
317 | #define VARRAY_TOP_BITMAP(VA) VARRAY_TOP (VA, vdt_bitmap) | |
318 | #define VARRAY_TOP_REG(VA) VARRAY_TOP (VA, vdt_reg) | |
319 | #define VARRAY_TOP_BB(VA) VARRAY_TOP (VA, vdt_bb) | |
320 | #define VARRAY_TOP_EDGE(VA) VARRAY_TOP (VA, vdt_e) | |
321 | #define VARRAY_TOP_TREE_PTR(VA) VARRAY_TOP (VA, vdt_tp) | |
a6873608 | 322 | |
88657302 | 323 | #endif /* ! GCC_VARRAY_H */ |