?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated for libbid move.
[official-gcc.git] / gcc / vec.h
blobc8eabc99f8516522c64763b2abae24026c1959b2
1 /* Vector API for GNU compiler.
2 Copyright (C) 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Nathan Sidwell <nathan@codesourcery.com>
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 #ifndef GCC_VEC_H
23 #define GCC_VEC_H
24
25 /* The macros here implement a set of templated vector types and
26 associated interfaces. These templates are implemented with
27 macros, as we're not in C++ land. The interface functions are
28 typesafe and use static inline functions, sometimes backed by
29 out-of-line generic functions. The vectors are designed to
30 interoperate with the GTY machinery.
31
32 Because of the different behavior of structure objects, scalar
33 objects and of pointers, there are three flavors, one for each of
34 these variants. Both the structure object and pointer variants
35 pass pointers to objects around -- in the former case the pointers
36 are stored into the vector and in the latter case the pointers are
37 dereferenced and the objects copied into the vector. The scalar
38 object variant is suitable for int-like objects, and the vector
39 elements are returned by value.
40
41 There are both 'index' and 'iterate' accessors. The iterator
42 returns a boolean iteration condition and updates the iteration
43 variable passed by reference. Because the iterator will be
44 inlined, the address-of can be optimized away.
45
46 The vectors are implemented using the trailing array idiom, thus
47 they are not resizeable without changing the address of the vector
48 object itself. This means you cannot have variables or fields of
49 vector type -- always use a pointer to a vector. The one exception
50 is the final field of a structure, which could be a vector type.
51 You will have to use the embedded_size & embedded_init calls to
52 create such objects, and they will probably not be resizeable (so
53 don't use the 'safe' allocation variants). The trailing array
54 idiom is used (rather than a pointer to an array of data), because,
55 if we allow NULL to also represent an empty vector, empty vectors
56 occupy minimal space in the structure containing them.
57
58 Each operation that increases the number of active elements is
59 available in 'quick' and 'safe' variants. The former presumes that
60 there is sufficient allocated space for the operation to succeed
61 (it dies if there is not). The latter will reallocate the
62 vector, if needed. Reallocation causes an exponential increase in
63 vector size. If you know you will be adding N elements, it would
64 be more efficient to use the reserve operation before adding the
65 elements with the 'quick' operation. This will ensure there are at
66 least as many elements as you ask for, it will exponentially
67 increase if there are too few spare slots. If you want reserve a
68 specific number of slots, but do not want the exponential increase
69 (for instance, you know this is the last allocation), use the
70 reserve_exact operation. You can also create a vector of a
71 specific size from the get go.
72
73 You should prefer the push and pop operations, as they append and
74 remove from the end of the vector. If you need to remove several
75 items in one go, use the truncate operation. The insert and remove
76 operations allow you to change elements in the middle of the
77 vector. There are two remove operations, one which preserves the
78 element ordering 'ordered_remove', and one which does not
79 'unordered_remove'. The latter function copies the end element
80 into the removed slot, rather than invoke a memmove operation. The
81 'lower_bound' function will determine where to place an item in the
82 array using insert that will maintain sorted order.
83
84 When a vector type is defined, first a non-memory managed version
85 is created. You can then define either or both garbage collected
86 and heap allocated versions. The allocation mechanism is specified
87 when the type is defined, and is therefore part of the type. If
88 you need both gc'd and heap allocated versions, you still must have
89 *exactly* one definition of the common non-memory managed base vector.
90
91 If you need to directly manipulate a vector, then the 'address'
92 accessor will return the address of the start of the vector. Also
93 the 'space' predicate will tell you whether there is spare capacity
94 in the vector. You will not normally need to use these two functions.
95
96 Vector types are defined using a DEF_VEC_{O,P,I}(TYPEDEF) macro, to
97 get the non-memory allocation version, and then a
98 DEF_VEC_ALLOC_{O,P,I}(TYPEDEF,ALLOC) macro to get memory managed
99 vectors. Variables of vector type are declared using a
100 VEC(TYPEDEF,ALLOC) macro. The ALLOC argument specifies the
101 allocation strategy, and can be either 'gc' or 'heap' for garbage
102 collected and heap allocated respectively. It can be 'none' to get
103 a vector that must be explicitly allocated (for instance as a
104 trailing array of another structure). The characters O, P and I
105 indicate whether TYPEDEF is a pointer (P), object (O) or integral
106 (I) type. Be careful to pick the correct one, as you'll get an
107 awkward and inefficient API if you use the wrong one. There is a
108 check, which results in a compile-time warning, for the P and I
109 versions, but there is no check for the O versions, as that is not
110 possible in plain C. Due to the way GTY works, you must annotate
111 any structures you wish to insert or reference from a vector with a
112 GTY(()) tag. You need to do this even if you never declare the GC
113 allocated variants.
114
115 An example of their use would be,
116
117 DEF_VEC_P(tree); // non-managed tree vector.
118 DEF_VEC_ALLOC_P(tree,gc); // gc'd vector of tree pointers. This must
119 // appear at file scope.
120
121 struct my_struct {
122 VEC(tree,gc) *v; // A (pointer to) a vector of tree pointers.
123 };
124
125 struct my_struct *s;
126
127 if (VEC_length(tree,s->v)) { we have some contents }
128 VEC_safe_push(tree,gc,s->v,decl); // append some decl onto the end
129 for (ix = 0; VEC_iterate(tree,s->v,ix,elt); ix++)
130 { do something with elt }
131
132 */
133
134 /* Macros to invoke API calls. A single macro works for both pointer
135 and object vectors, but the argument and return types might well be
136 different. In each macro, T is the typedef of the vector elements,
137 and A is the allocation strategy. The allocation strategy is only
138 present when it is required. Some of these macros pass the vector,
139 V, by reference (by taking its address), this is noted in the
140 descriptions. */
141
142 /* Length of vector
143 unsigned VEC_T_length(const VEC(T) *v);
144
145 Return the number of active elements in V. V can be NULL, in which
146 case zero is returned. */
147
148 #define VEC_length(T,V) (VEC_OP(T,base,length)(VEC_BASE(V)))
149
150
151 /* Check if vector is empty
152 int VEC_T_empty(const VEC(T) *v);
153
154 Return nonzero if V is an empty vector (or V is NULL), zero otherwise. */
155
156 #define VEC_empty(T,V) (VEC_length (T,V) == 0)
157
158
159 /* Get the final element of the vector.
160 T VEC_T_last(VEC(T) *v); // Integer
161 T VEC_T_last(VEC(T) *v); // Pointer
162 T *VEC_T_last(VEC(T) *v); // Object
163
164 Return the final element. V must not be empty. */
165
166 #define VEC_last(T,V) (VEC_OP(T,base,last)(VEC_BASE(V) VEC_CHECK_INFO))
167
168 /* Index into vector
169 T VEC_T_index(VEC(T) *v, unsigned ix); // Integer
170 T VEC_T_index(VEC(T) *v, unsigned ix); // Pointer
171 T *VEC_T_index(VEC(T) *v, unsigned ix); // Object
172
173 Return the IX'th element. If IX must be in the domain of V. */
174
175 #define VEC_index(T,V,I) (VEC_OP(T,base,index)(VEC_BASE(V),I VEC_CHECK_INFO))
176
177 /* Iterate over vector
178 int VEC_T_iterate(VEC(T) *v, unsigned ix, T &ptr); // Integer
179 int VEC_T_iterate(VEC(T) *v, unsigned ix, T &ptr); // Pointer
180 int VEC_T_iterate(VEC(T) *v, unsigned ix, T *&ptr); // Object
181
182 Return iteration condition and update PTR to point to the IX'th
183 element. At the end of iteration, sets PTR to NULL. Use this to
184 iterate over the elements of a vector as follows,
185
186 for (ix = 0; VEC_iterate(T,v,ix,ptr); ix++)
187 continue; */
188
189 #define VEC_iterate(T,V,I,P) (VEC_OP(T,base,iterate)(VEC_BASE(V),I,&(P)))
190
191 /* Allocate new vector.
192 VEC(T,A) *VEC_T_A_alloc(int reserve);
193
194 Allocate a new vector with space for RESERVE objects. If RESERVE
195 is zero, NO vector is created. */
196
197 #define VEC_alloc(T,A,N) (VEC_OP(T,A,alloc)(N MEM_STAT_INFO))
198
199 /* Free a vector.
200 void VEC_T_A_free(VEC(T,A) *&);
201
202 Free a vector and set it to NULL. */
203
204 #define VEC_free(T,A,V) (VEC_OP(T,A,free)(&V))
205
206 /* Use these to determine the required size and initialization of a
207 vector embedded within another structure (as the final member).
208
209 size_t VEC_T_embedded_size(int reserve);
210 void VEC_T_embedded_init(VEC(T) *v, int reserve);
211
212 These allow the caller to perform the memory allocation. */
213
214 #define VEC_embedded_size(T,N) (VEC_OP(T,base,embedded_size)(N))
215 #define VEC_embedded_init(T,O,N) (VEC_OP(T,base,embedded_init)(VEC_BASE(O),N))
216
217 /* Copy a vector.
218 VEC(T,A) *VEC_T_A_copy(VEC(T) *);
219
220 Copy the live elements of a vector into a new vector. The new and
221 old vectors need not be allocated by the same mechanism. */
222
223 #define VEC_copy(T,A,V) (VEC_OP(T,A,copy)(VEC_BASE(V) MEM_STAT_INFO))
224
225 /* Determine if a vector has additional capacity.
226
227 int VEC_T_space (VEC(T) *v,int reserve)
228
229 If V has space for RESERVE additional entries, return nonzero. You
230 usually only need to use this if you are doing your own vector
231 reallocation, for instance on an embedded vector. This returns
232 nonzero in exactly the same circumstances that VEC_T_reserve
233 will. */
234
235 #define VEC_space(T,V,R) \
236 (VEC_OP(T,base,space)(VEC_BASE(V),R VEC_CHECK_INFO))
237
238 /* Reserve space.
239 int VEC_T_A_reserve(VEC(T,A) *&v, int reserve);
240
241 Ensure that V has at least RESERVE slots available. This will
242 create additional headroom. Note this can cause V to be
243 reallocated. Returns nonzero iff reallocation actually
244 occurred. */
245
246 #define VEC_reserve(T,A,V,R) \
247 (VEC_OP(T,A,reserve)(&(V),R VEC_CHECK_INFO MEM_STAT_INFO))
248
249 /* Reserve space exactly.
250 int VEC_T_A_reserve_exact(VEC(T,A) *&v, int reserve);
251
252 Ensure that V has at least RESERVE slots available. This will not
253 create additional headroom. Note this can cause V to be
254 reallocated. Returns nonzero iff reallocation actually
255 occurred. */
256
257 #define VEC_reserve_exact(T,A,V,R) \
258 (VEC_OP(T,A,reserve_exact)(&(V),R VEC_CHECK_INFO MEM_STAT_INFO))
259
260 /* Push object with no reallocation
261 T *VEC_T_quick_push (VEC(T) *v, T obj); // Integer
262 T *VEC_T_quick_push (VEC(T) *v, T obj); // Pointer
263 T *VEC_T_quick_push (VEC(T) *v, T *obj); // Object
264
265 Push a new element onto the end, returns a pointer to the slot
266 filled in. For object vectors, the new value can be NULL, in which
267 case NO initialization is performed. There must
268 be sufficient space in the vector. */
269
270 #define VEC_quick_push(T,V,O) \
271 (VEC_OP(T,base,quick_push)(VEC_BASE(V),O VEC_CHECK_INFO))
272
273 /* Push object with reallocation
274 T *VEC_T_A_safe_push (VEC(T,A) *&v, T obj); // Integer
275 T *VEC_T_A_safe_push (VEC(T,A) *&v, T obj); // Pointer
276 T *VEC_T_A_safe_push (VEC(T,A) *&v, T *obj); // Object
277
278 Push a new element onto the end, returns a pointer to the slot
279 filled in. For object vectors, the new value can be NULL, in which
280 case NO initialization is performed. Reallocates V, if needed. */
281
282 #define VEC_safe_push(T,A,V,O) \
283 (VEC_OP(T,A,safe_push)(&(V),O VEC_CHECK_INFO MEM_STAT_INFO))
284
285 /* Pop element off end
286 T VEC_T_pop (VEC(T) *v); // Integer
287 T VEC_T_pop (VEC(T) *v); // Pointer
288 void VEC_T_pop (VEC(T) *v); // Object
289
290 Pop the last element off the end. Returns the element popped, for
291 pointer vectors. */
292
293 #define VEC_pop(T,V) (VEC_OP(T,base,pop)(VEC_BASE(V) VEC_CHECK_INFO))
294
295 /* Truncate to specific length
296 void VEC_T_truncate (VEC(T) *v, unsigned len);
297
298 Set the length as specified. The new length must be less than or
299 equal to the current length. This is an O(1) operation. */
300
301 #define VEC_truncate(T,V,I) \
302 (VEC_OP(T,base,truncate)(VEC_BASE(V),I VEC_CHECK_INFO))
303
304 /* Grow to a specific length.
305 void VEC_T_A_safe_grow (VEC(T,A) *&v, int len);
306
307 Grow the vector to a specific length. The LEN must be as
308 long or longer than the current length. The new elements are
309 uninitialized. */
310
311 #define VEC_safe_grow(T,A,V,I) \
312 (VEC_OP(T,A,safe_grow)(&(V),I VEC_CHECK_INFO MEM_STAT_INFO))
313
314 /* Grow to a specific length.
315 void VEC_T_A_safe_grow_cleared (VEC(T,A) *&v, int len);
316
317 Grow the vector to a specific length. The LEN must be as
318 long or longer than the current length. The new elements are
319 initialized to zero. */
320
321 #define VEC_safe_grow_cleared(T,A,V,I) \
322 (VEC_OP(T,A,safe_grow_cleared)(&(V),I VEC_CHECK_INFO MEM_STAT_INFO))
323
324 /* Replace element
325 T VEC_T_replace (VEC(T) *v, unsigned ix, T val); // Integer
326 T VEC_T_replace (VEC(T) *v, unsigned ix, T val); // Pointer
327 T *VEC_T_replace (VEC(T) *v, unsigned ix, T *val); // Object
328
329 Replace the IXth element of V with a new value, VAL. For pointer
330 vectors returns the original value. For object vectors returns a
331 pointer to the new value. For object vectors the new value can be
332 NULL, in which case no overwriting of the slot is actually
333 performed. */
334
335 #define VEC_replace(T,V,I,O) \
336 (VEC_OP(T,base,replace)(VEC_BASE(V),I,O VEC_CHECK_INFO))
337
338 /* Insert object with no reallocation
339 T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Integer
340 T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Pointer
341 T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T *val); // Object
342
343 Insert an element, VAL, at the IXth position of V. Return a pointer
344 to the slot created. For vectors of object, the new value can be
345 NULL, in which case no initialization of the inserted slot takes
346 place. There must be sufficient space. */
347
348 #define VEC_quick_insert(T,V,I,O) \
349 (VEC_OP(T,base,quick_insert)(VEC_BASE(V),I,O VEC_CHECK_INFO))
350
351 /* Insert object with reallocation
352 T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T val); // Integer
353 T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T val); // Pointer
354 T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T *val); // Object
355
356 Insert an element, VAL, at the IXth position of V. Return a pointer
357 to the slot created. For vectors of object, the new value can be
358 NULL, in which case no initialization of the inserted slot takes
359 place. Reallocate V, if necessary. */
360
361 #define VEC_safe_insert(T,A,V,I,O) \
362 (VEC_OP(T,A,safe_insert)(&(V),I,O VEC_CHECK_INFO MEM_STAT_INFO))
363
364 /* Remove element retaining order
365 T VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Integer
366 T VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Pointer
367 void VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Object
368
369 Remove an element from the IXth position of V. Ordering of
370 remaining elements is preserved. For pointer vectors returns the
371 removed object. This is an O(N) operation due to a memmove. */
372
373 #define VEC_ordered_remove(T,V,I) \
374 (VEC_OP(T,base,ordered_remove)(VEC_BASE(V),I VEC_CHECK_INFO))
375
376 /* Remove element destroying order
377 T VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Integer
378 T VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Pointer
379 void VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Object
380
381 Remove an element from the IXth position of V. Ordering of
382 remaining elements is destroyed. For pointer vectors returns the
383 removed object. This is an O(1) operation. */
384
385 #define VEC_unordered_remove(T,V,I) \
386 (VEC_OP(T,base,unordered_remove)(VEC_BASE(V),I VEC_CHECK_INFO))
387
388 /* Remove a block of elements
389 void VEC_T_block_remove (VEC(T) *v, unsigned ix, unsigned len);
390
391 Remove LEN elements starting at the IXth. Ordering is retained.
392 This is an O(1) operation. */
393
394 #define VEC_block_remove(T,V,I,L) \
395 (VEC_OP(T,base,block_remove)(VEC_BASE(V),I,L VEC_CHECK_INFO))
396
397 /* Get the address of the array of elements
398 T *VEC_T_address (VEC(T) v)
399
400 If you need to directly manipulate the array (for instance, you
401 want to feed it to qsort), use this accessor. */
402
403 #define VEC_address(T,V) (VEC_OP(T,base,address)(VEC_BASE(V)))
404
405 /* Find the first index in the vector not less than the object.
406 unsigned VEC_T_lower_bound (VEC(T) *v, const T val,
407 bool (*lessthan) (const T, const T)); // Integer
408 unsigned VEC_T_lower_bound (VEC(T) *v, const T val,
409 bool (*lessthan) (const T, const T)); // Pointer
410 unsigned VEC_T_lower_bound (VEC(T) *v, const T *val,
411 bool (*lessthan) (const T*, const T*)); // Object
412
413 Find the first position in which VAL could be inserted without
414 changing the ordering of V. LESSTHAN is a function that returns
415 true if the first argument is strictly less than the second. */
416
417 #define VEC_lower_bound(T,V,O,LT) \
418 (VEC_OP(T,base,lower_bound)(VEC_BASE(V),O,LT VEC_CHECK_INFO))
419
420 /* Reallocate an array of elements with prefix. */
421 extern void *vec_gc_p_reserve (void *, int MEM_STAT_DECL);
422 extern void *vec_gc_p_reserve_exact (void *, int MEM_STAT_DECL);
423 extern void *vec_gc_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL);
424 extern void *vec_gc_o_reserve_exact (void *, int, size_t, size_t
425 MEM_STAT_DECL);
426 extern void ggc_free (void *);
427 #define vec_gc_free(V) ggc_free (V)
428 extern void *vec_heap_p_reserve (void *, int MEM_STAT_DECL);
429 extern void *vec_heap_p_reserve_exact (void *, int MEM_STAT_DECL);
430 extern void *vec_heap_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL);
431 extern void *vec_heap_o_reserve_exact (void *, int, size_t, size_t
432 MEM_STAT_DECL);
433 #define vec_heap_free(V) free (V)
434
435 #if ENABLE_CHECKING
436 #define VEC_CHECK_INFO ,__FILE__,__LINE__,__FUNCTION__
437 #define VEC_CHECK_DECL ,const char *file_,unsigned line_,const char *function_
438 #define VEC_CHECK_PASS ,file_,line_,function_
439
440 #define VEC_ASSERT(EXPR,OP,T,A) \
441 (void)((EXPR) ? 0 : (VEC_ASSERT_FAIL(OP,VEC(T,A)), 0))
442
443 extern void vec_assert_fail (const char *, const char * VEC_CHECK_DECL)
444 ATTRIBUTE_NORETURN;
445 #define VEC_ASSERT_FAIL(OP,VEC) vec_assert_fail (OP,#VEC VEC_CHECK_PASS)
446 #else
447 #define VEC_CHECK_INFO
448 #define VEC_CHECK_DECL
449 #define VEC_CHECK_PASS
450 #define VEC_ASSERT(EXPR,OP,T,A) (void)(EXPR)
451 #endif
452
453 /* Note: gengtype has hardwired knowledge of the expansions of the
454 VEC, DEF_VEC_*, and DEF_VEC_ALLOC_* macros. If you change the
455 expansions of these macros you may need to change gengtype too. */
456
457 #define VEC(T,A) VEC_##T##_##A
458 #define VEC_OP(T,A,OP) VEC_##T##_##A##_##OP
459
460 /* Base of vector type, not user visible. */
461 #define VEC_T(T,B) \
462 typedef struct VEC(T,B) \
463 { \
464 unsigned num; \
465 unsigned alloc; \
466 T vec[1]; \
467 } VEC(T,B)
468
469 #define VEC_T_GTY(T,B) \
470 typedef struct VEC(T,B) GTY(()) \
471 { \
472 unsigned num; \
473 unsigned alloc; \
474 T GTY ((length ("%h.num"))) vec[1]; \
475 } VEC(T,B)
476
477 /* Derived vector type, user visible. */
478 #define VEC_TA_GTY(T,B,A,GTY) \
479 typedef struct VEC(T,A) GTY \
480 { \
481 VEC(T,B) base; \
482 } VEC(T,A)
483
484 /* Convert to base type. */
485 #define VEC_BASE(P) ((P) ? &(P)->base : 0)
486
487 /* Vector of integer-like object. */
488 #define DEF_VEC_I(T) \
489 static inline void VEC_OP (T,must_be,integral_type) (void) \
490 { \
491 (void)~(T)0; \
492 } \
493 \
494 VEC_T(T,base); \
495 VEC_TA_GTY(T,base,none,); \
496 DEF_VEC_FUNC_P(T) \
497 struct vec_swallow_trailing_semi
498 #define DEF_VEC_ALLOC_I(T,A) \
499 VEC_TA_GTY(T,base,A,); \
500 DEF_VEC_ALLOC_FUNC_I(T,A) \
501 struct vec_swallow_trailing_semi
502
503 /* Vector of pointer to object. */
504 #define DEF_VEC_P(T) \
505 static inline void VEC_OP (T,must_be,pointer_type) (void) \
506 { \
507 (void)((T)1 == (void *)1); \
508 } \
509 \
510 VEC_T_GTY(T,base); \
511 VEC_TA_GTY(T,base,none,); \
512 DEF_VEC_FUNC_P(T) \
513 struct vec_swallow_trailing_semi
514 #define DEF_VEC_ALLOC_P(T,A) \
515 VEC_TA_GTY(T,base,A,); \
516 DEF_VEC_ALLOC_FUNC_P(T,A) \
517 struct vec_swallow_trailing_semi
518
519 #define DEF_VEC_FUNC_P(T) \
520 static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \
521 { \
522 return vec_ ? vec_->num : 0; \
523 } \
524 \
525 static inline T VEC_OP (T,base,last) \
526 (const VEC(T,base) *vec_ VEC_CHECK_DECL) \
527 { \
528 VEC_ASSERT (vec_ && vec_->num, "last", T, base); \
529 \
530 return vec_->vec[vec_->num - 1]; \
531 } \
532 \
533 static inline T VEC_OP (T,base,index) \
534 (const VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
535 { \
536 VEC_ASSERT (vec_ && ix_ < vec_->num, "index", T, base); \
537 \
538 return vec_->vec[ix_]; \
539 } \
540 \
541 static inline int VEC_OP (T,base,iterate) \
542 (const VEC(T,base) *vec_, unsigned ix_, T *ptr) \
543 { \
544 if (vec_ && ix_ < vec_->num) \
545 { \
546 *ptr = vec_->vec[ix_]; \
547 return 1; \
548 } \
549 else \
550 { \
551 *ptr = 0; \
552 return 0; \
553 } \
554 } \
555 \
556 static inline size_t VEC_OP (T,base,embedded_size) \
557 (int alloc_) \
558 { \
559 return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T); \
560 } \
561 \
562 static inline void VEC_OP (T,base,embedded_init) \
563 (VEC(T,base) *vec_, int alloc_) \
564 { \
565 vec_->num = 0; \
566 vec_->alloc = alloc_; \
567 } \
568 \
569 static inline int VEC_OP (T,base,space) \
570 (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \
571 { \
572 VEC_ASSERT (alloc_ >= 0, "space", T, base); \
573 return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_; \
574 } \
575 \
576 static inline T *VEC_OP (T,base,quick_push) \
577 (VEC(T,base) *vec_, T obj_ VEC_CHECK_DECL) \
578 { \
579 T *slot_; \
580 \
581 VEC_ASSERT (vec_->num < vec_->alloc, "push", T, base); \
582 slot_ = &vec_->vec[vec_->num++]; \
583 *slot_ = obj_; \
584 \
585 return slot_; \
586 } \
587 \
588 static inline T VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \
589 { \
590 T obj_; \
591 \
592 VEC_ASSERT (vec_->num, "pop", T, base); \
593 obj_ = vec_->vec[--vec_->num]; \
594 \
595 return obj_; \
596 } \
597 \
598 static inline void VEC_OP (T,base,truncate) \
599 (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \
600 { \
601 VEC_ASSERT (vec_ ? vec_->num >= size_ : !size_, "truncate", T, base); \
602 if (vec_) \
603 vec_->num = size_; \
604 } \
605 \
606 static inline T VEC_OP (T,base,replace) \
607 (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) \
608 { \
609 T old_obj_; \
610 \
611 VEC_ASSERT (ix_ < vec_->num, "replace", T, base); \
612 old_obj_ = vec_->vec[ix_]; \
613 vec_->vec[ix_] = obj_; \
614 \
615 return old_obj_; \
616 } \
617 \
618 static inline T *VEC_OP (T,base,quick_insert) \
619 (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) \
620 { \
621 T *slot_; \
622 \
623 VEC_ASSERT (vec_->num < vec_->alloc, "insert", T, base); \
624 VEC_ASSERT (ix_ <= vec_->num, "insert", T, base); \
625 slot_ = &vec_->vec[ix_]; \
626 memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \
627 *slot_ = obj_; \
628 \
629 return slot_; \
630 } \
631 \
632 static inline T VEC_OP (T,base,ordered_remove) \
633 (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
634 { \
635 T *slot_; \
636 T obj_; \
637 \
638 VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
639 slot_ = &vec_->vec[ix_]; \
640 obj_ = *slot_; \
641 memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); \
642 \
643 return obj_; \
644 } \
645 \
646 static inline T VEC_OP (T,base,unordered_remove) \
647 (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
648 { \
649 T *slot_; \
650 T obj_; \
651 \
652 VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
653 slot_ = &vec_->vec[ix_]; \
654 obj_ = *slot_; \
655 *slot_ = vec_->vec[--vec_->num]; \
656 \
657 return obj_; \
658 } \
659 \
660 static inline void VEC_OP (T,base,block_remove) \
661 (VEC(T,base) *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) \
662 { \
663 T *slot_; \
664 \
665 VEC_ASSERT (ix_ + len_ <= vec_->num, "block_remove", T, base); \
666 slot_ = &vec_->vec[ix_]; \
667 vec_->num -= len_; \
668 memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); \
669 } \
670 \
671 static inline T *VEC_OP (T,base,address) \
672 (VEC(T,base) *vec_) \
673 { \
674 return vec_ ? vec_->vec : 0; \
675 } \
676 \
677 static inline unsigned VEC_OP (T,base,lower_bound) \
678 (VEC(T,base) *vec_, const T obj_, \
679 bool (*lessthan_)(const T, const T) VEC_CHECK_DECL) \
680 { \
681 unsigned int len_ = VEC_OP (T,base, length) (vec_); \
682 unsigned int half_, middle_; \
683 unsigned int first_ = 0; \
684 while (len_ > 0) \
685 { \
686 T middle_elem_; \
687 half_ = len_ >> 1; \
688 middle_ = first_; \
689 middle_ += half_; \
690 middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \
691 if (lessthan_ (middle_elem_, obj_)) \
692 { \
693 first_ = middle_; \
694 ++first_; \
695 len_ = len_ - half_ - 1; \
696 } \
697 else \
698 len_ = half_; \
699 } \
700 return first_; \
701 }
702
703 #define DEF_VEC_ALLOC_FUNC_P(T,A) \
704 static inline VEC(T,A) *VEC_OP (T,A,alloc) \
705 (int alloc_ MEM_STAT_DECL) \
706 { \
707 return (VEC(T,A) *) vec_##A##_p_reserve_exact (NULL, alloc_ \
708 PASS_MEM_STAT); \
709 } \
710 \
711 static inline void VEC_OP (T,A,free) \
712 (VEC(T,A) **vec_) \
713 { \
714 if (*vec_) \
715 vec_##A##_free (*vec_); \
716 *vec_ = NULL; \
717 } \
718 \
719 static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \
720 { \
721 size_t len_ = vec_ ? vec_->num : 0; \
722 VEC (T,A) *new_vec_ = NULL; \
723 \
724 if (len_) \
725 { \
726 new_vec_ = (VEC (T,A) *)(vec_##A##_p_reserve_exact \
727 (NULL, len_ PASS_MEM_STAT)); \
728 \
729 new_vec_->base.num = len_; \
730 memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \
731 } \
732 return new_vec_; \
733 } \
734 \
735 static inline int VEC_OP (T,A,reserve) \
736 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
737 { \
738 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
739 VEC_CHECK_PASS); \
740 \
741 if (extend) \
742 *vec_ = (VEC(T,A) *) vec_##A##_p_reserve (*vec_, alloc_ PASS_MEM_STAT); \
743 \
744 return extend; \
745 } \
746 \
747 static inline int VEC_OP (T,A,reserve_exact) \
748 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
749 { \
750 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
751 VEC_CHECK_PASS); \
752 \
753 if (extend) \
754 *vec_ = (VEC(T,A) *) vec_##A##_p_reserve_exact (*vec_, alloc_ \
755 PASS_MEM_STAT); \
756 \
757 return extend; \
758 } \
759 \
760 static inline void VEC_OP (T,A,safe_grow) \
761 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
762 { \
763 VEC_ASSERT (size_ >= 0 \
764 && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \
765 "grow", T, A); \
766 VEC_OP (T,A,reserve_exact) (vec_, \
767 size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \
768 VEC_CHECK_PASS PASS_MEM_STAT); \
769 VEC_BASE (*vec_)->num = size_; \
770 } \
771 \
772 static inline void VEC_OP (T,A,safe_grow_cleared) \
773 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
774 { \
775 int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \
776 VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \
777 memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \
778 sizeof (T) * (size_ - oldsize)); \
779 } \
780 \
781 static inline T *VEC_OP (T,A,safe_push) \
782 (VEC(T,A) **vec_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
783 { \
784 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
785 \
786 return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \
787 } \
788 \
789 static inline T *VEC_OP (T,A,safe_insert) \
790 (VEC(T,A) **vec_, unsigned ix_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
791 { \
792 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
793 \
794 return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \
795 VEC_CHECK_PASS); \
796 }
797
798 /* Vector of object. */
799 #define DEF_VEC_O(T) \
800 VEC_T_GTY(T,base); \
801 VEC_TA_GTY(T,base,none,); \
802 DEF_VEC_FUNC_O(T) \
803 struct vec_swallow_trailing_semi
804 #define DEF_VEC_ALLOC_O(T,A) \
805 VEC_TA_GTY(T,base,A,); \
806 DEF_VEC_ALLOC_FUNC_O(T,A) \
807 struct vec_swallow_trailing_semi
808
809 #define DEF_VEC_FUNC_O(T) \
810 static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \
811 { \
812 return vec_ ? vec_->num : 0; \
813 } \
814 \
815 static inline T *VEC_OP (T,base,last) (VEC(T,base) *vec_ VEC_CHECK_DECL) \
816 { \
817 VEC_ASSERT (vec_ && vec_->num, "last", T, base); \
818 \
819 return &vec_->vec[vec_->num - 1]; \
820 } \
821 \
822 static inline T *VEC_OP (T,base,index) \
823 (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
824 { \
825 VEC_ASSERT (vec_ && ix_ < vec_->num, "index", T, base); \
826 \
827 return &vec_->vec[ix_]; \
828 } \
829 \
830 static inline int VEC_OP (T,base,iterate) \
831 (VEC(T,base) *vec_, unsigned ix_, T **ptr) \
832 { \
833 if (vec_ && ix_ < vec_->num) \
834 { \
835 *ptr = &vec_->vec[ix_]; \
836 return 1; \
837 } \
838 else \
839 { \
840 *ptr = 0; \
841 return 0; \
842 } \
843 } \
844 \
845 static inline size_t VEC_OP (T,base,embedded_size) \
846 (int alloc_) \
847 { \
848 return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T); \
849 } \
850 \
851 static inline void VEC_OP (T,base,embedded_init) \
852 (VEC(T,base) *vec_, int alloc_) \
853 { \
854 vec_->num = 0; \
855 vec_->alloc = alloc_; \
856 } \
857 \
858 static inline int VEC_OP (T,base,space) \
859 (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \
860 { \
861 VEC_ASSERT (alloc_ >= 0, "space", T, base); \
862 return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_; \
863 } \
864 \
865 static inline T *VEC_OP (T,base,quick_push) \
866 (VEC(T,base) *vec_, const T *obj_ VEC_CHECK_DECL) \
867 { \
868 T *slot_; \
869 \
870 VEC_ASSERT (vec_->num < vec_->alloc, "push", T, base); \
871 slot_ = &vec_->vec[vec_->num++]; \
872 if (obj_) \
873 *slot_ = *obj_; \
874 \
875 return slot_; \
876 } \
877 \
878 static inline void VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \
879 { \
880 VEC_ASSERT (vec_->num, "pop", T, base); \
881 --vec_->num; \
882 } \
883 \
884 static inline void VEC_OP (T,base,truncate) \
885 (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \
886 { \
887 VEC_ASSERT (vec_ ? vec_->num >= size_ : !size_, "truncate", T, base); \
888 if (vec_) \
889 vec_->num = size_; \
890 } \
891 \
892 static inline T *VEC_OP (T,base,replace) \
893 (VEC(T,base) *vec_, unsigned ix_, const T *obj_ VEC_CHECK_DECL) \
894 { \
895 T *slot_; \
896 \
897 VEC_ASSERT (ix_ < vec_->num, "replace", T, base); \
898 slot_ = &vec_->vec[ix_]; \
899 if (obj_) \
900 *slot_ = *obj_; \
901 \
902 return slot_; \
903 } \
904 \
905 static inline T *VEC_OP (T,base,quick_insert) \
906 (VEC(T,base) *vec_, unsigned ix_, const T *obj_ VEC_CHECK_DECL) \
907 { \
908 T *slot_; \
909 \
910 VEC_ASSERT (vec_->num < vec_->alloc, "insert", T, base); \
911 VEC_ASSERT (ix_ <= vec_->num, "insert", T, base); \
912 slot_ = &vec_->vec[ix_]; \
913 memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \
914 if (obj_) \
915 *slot_ = *obj_; \
916 \
917 return slot_; \
918 } \
919 \
920 static inline void VEC_OP (T,base,ordered_remove) \
921 (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
922 { \
923 T *slot_; \
924 \
925 VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
926 slot_ = &vec_->vec[ix_]; \
927 memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); \
928 } \
929 \
930 static inline void VEC_OP (T,base,unordered_remove) \
931 (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
932 { \
933 VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
934 vec_->vec[ix_] = vec_->vec[--vec_->num]; \
935 } \
936 \
937 static inline void VEC_OP (T,base,block_remove) \
938 (VEC(T,base) *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) \
939 { \
940 T *slot_; \
941 \
942 VEC_ASSERT (ix_ + len_ <= vec_->num, "block_remove", T, base); \
943 slot_ = &vec_->vec[ix_]; \
944 vec_->num -= len_; \
945 memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); \
946 } \
947 \
948 static inline T *VEC_OP (T,base,address) \
949 (VEC(T,base) *vec_) \
950 { \
951 return vec_ ? vec_->vec : 0; \
952 } \
953 \
954 static inline unsigned VEC_OP (T,base,lower_bound) \
955 (VEC(T,base) *vec_, const T *obj_, \
956 bool (*lessthan_)(const T *, const T *) VEC_CHECK_DECL) \
957 { \
958 unsigned int len_ = VEC_OP (T, base, length) (vec_); \
959 unsigned int half_, middle_; \
960 unsigned int first_ = 0; \
961 while (len_ > 0) \
962 { \
963 T *middle_elem_; \
964 half_ = len_ >> 1; \
965 middle_ = first_; \
966 middle_ += half_; \
967 middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \
968 if (lessthan_ (middle_elem_, obj_)) \
969 { \
970 first_ = middle_; \
971 ++first_; \
972 len_ = len_ - half_ - 1; \
973 } \
974 else \
975 len_ = half_; \
976 } \
977 return first_; \
978 }
979
980 #define DEF_VEC_ALLOC_FUNC_O(T,A) \
981 static inline VEC(T,A) *VEC_OP (T,A,alloc) \
982 (int alloc_ MEM_STAT_DECL) \
983 { \
984 return (VEC(T,A) *) vec_##A##_o_reserve_exact (NULL, alloc_, \
985 offsetof (VEC(T,A),base.vec), \
986 sizeof (T) \
987 PASS_MEM_STAT); \
988 } \
989 \
990 static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \
991 { \
992 size_t len_ = vec_ ? vec_->num : 0; \
993 VEC (T,A) *new_vec_ = NULL; \
994 \
995 if (len_) \
996 { \
997 new_vec_ = (VEC (T,A) *)(vec_##A##_o_reserve_exact \
998 (NULL, len_, \
999 offsetof (VEC(T,A),base.vec), sizeof (T) \
1000 PASS_MEM_STAT)); \
1001 \
1002 new_vec_->base.num = len_; \
1003 memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \
1004 } \
1005 return new_vec_; \
1006 } \
1007 \
1008 static inline void VEC_OP (T,A,free) \
1009 (VEC(T,A) **vec_) \
1010 { \
1011 if (*vec_) \
1012 vec_##A##_free (*vec_); \
1013 *vec_ = NULL; \
1014 } \
1015 \
1016 static inline int VEC_OP (T,A,reserve) \
1017 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
1018 { \
1019 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
1020 VEC_CHECK_PASS); \
1021 \
1022 if (extend) \
1023 *vec_ = (VEC(T,A) *) vec_##A##_o_reserve (*vec_, alloc_, \
1024 offsetof (VEC(T,A),base.vec),\
1025 sizeof (T) \
1026 PASS_MEM_STAT); \
1027 \
1028 return extend; \
1029 } \
1030 \
1031 static inline int VEC_OP (T,A,reserve_exact) \
1032 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
1033 { \
1034 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
1035 VEC_CHECK_PASS); \
1036 \
1037 if (extend) \
1038 *vec_ = (VEC(T,A) *) vec_##A##_o_reserve_exact \
1039 (*vec_, alloc_, \
1040 offsetof (VEC(T,A),base.vec), \
1041 sizeof (T) PASS_MEM_STAT); \
1042 \
1043 return extend; \
1044 } \
1045 \
1046 static inline void VEC_OP (T,A,safe_grow) \
1047 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
1048 { \
1049 VEC_ASSERT (size_ >= 0 \
1050 && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \
1051 "grow", T, A); \
1052 VEC_OP (T,A,reserve_exact) (vec_, \
1053 size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \
1054 VEC_CHECK_PASS PASS_MEM_STAT); \
1055 VEC_BASE (*vec_)->num = size_; \
1056 } \
1057 \
1058 static inline void VEC_OP (T,A,safe_grow_cleared) \
1059 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
1060 { \
1061 int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \
1062 VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \
1063 memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \
1064 sizeof (T) * (size_ - oldsize)); \
1065 } \
1066 \
1067 static inline T *VEC_OP (T,A,safe_push) \
1068 (VEC(T,A) **vec_, const T *obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
1069 { \
1070 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
1071 \
1072 return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \
1073 } \
1074 \
1075 static inline T *VEC_OP (T,A,safe_insert) \
1076 (VEC(T,A) **vec_, unsigned ix_, const T *obj_ \
1077 VEC_CHECK_DECL MEM_STAT_DECL) \
1078 { \
1079 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
1080 \
1081 return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \
1082 VEC_CHECK_PASS); \
1083 }
1084
1085 #define DEF_VEC_ALLOC_FUNC_I(T,A) \
1086 static inline VEC(T,A) *VEC_OP (T,A,alloc) \
1087 (int alloc_ MEM_STAT_DECL) \
1088 { \
1089 return (VEC(T,A) *) vec_##A##_o_reserve_exact \
1090 (NULL, alloc_, offsetof (VEC(T,A),base.vec), \
1091 sizeof (T) PASS_MEM_STAT); \
1092 } \
1093 \
1094 static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \
1095 { \
1096 size_t len_ = vec_ ? vec_->num : 0; \
1097 VEC (T,A) *new_vec_ = NULL; \
1098 \
1099 if (len_) \
1100 { \
1101 new_vec_ = (VEC (T,A) *)(vec_##A##_o_reserve_exact \
1102 (NULL, len_, \
1103 offsetof (VEC(T,A),base.vec), sizeof (T) \
1104 PASS_MEM_STAT)); \
1105 \
1106 new_vec_->base.num = len_; \
1107 memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \
1108 } \
1109 return new_vec_; \
1110 } \
1111 \
1112 static inline void VEC_OP (T,A,free) \
1113 (VEC(T,A) **vec_) \
1114 { \
1115 if (*vec_) \
1116 vec_##A##_free (*vec_); \
1117 *vec_ = NULL; \
1118 } \
1119 \
1120 static inline int VEC_OP (T,A,reserve) \
1121 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
1122 { \
1123 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
1124 VEC_CHECK_PASS); \
1125 \
1126 if (extend) \
1127 *vec_ = (VEC(T,A) *) vec_##A##_o_reserve (*vec_, alloc_, \
1128 offsetof (VEC(T,A),base.vec),\
1129 sizeof (T) \
1130 PASS_MEM_STAT); \
1131 \
1132 return extend; \
1133 } \
1134 \
1135 static inline int VEC_OP (T,A,reserve_exact) \
1136 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
1137 { \
1138 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
1139 VEC_CHECK_PASS); \
1140 \
1141 if (extend) \
1142 *vec_ = (VEC(T,A) *) vec_##A##_o_reserve_exact \
1143 (*vec_, alloc_, offsetof (VEC(T,A),base.vec), \
1144 sizeof (T) PASS_MEM_STAT); \
1145 \
1146 return extend; \
1147 } \
1148 \
1149 static inline void VEC_OP (T,A,safe_grow) \
1150 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
1151 { \
1152 VEC_ASSERT (size_ >= 0 \
1153 && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \
1154 "grow", T, A); \
1155 VEC_OP (T,A,reserve_exact) (vec_, \
1156 size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \
1157 VEC_CHECK_PASS PASS_MEM_STAT); \
1158 VEC_BASE (*vec_)->num = size_; \
1159 } \
1160 \
1161 static inline void VEC_OP (T,A,safe_grow_cleared) \
1162 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
1163 { \
1164 int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \
1165 VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \
1166 memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \
1167 sizeof (T) * (size_ - oldsize)); \
1168 } \
1169 \
1170 static inline T *VEC_OP (T,A,safe_push) \
1171 (VEC(T,A) **vec_, const T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
1172 { \
1173 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
1174 \
1175 return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \
1176 } \
1177 \
1178 static inline T *VEC_OP (T,A,safe_insert) \
1179 (VEC(T,A) **vec_, unsigned ix_, const T obj_ \
1180 VEC_CHECK_DECL MEM_STAT_DECL) \
1181 { \
1182 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
1183 \
1184 return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \
1185 VEC_CHECK_PASS); \
1186 }
1187
1188 #endif /* GCC_VEC_H */
Mirror of the offical gcc git repository hosted at gcc.gnu.org