* vec.h, vec.c: New, type safe vector API.

	* Makefile.in (OBJS-common): Add vec.o.
	(vec.o): New target.
	(gengtype-lex.o): Depend on vec.h.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@83769 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 567 insertions, 0 deletions

diff --git a/gcc/vec.h b/gcc/vec.h
new file mode 100644
index 00000000000..42d1c1f6310
--- /dev/null
+++ b/gcc/vec.h
@@ -0,0 +1,567 @@
+/* Vector API for GNU compiler.
+   Copyright (C) 2004 Free Software Foundation, Inc.
+   Contributed by Nathan Sidwell <nathan@codesourcery.com>
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING.  If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.  */
+
+#ifndef GCC_VEC_H
+#define GCC_VEC_H
+
+/* The macros here implement a set of templated vector types and
+   associated interfaces.  These templates are implemented with
+   macros, as we're not in C++ land.  The interface functions are
+   typesafe and use static inline functions, sometimes backed by
+   out-of-line generic functions.  The vectors are designed to
+   interoperate with the GTY machinery.
+
+   Because of the different behaviour of objects and of pointers to
+   objects, there are two flavours.  One to deal with a vector of
+   pointers to objects, and one to deal with a vector of objects
+   themselves.  Both of these pass pointers to objects around -- in
+   the former case the pointers are stored into the vector and in the
+   latter case the pointers are dereferenced and the objects copied
+   into the vector.  Therefore, when using a vector of pointers, the
+   objects pointed to must be long lived, but when dealing with a
+   vector of objects, the source objects need not be.
+
+   The vectors are implemented using the trailing array idiom, thus
+   they are not resizeable without changing the address of the vector
+   object itself.  This means you cannot have variables or fields of
+   vector type -- always use a pointer to a vector.  The one exception
+   is the final field of a structure, which could be a vector type.
+   You will have to use the embedded_alloc call to create such
+   objects, and they will probably not be resizeable (so don't use the
+   'safe' allocation variants).  The trailing array idiom is used
+   (rather than a pointer to an array of data), because, if we allow
+   NULL to also represent an empty vector, empty vectors occupy
+   minimal space in the structure containing them.
+
+   Each operation that increases the number of active elements is
+   available in 'quick' and 'safe' variants.  The former presumes that
+   there is sufficient allocated space for the operation to succeed
+   (it aborts if there is not).  The latter will reallocate the
+   vector, if needed.  Reallocation causes an exponential increase in
+   vector size.  If you know you will be adding N elements, it would
+   be more efficient to use the reserve operation before adding the
+   elements with the 'quick' operation.
+
+   You should prefer the push and pop operations, as they append and
+   remove from the end of the vector.  The insert and remove
+   operations allow you to change elements in the middle of the
+   vector.  There are two remove operations, one which preserves the
+   element ordering 'ordered_remove', and one which does not
+   'unordered_remove'.  The latter function copies the end element
+   into the removed slot, rather than invoke a memmove operation.
+   
+   Vector types are defined using a DEF_VEC_x(TYPEDEF) macro, and
+   variables of vector type are declared using a VEC(TYPEDEF)
+   macro. The 'x' letter indicates whether TYPEDEF is a pointer (P) or
+   object (O) type.
+
+   An example of their use would be,
+
+   DEF_VEC_P(tree);	// define a vector of tree pointers.  This must
+   			// appear at file scope.
+
+   struct my_struct {
+     VEC(tree) *v;      // A (pointer to) a vector of tree pointers.
+   };
+
+   struct my_struct *s;
+
+   if (VEC_length(tree,s)) { we have some contents }
+   VEC_safe_push(tree,s,decl); // append some decl onto the end
+   for (ix = 0; (t = VEC_iterate(tree,s,ix)); ix++)
+     { do something with t }
+
+*/
+
+/* Macros to invoke API calls.  A single macro works for both pointer
+   and object vectors, but the argument and return types might well be
+   different.  In each macro, TDEF is the typedef of the vector
+   elements.  Some of these macros pass the vector, V, by reference
+   (by taking its address), this is noted in the descriptions.  */
+
+/* Length of vector
+   size_t VEC_T_length(const VEC(T) *v);
+
+   Return the number of active elements in V.  V can be NULL, in which
+   case zero is returned.  */
+#define VEC_length(TDEF,V)		(VEC_OP(TDEF,length)(V))
+
+/* Get the final element of the vector.
+   T VEC_T_last(VEC(T) *v); // Pointer
+   T *VEC_T_last(VEC(T) *v); // Object
+
+   Return the final element.  If V is empty,  abort.  */
+#define VEC_last(TDEF,V)		(VEC_OP(TDEF,last)(V))
+
+/* Index into vector
+   T VEC_T_index(VEC(T) *v, size_t ix); // Pointer
+   T *VEC_T_index(VEC(T) *v, size_t ix); // Object
+
+   Return the IX'th element.  If IX is outside the domain of V,
+   abort.  */
+#define VEC_index(TDEF,V,I)		(VEC_OP(TDEF,index)(V,I))
+
+/* Iterate over vector
+   T VEC_T_index(VEC(T) *v, size_t ix); // Pointer
+   T *VEC_T_index(VEC(T) *v, size_t ix); // Object
+
+   Return the IX'th element or NULL. Use this to iterate over the
+   elements of a vector as follows,
+
+     for (ix = 0; (ptr = VEC_iterate(T,v,ix)); ix++)
+       continue;  */
+#define VEC_iterate(TDEF,V,I)		(VEC_OP(TDEF,iterate)(V,I))
+
+/* Allocate new vector.
+   VEC(T) *VEC_T_alloc(size_t reserve);
+
+   Allocate a new vector with space for RESERVE objects.  */
+#define VEC_alloc(TDEF,A)		(VEC_OP(TDEF,alloc)(A))
+
+/* Allocate new vector offset within a structure
+   void *VEC_T_embedded_alloc(size_t offset, size_t reserve);
+
+   Allocate a new vector which is at offset OFFSET within a structure,
+   and with space for RESERVE objects.  Return a pointer to the start
+   of the structure containing the vector.  Naturally, the vector must
+   be the last member of the structure.  */
+#define VEC_embedded_alloc(TDEF,O,A)	(VEC_OP(TDEF,embedded_alloc)(O,A))
+
+/* Reserve space.
+   void VEC_T_reserve(VEC(T) *&v, size_t reserve);
+
+   Ensure that V has at least RESERVE slots available.  Note this can
+   cause V to be reallocated.  */
+#define VEC_reserve(TDEF,V,R)		(VEC_OP(TDEF,reserve)(&(V),R))
+
+/* Push object with no reallocation
+   T *VEC_T_quick_push (VEC(T) *v, T obj); // Pointer
+   T *VEC_T_quick_push (VEC(T) *v, T *obj); // Object
+   
+   Push a new element onto the end, returns a pointer to the slot
+   filled in. For object vectors, the new value can be NULL, in which
+   case NO initialization is performed.  Aborts if there is
+   insufficient space in the vector. */
+#define VEC_quick_push(TDEF,V,O)	(VEC_OP(TDEF,quick_push)(V,O))
+
+/* Push object with reallocation
+   T *VEC_T_safe_push (VEC(T) *&v, T obj); // Pointer
+   T *VEC_T_safe_push (VEC(T) *&v, T *obj); // Object
+   
+   Push a new element onto the end, returns a pointer to the slot
+   filled in. For object vectors, the new value can be NULL, in which
+   case NO initialization is performed.  Reallocates V, if needed.  */
+#define VEC_safe_push(TDEF,V,O)		(VEC_OP(TDEF,safe_push)(&(V),O))
+
+/* Pop element off end
+   T VEC_T_pop (VEC(T) *v);		// Pointer
+   void VEC_T_pop (VEC(T) *v);		// Object
+
+   Pop the last element off the end. Returns the element popped, for
+   pointer vectors.  */
+#define VEC_pop(TDEF,V)			(VEC_OP(TDEF,pop)(V))
+
+/* Replace element
+   T VEC_T_replace (VEC(T) *v, size_t ix, T val); // Pointer
+   T *VEC_T_replace (VEC(T) *v, size_t ix, T *val);  // Object
+   
+   Replace the IXth element of V with a new value, VAL.  For pointer
+   vectors returns the original value. For object vectors returns a
+   pointer to the new value.  For object vectors the new value can be
+   NULL, in which case no overwriting of the slot is actually
+   performed.  */
+#define VEC_replace(TDEF,V,I,O)		(VEC_OP(TDEF,replace)(V,I,O))
+
+/* Insert object with no reallocation
+   T *VEC_T_quick_insert (VEC(T) *v, size_t ix, T val); // Pointer
+   T *VEC_T_quick_insert (VEC(T) *v, size_t ix, T *val); // Object
+   
+   Insert an element, VAL, at the IXth position of V. Return a pointer
+   to the slot created.  For vectors of object, the new value can be
+   NULL, in which case no initialization of the inserted slot takes
+   place. Aborts if there is insufficient space.  */
+#define VEC_quick_insert(TDEF,V,I,O)	(VEC_OP(TDEF,quick_insert)(V,I,O))
+
+/* Insert object with reallocation
+   T *VEC_T_safe_insert (VEC(T) *&v, size_t ix, T val); // Pointer
+   T *VEC_T_safe_insert (VEC(T) *&v, size_t ix, T *val); // Object
+   
+   Insert an element, VAL, at the IXth position of V. Return a pointer
+   to the slot created.  For vectors of object, the new value can be
+   NULL, in which case no initialization of the inserted slot takes
+   place. Reallocate V, if necessary.  */
+#define VEC_safe_insert(TDEF,V,I,O)	(VEC_OP(TDEF,safe_insert)(&(V),I,O))
+     
+/* Remove element retaining order
+   T VEC_T_ordered_remove (VEC(T) *v, size_t ix); // Pointer
+   void VEC_T_ordered_remove (VEC(T) *v, size_t ix); // Object
+   
+   Remove an element from the IXth position of V. Ordering of
+   remaining elements is preserverd.  For pointer vectors returns the
+   removed object.  This is an O(N) operation due to a memmove.  */
+#define VEC_ordered_remove(TDEF,V,I)	(VEC_OP(TDEF,ordered_remove)(V,I))
+
+/* Remove element destroying order
+   T VEC_T_unordered_remove (VEC(T) *v, size_t ix); // Pointer
+   void VEC_T_unordered_remove (VEC(T) *v, size_t ix); // Object
+   
+   Remove an element from the IXth position of V. Ordering of
+   remaining elements is destroyed.  For pointer vectors returns the
+   removed object.  This is an O(1) operation.  */
+#define VEC_unordered_remove(TDEF,V,I)	(VEC_OP(TDEF,unordered_remove)(V,I))
+
+#if !IN_GENGTYPE
+#include "auto-host.h"
+
+/* Reallocate an array of elements with prefix.  */
+extern void *vec_p_reserve (void *, size_t);
+extern void *vec_o_reserve (void *, size_t, size_t, size_t);
+extern void *vec_embedded_alloc (size_t, size_t, size_t, size_t);
+
+#if ENABLE_CHECKING
+extern void vec_assert_fail (const char *, const char *,
+			    const char *, size_t, const char *)
+     ATTRIBUTE_NORETURN;
+#define VEC_ASSERT_FAIL(OP,VEC) \
+  vec_assert_fail (OP,#VEC,__FILE__,__LINE__,__FUNCTION__)
+     
+#define VEC_ASSERT(EXPR,OP,TDEF) \
+  (void)((EXPR) ? 0 : (VEC_ASSERT_FAIL(OP,VEC(TDEF)), 0))
+#else
+#define VEC_ASSERT(EXPR,OP,TYPE) (void)(EXPR)
+#endif
+
+#define VEC(TDEF) VEC_##TDEF
+#define VEC_OP(TDEF,OP) VEC_OP_(VEC(TDEF),OP)
+#define VEC_OP_(VEC,OP) VEC_OP__(VEC,OP)
+#define VEC_OP__(VEC,OP) VEC ## _ ## OP
+#else  /* IN_GENGTYPE */
+#define VEC(TDEF) VEC_ TDEF
+#define VEC_STRINGIFY(X) VEC_STRINGIFY_(X)
+#define VEC_STRINGIFY_(X) #X
+#undef GTY
+#endif /* IN_GENGTYPE */
+
+#define VEC_TDEF(TDEF)							  \
+typedef struct VEC (TDEF) GTY(())					  \
+{									  \
+  size_t num;								  \
+  size_t alloc;								  \
+  TDEF GTY ((length ("%h.num"))) vec[1];				  \
+} VEC (TDEF)
+
+/* Vector of pointer to object.  */
+#if IN_GENGTYPE
+{"DEF_VEC_P", VEC_STRINGIFY (VEC_TDEF (#)) ";", NULL},
+#else
+  
+#define DEF_VEC_P(TDEF)							  \
+VEC_TDEF (TDEF);							  \
+									  \
+static inline size_t VEC_OP (TDEF,length)				  \
+     (const VEC (TDEF) *vec_) 						  \
+{									  \
+  return vec_ ? vec_->num : 0;						  \
+}									  \
+									  \
+static inline TDEF VEC_OP (TDEF,last)					  \
+     (const VEC (TDEF) *vec_)						  \
+{									  \
+  VEC_ASSERT (vec_ && vec_->num, "last", TDEF);				  \
+  									  \
+  return vec_->vec[vec->num - 1];					  \
+}									  \
+									  \
+static inline TDEF VEC_OP (TDEF,index)					  \
+     (const VEC (TDEF) *vec_, size_t ix_)				  \
+{									  \
+  VEC_ASSERT (vec_ && ix_ < vec_->num, "index", TDEF);			  \
+  									  \
+  return vec_->vec[ix_];						  \
+}									  \
+									  \
+static inline TDEF VEC_OP (TDEF,iterate)		  	     	  \
+     (const VEC (TDEF) *vec_, size_t ix_)				  \
+{									  \
+  return vec_ && ix_ < vec_->num ? vec_->vec[ix_] : NULL;		  \
+}									  \
+									  \
+static inline VEC (TDEF) *VEC_OP (TDEF,alloc)		       		  \
+     (size_t alloc_)							  \
+{									  \
+  return vec_p_reserve (NULL, alloc_ - !alloc_);			  \
+}									  \
+									  \
+static inline void *VEC_OP (TDEF,embedded_alloc)			  \
+     (size_t offset_, size_t alloc_)					  \
+{									  \
+  return vec_embedded_alloc (offset_, offsetof (VEC(TDEF),vec),		  \
+			     sizeof (TDEF), alloc_);			  \
+}									  \
+									  \
+static inline void VEC_OP (TDEF,reserve)	       			  \
+     (VEC (TDEF) **vec_, size_t alloc_)					  \
+{									  \
+  *vec_ = vec_p_reserve (*vec_, alloc_);				  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,quick_push)				  \
+     (VEC (TDEF) *vec_, TDEF obj_)					  \
+{									  \
+  TDEF *slot_;								  \
+  									  \
+  VEC_ASSERT (vec_->num < vec_->alloc, "push", TDEF);			  \
+  slot_ = &vec_->vec[vec_->num++];					  \
+  *slot_ = obj_;							  \
+  									  \
+  return slot_;								  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,safe_push)				  \
+     (VEC (TDEF) **vec_, TDEF obj_)					  \
+{									  \
+  if (!*vec_ || (*vec_)->num == (*vec_)->alloc)				  \
+    VEC_OP (TDEF,reserve) (vec_, ~0u);					  \
+									  \
+  return VEC_OP (TDEF,quick_push) (*vec_, obj_);			  \
+}									  \
+									  \
+static inline TDEF VEC_OP (TDEF,pop)					  \
+     (VEC (TDEF) *vec_)			       				  \
+{									  \
+  TDEF obj_;								  \
+									  \
+  VEC_ASSERT (vec_->num, "pop", TDEF);					  \
+  obj_ = vec_->vec[--vec_->num];					  \
+									  \
+  return obj_;								  \
+}									  \
+									  \
+static inline TDEF VEC_OP (TDEF,replace)		  	     	  \
+     (VEC (TDEF) *vec_, size_t ix_, TDEF obj_)				  \
+{									  \
+  TDEF old_obj_;							  \
+									  \
+  VEC_ASSERT (ix_ < vec_->num, "replace", TDEF);			  \
+  old_obj_ = vec_->vec[ix_];						  \
+  vec_->vec[ix_] = obj_;						  \
+									  \
+  return old_obj_;							  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,quick_insert)		     	  	  \
+     (VEC (TDEF) *vec_, size_t ix_, TDEF obj_)				  \
+{									  \
+  TDEF *slot_;								  \
+									  \
+  VEC_ASSERT (vec_->num < vec_->alloc, "insert", TDEF);			  \
+  VEC_ASSERT (ix_ <= vec_->num, "insert", TDEF);			  \
+  slot_ = &vec_->vec[ix_];						  \
+  memmove (slot_ + 1, slot_, vec_->num++ - ix_);			  \
+  *slot_ = obj_;							  \
+  									  \
+  return slot_;								  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,safe_insert)		     	  	  \
+     (VEC (TDEF) **vec_, size_t ix_, TDEF obj_)       			  \
+{									  \
+  if (!*vec_ || (*vec_)->num == (*vec_)->alloc)				  \
+    VEC_OP (TDEF,reserve) (vec_, ~0u);					  \
+									  \
+  return VEC_OP (TDEF,quick_insert) (*vec_, ix_, obj_);			  \
+}									  \
+									  \
+static inline TDEF VEC_OP (TDEF,ordered_remove)				  \
+     (VEC (TDEF) *vec_, size_t ix_)					  \
+{									  \
+  TDEF *slot_;								  \
+  TDEF obj_;								  \
+									  \
+  VEC_ASSERT (ix_ < vec_->num, "remove", TDEF);				  \
+  slot_ = &vec_->vec[ix_];						  \
+  obj_ = *slot_;							  \
+  memmove (slot_, slot_ + 1, --vec_->num - ix_);       			  \
+									  \
+  return obj_;								  \
+}									  \
+									  \
+static inline TDEF VEC_OP (TDEF,unordered_remove)			  \
+     (VEC (TDEF) *vec_, size_t ix_)					  \
+{									  \
+  TDEF *slot_;								  \
+  TDEF obj_;								  \
+									  \
+  VEC_ASSERT (ix_ < vec_->num, "remove", TDEF);				  \
+  slot_ = &vec_->vec[ix_];						  \
+  obj_ = *slot_;							  \
+  *slot_ = vec_->vec[--vec_->num];					  \
+									  \
+  return obj_;								  \
+}									  \
+									  \
+struct vec_swallow_trailing_semi
+#endif
+
+/* Vector of object.  */
+#if IN_GENGTYPE
+{"DEF_VEC_O", VEC_STRINGIFY (VEC_TDEF (#)) ";", NULL},
+#else
+  
+#define DEF_VEC_O(TDEF)							  \
+VEC_TDEF (TDEF);							  \
+									  \
+static inline size_t VEC_OP (TDEF,length)				  \
+     (const VEC (TDEF) *vec_) 						  \
+{									  \
+  return vec_ ? vec_->num : 0;						  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,last)					  \
+     (VEC (TDEF) *vec_)							  \
+{									  \
+  VEC_ASSERT (vec_ && vec_->num, "last", TDEF);				  \
+  									  \
+  return &vec_->vec[vec_->num - 1];					  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,index)					  \
+     (VEC (TDEF) *vec_, size_t ix_)					  \
+{									  \
+  VEC_ASSERT (vec_ && ix_ < vec_->num, "index", TDEF);			  \
+  									  \
+  return &vec_->vec[ix_];						  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,iterate)				  \
+     (VEC (TDEF) *vec_, size_t ix_)					  \
+{									  \
+  return vec_ && ix_ < vec_->num ? &vec_->vec[ix_] : NULL;		  \
+}									  \
+									  \
+static inline VEC (TDEF) *VEC_OP (TDEF,alloc)      			  \
+     (size_t alloc_)							  \
+{									  \
+  return vec_o_reserve (NULL, alloc_ - !alloc_,				  \
+			offsetof (VEC(TDEF),vec), sizeof (TDEF));	  \
+}									  \
+									  \
+static inline void *VEC_OP (TDEF,embedded_alloc)			  \
+     (size_t offset_, size_t alloc_)					  \
+{									  \
+  return vec_embedded_alloc (offset_, offsetof (VEC(TDEF),vec),		  \
+			     sizeof (TDEF), alloc_);			  \
+}									  \
+									  \
+static inline void VEC_OP (TDEF,reserve)	       			  \
+     (VEC (TDEF) **vec_, size_t alloc_)					  \
+{									  \
+  *vec_ = vec_o_reserve (*vec_, alloc_,					  \
+			 offsetof (VEC(TDEF),vec), sizeof (TDEF));	  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,quick_push)				  \
+     (VEC (TDEF) *vec_, const TDEF *obj_)				  \
+{									  \
+  TDEF *slot_;								  \
+  									  \
+  VEC_ASSERT (vec_->num < vec_->alloc, "push", TDEF);			  \
+  slot_ = &vec_->vec[vec_->num++];					  \
+  if (obj_)								  \
+    *slot_ = *obj_;							  \
+  									  \
+  return slot_;								  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,safe_push)				  \
+     (VEC (TDEF) **vec_, const TDEF *obj_)				  \
+{									  \
+  if (!*vec_ || (*vec_)->num == (*vec_)->alloc)				  \
+    VEC_OP (TDEF,reserve) (vec_, ~0u);					  \
+									  \
+  return VEC_OP (TDEF,quick_push) (*vec_, obj_);			  \
+}									  \
+									  \
+static inline void VEC_OP (TDEF,pop)					  \
+     (VEC (TDEF) *vec_)							  \
+{									  \
+  VEC_ASSERT (vec_->num, "pop", TDEF);					  \
+  vec_->vec[--vec_->num];						  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,replace)				  \
+     (VEC (TDEF) *vec_, size_t ix_, const TDEF *obj_)			  \
+{									  \
+  TDEF *slot_;								  \
+									  \
+  VEC_ASSERT (ix_ < vec_->num, "replace", TDEF);			  \
+  slot_ = &vec_->vec[ix_];						  \
+  if (obj_)								  \
+    *slot_ = *obj_;							  \
+									  \
+  return slot_;								  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,quick_insert)				  \
+     (VEC (TDEF) *vec_, size_t ix_, const TDEF *obj_)			  \
+{									  \
+  TDEF *slot_;								  \
+									  \
+  VEC_ASSERT (vec_->num < vec_->alloc, "insert", TDEF);			  \
+  VEC_ASSERT (ix_ <= vec_->num, "insert", TDEF);			  \
+  slot_ = &vec_->vec[ix_];						  \
+  memmove (slot_ + 1, slot_, vec_->num++ - ix_);			  \
+  if (obj_)								  \
+    *slot_ = *obj_;							  \
+  									  \
+  return slot_;								  \
+}									  \
+									  \
+static inline TDEF *VEC_OP (TDEF,safe_insert)		     	  	  \
+     (VEC (TDEF) **vec_, size_t ix_, const TDEF *obj_)			  \
+{									  \
+  if (!*vec_ || (*vec_)->num == (*vec_)->alloc)				  \
+    VEC_OP (TDEF,reserve) (vec_, ~0u);					  \
+									  \
+  return VEC_OP (TDEF,quick_insert) (*vec_, ix_, obj_);			  \
+}									  \
+									  \
+static inline void VEC_OP (TDEF,ordered_remove)				  \
+     (VEC (TDEF) *vec_, size_t ix_)					  \
+{									  \
+  TDEF *slot_;								  \
+									  \
+  VEC_ASSERT (ix_ < vec_->num, "remove", TDEF);				  \
+  slot_ = &vec_->vec[ix_];						  \
+  memmove (slot_, slot_ + 1, --vec_->num - ix_);       			  \
+}									  \
+									  \
+static inline void VEC_OP (TDEF,unordered_remove)			  \
+     (VEC (TDEF) *vec_, size_t ix_)					  \
+{									  \
+  VEC_ASSERT (ix_ < vec_->num, "remove", TDEF);				  \
+  vec_->vec[ix_] = vec_->vec[--vec_->num];				  \
+}									  \
+									  \
+struct vec_swallow_trailing_semi
+#endif
+
+#endif /* GCC_VEC_H */