?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2007-03-01 Paul Brook <paul@codesourcery.com>
[official-gcc.git] / gcc / vec.h
blob3bc6566a1bb6678c2ed4fcf72ea9983eca09e2e1
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 #if !IN_GENGTYPE
421 /* Reallocate an array of elements with prefix. */
422 extern void *vec_gc_p_reserve (void *, int MEM_STAT_DECL);
423 extern void *vec_gc_p_reserve_exact (void *, int MEM_STAT_DECL);
424 extern void *vec_gc_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL);
425 extern void *vec_gc_o_reserve_exact (void *, int, size_t, size_t
426 MEM_STAT_DECL);
427 extern void ggc_free (void *);
428 #define vec_gc_free(V) ggc_free (V)
429 extern void *vec_heap_p_reserve (void *, int MEM_STAT_DECL);
430 extern void *vec_heap_p_reserve_exact (void *, int MEM_STAT_DECL);
431 extern void *vec_heap_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL);
432 extern void *vec_heap_o_reserve_exact (void *, int, size_t, size_t
433 MEM_STAT_DECL);
434 #define vec_heap_free(V) free (V)
435
436 #if ENABLE_CHECKING
437 #define VEC_CHECK_INFO ,__FILE__,__LINE__,__FUNCTION__
438 #define VEC_CHECK_DECL ,const char *file_,unsigned line_,const char *function_
439 #define VEC_CHECK_PASS ,file_,line_,function_
440
441 #define VEC_ASSERT(EXPR,OP,T,A) \
442 (void)((EXPR) ? 0 : (VEC_ASSERT_FAIL(OP,VEC(T,A)), 0))
443
444 extern void vec_assert_fail (const char *, const char * VEC_CHECK_DECL)
445 ATTRIBUTE_NORETURN;
446 #define VEC_ASSERT_FAIL(OP,VEC) vec_assert_fail (OP,#VEC VEC_CHECK_PASS)
447 #else
448 #define VEC_CHECK_INFO
449 #define VEC_CHECK_DECL
450 #define VEC_CHECK_PASS
451 #define VEC_ASSERT(EXPR,OP,T,A) (void)(EXPR)
452 #endif
453
454 #define VEC(T,A) VEC_##T##_##A
455 #define VEC_OP(T,A,OP) VEC_##T##_##A##_##OP
456 #else /* IN_GENGTYPE */
457 #define VEC(T,A) VEC_ T _ A
458 #define VEC_STRINGIFY(X) VEC_STRINGIFY_(X)
459 #define VEC_STRINGIFY_(X) #X
460 #undef GTY
461 #endif /* IN_GENGTYPE */
462
463 /* Base of vector type, not user visible. */
464 #define VEC_T(T,B) \
465 typedef struct VEC(T,B) \
466 { \
467 unsigned num; \
468 unsigned alloc; \
469 T vec[1]; \
470 } VEC(T,B)
471
472 #define VEC_T_GTY(T,B) \
473 typedef struct VEC(T,B) GTY(()) \
474 { \
475 unsigned num; \
476 unsigned alloc; \
477 T GTY ((length ("%h.num"))) vec[1]; \
478 } VEC(T,B)
479
480 /* Derived vector type, user visible. */
481 #define VEC_TA_GTY(T,B,A,GTY) \
482 typedef struct VEC(T,A) GTY \
483 { \
484 VEC(T,B) base; \
485 } VEC(T,A)
486
487 /* Convert to base type. */
488 #define VEC_BASE(P) ((P) ? &(P)->base : 0)
489
490 /* Vector of integer-like object. */
491 #if IN_GENGTYPE
492 {"DEF_VEC_I", VEC_STRINGIFY (VEC_T(#0,#1)) ";", "none"},
493 {"DEF_VEC_ALLOC_I", VEC_STRINGIFY (VEC_TA (#0,#1,#2,#3)) ";", NULL},
494 #else
495 #define DEF_VEC_I(T) \
496 static inline void VEC_OP (T,must_be,integral_type) (void) \
497 { \
498 (void)~(T)0; \
499 } \
500 \
501 VEC_T(T,base); \
502 VEC_TA_GTY(T,base,none,); \
503 DEF_VEC_FUNC_P(T) \
504 struct vec_swallow_trailing_semi
505 #define DEF_VEC_ALLOC_I(T,A) \
506 VEC_TA_GTY(T,base,A,); \
507 DEF_VEC_ALLOC_FUNC_I(T,A) \
508 struct vec_swallow_trailing_semi
509 #endif
510
511 /* Vector of pointer to object. */
512 #if IN_GENGTYPE
513 {"DEF_VEC_P", VEC_STRINGIFY (VEC_T_GTY(#0,#1)) ";", "none"},
514 {"DEF_VEC_ALLOC_P", VEC_STRINGIFY (VEC_TA_GTY (#0,#1,#2,#3)) ";", NULL},
515 #else
516 #define DEF_VEC_P(T) \
517 static inline void VEC_OP (T,must_be,pointer_type) (void) \
518 { \
519 (void)((T)1 == (void *)1); \
520 } \
521 \
522 VEC_T_GTY(T,base); \
523 VEC_TA_GTY(T,base,none,); \
524 DEF_VEC_FUNC_P(T) \
525 struct vec_swallow_trailing_semi
526 #define DEF_VEC_ALLOC_P(T,A) \
527 VEC_TA_GTY(T,base,A,); \
528 DEF_VEC_ALLOC_FUNC_P(T,A) \
529 struct vec_swallow_trailing_semi
530 #endif
531
532 #define DEF_VEC_FUNC_P(T) \
533 static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \
534 { \
535 return vec_ ? vec_->num : 0; \
536 } \
537 \
538 static inline T VEC_OP (T,base,last) \
539 (const VEC(T,base) *vec_ VEC_CHECK_DECL) \
540 { \
541 VEC_ASSERT (vec_ && vec_->num, "last", T, base); \
542 \
543 return vec_->vec[vec_->num - 1]; \
544 } \
545 \
546 static inline T VEC_OP (T,base,index) \
547 (const VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
548 { \
549 VEC_ASSERT (vec_ && ix_ < vec_->num, "index", T, base); \
550 \
551 return vec_->vec[ix_]; \
552 } \
553 \
554 static inline int VEC_OP (T,base,iterate) \
555 (const VEC(T,base) *vec_, unsigned ix_, T *ptr) \
556 { \
557 if (vec_ && ix_ < vec_->num) \
558 { \
559 *ptr = vec_->vec[ix_]; \
560 return 1; \
561 } \
562 else \
563 { \
564 *ptr = 0; \
565 return 0; \
566 } \
567 } \
568 \
569 static inline size_t VEC_OP (T,base,embedded_size) \
570 (int alloc_) \
571 { \
572 return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T); \
573 } \
574 \
575 static inline void VEC_OP (T,base,embedded_init) \
576 (VEC(T,base) *vec_, int alloc_) \
577 { \
578 vec_->num = 0; \
579 vec_->alloc = alloc_; \
580 } \
581 \
582 static inline int VEC_OP (T,base,space) \
583 (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \
584 { \
585 VEC_ASSERT (alloc_ >= 0, "space", T, base); \
586 return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_; \
587 } \
588 \
589 static inline T *VEC_OP (T,base,quick_push) \
590 (VEC(T,base) *vec_, T obj_ VEC_CHECK_DECL) \
591 { \
592 T *slot_; \
593 \
594 VEC_ASSERT (vec_->num < vec_->alloc, "push", T, base); \
595 slot_ = &vec_->vec[vec_->num++]; \
596 *slot_ = obj_; \
597 \
598 return slot_; \
599 } \
600 \
601 static inline T VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \
602 { \
603 T obj_; \
604 \
605 VEC_ASSERT (vec_->num, "pop", T, base); \
606 obj_ = vec_->vec[--vec_->num]; \
607 \
608 return obj_; \
609 } \
610 \
611 static inline void VEC_OP (T,base,truncate) \
612 (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \
613 { \
614 VEC_ASSERT (vec_ ? vec_->num >= size_ : !size_, "truncate", T, base); \
615 if (vec_) \
616 vec_->num = size_; \
617 } \
618 \
619 static inline T VEC_OP (T,base,replace) \
620 (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) \
621 { \
622 T old_obj_; \
623 \
624 VEC_ASSERT (ix_ < vec_->num, "replace", T, base); \
625 old_obj_ = vec_->vec[ix_]; \
626 vec_->vec[ix_] = obj_; \
627 \
628 return old_obj_; \
629 } \
630 \
631 static inline T *VEC_OP (T,base,quick_insert) \
632 (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) \
633 { \
634 T *slot_; \
635 \
636 VEC_ASSERT (vec_->num < vec_->alloc, "insert", T, base); \
637 VEC_ASSERT (ix_ <= vec_->num, "insert", T, base); \
638 slot_ = &vec_->vec[ix_]; \
639 memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \
640 *slot_ = obj_; \
641 \
642 return slot_; \
643 } \
644 \
645 static inline T VEC_OP (T,base,ordered_remove) \
646 (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
647 { \
648 T *slot_; \
649 T obj_; \
650 \
651 VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
652 slot_ = &vec_->vec[ix_]; \
653 obj_ = *slot_; \
654 memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); \
655 \
656 return obj_; \
657 } \
658 \
659 static inline T VEC_OP (T,base,unordered_remove) \
660 (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
661 { \
662 T *slot_; \
663 T obj_; \
664 \
665 VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
666 slot_ = &vec_->vec[ix_]; \
667 obj_ = *slot_; \
668 *slot_ = vec_->vec[--vec_->num]; \
669 \
670 return obj_; \
671 } \
672 \
673 static inline void VEC_OP (T,base,block_remove) \
674 (VEC(T,base) *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) \
675 { \
676 T *slot_; \
677 \
678 VEC_ASSERT (ix_ + len_ <= vec_->num, "block_remove", T, base); \
679 slot_ = &vec_->vec[ix_]; \
680 vec_->num -= len_; \
681 memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); \
682 } \
683 \
684 static inline T *VEC_OP (T,base,address) \
685 (VEC(T,base) *vec_) \
686 { \
687 return vec_ ? vec_->vec : 0; \
688 } \
689 \
690 static inline unsigned VEC_OP (T,base,lower_bound) \
691 (VEC(T,base) *vec_, const T obj_, \
692 bool (*lessthan_)(const T, const T) VEC_CHECK_DECL) \
693 { \
694 unsigned int len_ = VEC_OP (T,base, length) (vec_); \
695 unsigned int half_, middle_; \
696 unsigned int first_ = 0; \
697 while (len_ > 0) \
698 { \
699 T middle_elem_; \
700 half_ = len_ >> 1; \
701 middle_ = first_; \
702 middle_ += half_; \
703 middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \
704 if (lessthan_ (middle_elem_, obj_)) \
705 { \
706 first_ = middle_; \
707 ++first_; \
708 len_ = len_ - half_ - 1; \
709 } \
710 else \
711 len_ = half_; \
712 } \
713 return first_; \
714 }
715
716 #define DEF_VEC_ALLOC_FUNC_P(T,A) \
717 static inline VEC(T,A) *VEC_OP (T,A,alloc) \
718 (int alloc_ MEM_STAT_DECL) \
719 { \
720 return (VEC(T,A) *) vec_##A##_p_reserve_exact (NULL, alloc_ \
721 PASS_MEM_STAT); \
722 } \
723 \
724 static inline void VEC_OP (T,A,free) \
725 (VEC(T,A) **vec_) \
726 { \
727 if (*vec_) \
728 vec_##A##_free (*vec_); \
729 *vec_ = NULL; \
730 } \
731 \
732 static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \
733 { \
734 size_t len_ = vec_ ? vec_->num : 0; \
735 VEC (T,A) *new_vec_ = NULL; \
736 \
737 if (len_) \
738 { \
739 new_vec_ = (VEC (T,A) *)(vec_##A##_p_reserve_exact \
740 (NULL, len_ PASS_MEM_STAT)); \
741 \
742 new_vec_->base.num = len_; \
743 memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \
744 } \
745 return new_vec_; \
746 } \
747 \
748 static inline int VEC_OP (T,A,reserve) \
749 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
750 { \
751 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
752 VEC_CHECK_PASS); \
753 \
754 if (extend) \
755 *vec_ = (VEC(T,A) *) vec_##A##_p_reserve (*vec_, alloc_ PASS_MEM_STAT); \
756 \
757 return extend; \
758 } \
759 \
760 static inline int VEC_OP (T,A,reserve_exact) \
761 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
762 { \
763 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
764 VEC_CHECK_PASS); \
765 \
766 if (extend) \
767 *vec_ = (VEC(T,A) *) vec_##A##_p_reserve_exact (*vec_, alloc_ \
768 PASS_MEM_STAT); \
769 \
770 return extend; \
771 } \
772 \
773 static inline void VEC_OP (T,A,safe_grow) \
774 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
775 { \
776 VEC_ASSERT (size_ >= 0 \
777 && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \
778 "grow", T, A); \
779 VEC_OP (T,A,reserve_exact) (vec_, \
780 size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \
781 VEC_CHECK_PASS PASS_MEM_STAT); \
782 VEC_BASE (*vec_)->num = size_; \
783 } \
784 \
785 static inline void VEC_OP (T,A,safe_grow_cleared) \
786 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
787 { \
788 int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \
789 VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \
790 memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \
791 sizeof (T) * (size_ - oldsize)); \
792 } \
793 \
794 static inline T *VEC_OP (T,A,safe_push) \
795 (VEC(T,A) **vec_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
796 { \
797 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
798 \
799 return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \
800 } \
801 \
802 static inline T *VEC_OP (T,A,safe_insert) \
803 (VEC(T,A) **vec_, unsigned ix_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
804 { \
805 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
806 \
807 return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \
808 VEC_CHECK_PASS); \
809 }
810
811 /* Vector of object. */
812 #if IN_GENGTYPE
813 {"DEF_VEC_O", VEC_STRINGIFY (VEC_T_GTY(#0,#1)) ";", "none"},
814 {"DEF_VEC_ALLOC_O", VEC_STRINGIFY (VEC_TA_GTY(#0,#1,#2,#3)) ";", NULL},
815 #else
816 #define DEF_VEC_O(T) \
817 VEC_T_GTY(T,base); \
818 VEC_TA_GTY(T,base,none,); \
819 DEF_VEC_FUNC_O(T) \
820 struct vec_swallow_trailing_semi
821 #define DEF_VEC_ALLOC_O(T,A) \
822 VEC_TA_GTY(T,base,A,); \
823 DEF_VEC_ALLOC_FUNC_O(T,A) \
824 struct vec_swallow_trailing_semi
825 #endif
826
827 #define DEF_VEC_FUNC_O(T) \
828 static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \
829 { \
830 return vec_ ? vec_->num : 0; \
831 } \
832 \
833 static inline T *VEC_OP (T,base,last) (VEC(T,base) *vec_ VEC_CHECK_DECL) \
834 { \
835 VEC_ASSERT (vec_ && vec_->num, "last", T, base); \
836 \
837 return &vec_->vec[vec_->num - 1]; \
838 } \
839 \
840 static inline T *VEC_OP (T,base,index) \
841 (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
842 { \
843 VEC_ASSERT (vec_ && ix_ < vec_->num, "index", T, base); \
844 \
845 return &vec_->vec[ix_]; \
846 } \
847 \
848 static inline int VEC_OP (T,base,iterate) \
849 (VEC(T,base) *vec_, unsigned ix_, T **ptr) \
850 { \
851 if (vec_ && ix_ < vec_->num) \
852 { \
853 *ptr = &vec_->vec[ix_]; \
854 return 1; \
855 } \
856 else \
857 { \
858 *ptr = 0; \
859 return 0; \
860 } \
861 } \
862 \
863 static inline size_t VEC_OP (T,base,embedded_size) \
864 (int alloc_) \
865 { \
866 return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T); \
867 } \
868 \
869 static inline void VEC_OP (T,base,embedded_init) \
870 (VEC(T,base) *vec_, int alloc_) \
871 { \
872 vec_->num = 0; \
873 vec_->alloc = alloc_; \
874 } \
875 \
876 static inline int VEC_OP (T,base,space) \
877 (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \
878 { \
879 VEC_ASSERT (alloc_ >= 0, "space", T, base); \
880 return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_; \
881 } \
882 \
883 static inline T *VEC_OP (T,base,quick_push) \
884 (VEC(T,base) *vec_, const T *obj_ VEC_CHECK_DECL) \
885 { \
886 T *slot_; \
887 \
888 VEC_ASSERT (vec_->num < vec_->alloc, "push", T, base); \
889 slot_ = &vec_->vec[vec_->num++]; \
890 if (obj_) \
891 *slot_ = *obj_; \
892 \
893 return slot_; \
894 } \
895 \
896 static inline void VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \
897 { \
898 VEC_ASSERT (vec_->num, "pop", T, base); \
899 --vec_->num; \
900 } \
901 \
902 static inline void VEC_OP (T,base,truncate) \
903 (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \
904 { \
905 VEC_ASSERT (vec_ ? vec_->num >= size_ : !size_, "truncate", T, base); \
906 if (vec_) \
907 vec_->num = size_; \
908 } \
909 \
910 static inline T *VEC_OP (T,base,replace) \
911 (VEC(T,base) *vec_, unsigned ix_, const T *obj_ VEC_CHECK_DECL) \
912 { \
913 T *slot_; \
914 \
915 VEC_ASSERT (ix_ < vec_->num, "replace", T, base); \
916 slot_ = &vec_->vec[ix_]; \
917 if (obj_) \
918 *slot_ = *obj_; \
919 \
920 return slot_; \
921 } \
922 \
923 static inline T *VEC_OP (T,base,quick_insert) \
924 (VEC(T,base) *vec_, unsigned ix_, const T *obj_ VEC_CHECK_DECL) \
925 { \
926 T *slot_; \
927 \
928 VEC_ASSERT (vec_->num < vec_->alloc, "insert", T, base); \
929 VEC_ASSERT (ix_ <= vec_->num, "insert", T, base); \
930 slot_ = &vec_->vec[ix_]; \
931 memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \
932 if (obj_) \
933 *slot_ = *obj_; \
934 \
935 return slot_; \
936 } \
937 \
938 static inline void VEC_OP (T,base,ordered_remove) \
939 (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
940 { \
941 T *slot_; \
942 \
943 VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
944 slot_ = &vec_->vec[ix_]; \
945 memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); \
946 } \
947 \
948 static inline void VEC_OP (T,base,unordered_remove) \
949 (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
950 { \
951 VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
952 vec_->vec[ix_] = vec_->vec[--vec_->num]; \
953 } \
954 \
955 static inline void VEC_OP (T,base,block_remove) \
956 (VEC(T,base) *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) \
957 { \
958 T *slot_; \
959 \
960 VEC_ASSERT (ix_ + len_ <= vec_->num, "block_remove", T, base); \
961 slot_ = &vec_->vec[ix_]; \
962 vec_->num -= len_; \
963 memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); \
964 } \
965 \
966 static inline T *VEC_OP (T,base,address) \
967 (VEC(T,base) *vec_) \
968 { \
969 return vec_ ? vec_->vec : 0; \
970 } \
971 \
972 static inline unsigned VEC_OP (T,base,lower_bound) \
973 (VEC(T,base) *vec_, const T *obj_, \
974 bool (*lessthan_)(const T *, const T *) VEC_CHECK_DECL) \
975 { \
976 unsigned int len_ = VEC_OP (T, base, length) (vec_); \
977 unsigned int half_, middle_; \
978 unsigned int first_ = 0; \
979 while (len_ > 0) \
980 { \
981 T *middle_elem_; \
982 half_ = len_ >> 1; \
983 middle_ = first_; \
984 middle_ += half_; \
985 middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \
986 if (lessthan_ (middle_elem_, obj_)) \
987 { \
988 first_ = middle_; \
989 ++first_; \
990 len_ = len_ - half_ - 1; \
991 } \
992 else \
993 len_ = half_; \
994 } \
995 return first_; \
996 }
997
998 #define DEF_VEC_ALLOC_FUNC_O(T,A) \
999 static inline VEC(T,A) *VEC_OP (T,A,alloc) \
1000 (int alloc_ MEM_STAT_DECL) \
1001 { \
1002 return (VEC(T,A) *) vec_##A##_o_reserve_exact (NULL, alloc_, \
1003 offsetof (VEC(T,A),base.vec), \
1004 sizeof (T) \
1005 PASS_MEM_STAT); \
1006 } \
1007 \
1008 static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \
1009 { \
1010 size_t len_ = vec_ ? vec_->num : 0; \
1011 VEC (T,A) *new_vec_ = NULL; \
1012 \
1013 if (len_) \
1014 { \
1015 new_vec_ = (VEC (T,A) *)(vec_##A##_o_reserve_exact \
1016 (NULL, len_, \
1017 offsetof (VEC(T,A),base.vec), sizeof (T) \
1018 PASS_MEM_STAT)); \
1019 \
1020 new_vec_->base.num = len_; \
1021 memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \
1022 } \
1023 return new_vec_; \
1024 } \
1025 \
1026 static inline void VEC_OP (T,A,free) \
1027 (VEC(T,A) **vec_) \
1028 { \
1029 if (*vec_) \
1030 vec_##A##_free (*vec_); \
1031 *vec_ = NULL; \
1032 } \
1033 \
1034 static inline int VEC_OP (T,A,reserve) \
1035 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
1036 { \
1037 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
1038 VEC_CHECK_PASS); \
1039 \
1040 if (extend) \
1041 *vec_ = (VEC(T,A) *) vec_##A##_o_reserve (*vec_, alloc_, \
1042 offsetof (VEC(T,A),base.vec),\
1043 sizeof (T) \
1044 PASS_MEM_STAT); \
1045 \
1046 return extend; \
1047 } \
1048 \
1049 static inline int VEC_OP (T,A,reserve_exact) \
1050 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
1051 { \
1052 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
1053 VEC_CHECK_PASS); \
1054 \
1055 if (extend) \
1056 *vec_ = (VEC(T,A) *) vec_##A##_o_reserve_exact \
1057 (*vec_, alloc_, \
1058 offsetof (VEC(T,A),base.vec), \
1059 sizeof (T) PASS_MEM_STAT); \
1060 \
1061 return extend; \
1062 } \
1063 \
1064 static inline void VEC_OP (T,A,safe_grow) \
1065 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
1066 { \
1067 VEC_ASSERT (size_ >= 0 \
1068 && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \
1069 "grow", T, A); \
1070 VEC_OP (T,A,reserve_exact) (vec_, \
1071 size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \
1072 VEC_CHECK_PASS PASS_MEM_STAT); \
1073 VEC_BASE (*vec_)->num = size_; \
1074 } \
1075 \
1076 static inline void VEC_OP (T,A,safe_grow_cleared) \
1077 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
1078 { \
1079 int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \
1080 VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \
1081 memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \
1082 sizeof (T) * (size_ - oldsize)); \
1083 } \
1084 \
1085 static inline T *VEC_OP (T,A,safe_push) \
1086 (VEC(T,A) **vec_, const T *obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
1087 { \
1088 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
1089 \
1090 return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \
1091 } \
1092 \
1093 static inline T *VEC_OP (T,A,safe_insert) \
1094 (VEC(T,A) **vec_, unsigned ix_, const T *obj_ \
1095 VEC_CHECK_DECL MEM_STAT_DECL) \
1096 { \
1097 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
1098 \
1099 return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \
1100 VEC_CHECK_PASS); \
1101 }
1102
1103 #define DEF_VEC_ALLOC_FUNC_I(T,A) \
1104 static inline VEC(T,A) *VEC_OP (T,A,alloc) \
1105 (int alloc_ MEM_STAT_DECL) \
1106 { \
1107 return (VEC(T,A) *) vec_##A##_o_reserve_exact \
1108 (NULL, alloc_, offsetof (VEC(T,A),base.vec), \
1109 sizeof (T) PASS_MEM_STAT); \
1110 } \
1111 \
1112 static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \
1113 { \
1114 size_t len_ = vec_ ? vec_->num : 0; \
1115 VEC (T,A) *new_vec_ = NULL; \
1116 \
1117 if (len_) \
1118 { \
1119 new_vec_ = (VEC (T,A) *)(vec_##A##_o_reserve_exact \
1120 (NULL, len_, \
1121 offsetof (VEC(T,A),base.vec), sizeof (T) \
1122 PASS_MEM_STAT)); \
1123 \
1124 new_vec_->base.num = len_; \
1125 memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \
1126 } \
1127 return new_vec_; \
1128 } \
1129 \
1130 static inline void VEC_OP (T,A,free) \
1131 (VEC(T,A) **vec_) \
1132 { \
1133 if (*vec_) \
1134 vec_##A##_free (*vec_); \
1135 *vec_ = NULL; \
1136 } \
1137 \
1138 static inline int VEC_OP (T,A,reserve) \
1139 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
1140 { \
1141 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
1142 VEC_CHECK_PASS); \
1143 \
1144 if (extend) \
1145 *vec_ = (VEC(T,A) *) vec_##A##_o_reserve (*vec_, alloc_, \
1146 offsetof (VEC(T,A),base.vec),\
1147 sizeof (T) \
1148 PASS_MEM_STAT); \
1149 \
1150 return extend; \
1151 } \
1152 \
1153 static inline int VEC_OP (T,A,reserve_exact) \
1154 (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \
1155 { \
1156 int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \
1157 VEC_CHECK_PASS); \
1158 \
1159 if (extend) \
1160 *vec_ = (VEC(T,A) *) vec_##A##_o_reserve_exact \
1161 (*vec_, alloc_, offsetof (VEC(T,A),base.vec), \
1162 sizeof (T) PASS_MEM_STAT); \
1163 \
1164 return extend; \
1165 } \
1166 \
1167 static inline void VEC_OP (T,A,safe_grow) \
1168 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
1169 { \
1170 VEC_ASSERT (size_ >= 0 \
1171 && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \
1172 "grow", T, A); \
1173 VEC_OP (T,A,reserve_exact) (vec_, \
1174 size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \
1175 VEC_CHECK_PASS PASS_MEM_STAT); \
1176 VEC_BASE (*vec_)->num = size_; \
1177 } \
1178 \
1179 static inline void VEC_OP (T,A,safe_grow_cleared) \
1180 (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \
1181 { \
1182 int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \
1183 VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \
1184 memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \
1185 sizeof (T) * (size_ - oldsize)); \
1186 } \
1187 \
1188 static inline T *VEC_OP (T,A,safe_push) \
1189 (VEC(T,A) **vec_, const T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
1190 { \
1191 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
1192 \
1193 return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \
1194 } \
1195 \
1196 static inline T *VEC_OP (T,A,safe_insert) \
1197 (VEC(T,A) **vec_, unsigned ix_, const T obj_ \
1198 VEC_CHECK_DECL MEM_STAT_DECL) \
1199 { \
1200 VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \
1201 \
1202 return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \
1203 VEC_CHECK_PASS); \
1204 }
1205
1206 #endif /* GCC_VEC_H */
Mirror of the offical gcc git repository hosted at gcc.gnu.org