2006-09-21 Nathan Sidwell <nathan@codesourcery.com>

gdb/
	* vec.h: New file.
	* vec.c: New file.
	* Makefile.in (SFILES): Add vec.c.
	(vec_h): New.
	(COMMON_OBJS): Add vec.o.
	(vec.o): New target.
gdb/doc/
	* gdbint.texinfo (Array Containers): New section.

6 files changed, 1312 insertions, 2 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 268df64..7b0e5d6 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,12 @@
+2006-09-21  Nathan Sidwell  <nathan@codesourcery.com>
+
+	* vec.h: New file.
+	* vec.c: New file.
+	* Makefile.in (SFILES): Add vec.c.
+	(vec_h): New.
+	(COMMON_OBJS): Add vec.o.
+	(vec.o): New target.
+
 2006-09-20  Daniel Jacobowitz  <dan@codesourcery.com>
 
 	PR remote/2154
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 5d4b5fc..1690f52 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -560,7 +560,7 @@ SFILES = ada-exp.y ada-lang.c ada-typeprint.c ada-valprint.c  \
 	typeprint.c \
 	ui-out.c utils.c ui-file.h ui-file.c \
 	user-regs.c \
-	valarith.c valops.c valprint.c value.c varobj.c \
+	valarith.c valops.c valprint.c value.c varobj.c vec.c \
 	wrapper.c
 
 LINTFILES = $(SFILES) $(YYFILES) $(CONFIG_SRCS) init.c
@@ -816,6 +816,7 @@ value_h = value.h $(doublest_h) $(frame_h) $(symtab_h) $(gdbtypes_h) \
 	$(expression_h)
 varobj_h = varobj.h $(symtab_h) $(gdbtypes_h)
 vax_tdep_h = vax-tdep.h
+vec_h = vec.h $(gdb_assert_h) $(gdb_string_h)
 version_h = version.h
 wince_stub_h = wince-stub.h
 wrapper_h = wrapper.h $(gdb_h)
@@ -941,7 +942,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $(YYOBJ) \
 	dwarf2expr.o dwarf2loc.o dwarf2-frame.o \
 	ada-lang.o c-lang.o f-lang.o objc-lang.o \
 	ui-out.o cli-out.o \
-	varobj.o wrapper.o \
+	varobj.o vec.o wrapper.o \
 	jv-lang.o jv-valprint.o jv-typeprint.o \
 	m2-lang.o p-lang.o p-typeprint.o p-valprint.o \
 	scm-exp.o scm-lang.o scm-valprint.o \
@@ -2826,6 +2827,7 @@ vax-tdep.o: vax-tdep.c $(defs_h) $(arch_utils_h) $(dis_asm_h) \
 	$(float_format_h) $(frame_h) $(frame_base_h) $(frame_unwind_h) \
 	$(gdbcore_h) $(gdbtypes_h) $(osabi_h) $(regcache_h) $(regset_h) \
 	$(trad_frame_h) $(value_h) $(gdb_string_h) $(vax_tdep_h)
+vec.o: vec.c $(defs_h) $(vec_h)
 win32-nat.o: win32-nat.c $(defs_h) $(frame_h) $(inferior_h) $(target_h) \
 	$(exceptions_h) $(gdbcore_h) $(command_h) $(completer_h) \
 	$(regcache_h) $(top_h) $(buildsym_h) $(symfile_h) $(objfiles_h) \
diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog
index f2ee9d8..d50e845 100644
--- a/gdb/doc/ChangeLog
+++ b/gdb/doc/ChangeLog
@@ -1,3 +1,7 @@
+2006-09-21  Nathan Sidwell  <nathan@codesourcery.com>
+
+	* gdbint.texinfo (Array Containers): New section.
+
 2006-09-17  Vladimir Prus  <vladimir@codesourcery.com>
 
 	* gdb.texinfo (GDB/MI Stack Manipulation): Mention that
diff --git a/gdb/doc/gdbint.texinfo b/gdb/doc/gdbint.texinfo
index 1ab1dbf..d370cb5 100644
--- a/gdb/doc/gdbint.texinfo
+++ b/gdb/doc/gdbint.texinfo
@@ -4913,6 +4913,181 @@ Regex conditionals.
 @item sparc
 @end table
 
+@section Array Containers
+@cindex Array Containers
+@cindex VEC
+
+Often it is necessary to manipulate a dynamic array of a set of
+objects.  C forces some bookkeeping on this, which can get cumbersome
+and repetative.  The @file{vec.h} file contains macros for defining
+and using a typesafe vector type.  The functions defined will be
+inlined when compiling, and so the abstraction cost should be zero.
+Domain checks are added to detect programming errors.
+
+An example use would be an array of symbols or section information.
+The array can be grown as symbols are read in (or preallocated), and
+the accessor macros provided keep care of all the necessary
+bookkeeping.  Because the arrays are type safe, there is no danger of
+accidentally mixing up the contents.  Think of these as C++ templates,
+but implemented in C.
+
+Because of the different behavior of structure objects, scalar objects
+and of pointers, there are three flavors of vector, one for each of
+these variants.  Both the structure object and pointer variants 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.  The scalar
+object variant is suitable for @code{int}-like objects, and the vector
+elements are returned by value.
+
+There are both @code{index} and @code{iterate} accessors.  The iterator
+returns a boolean iteration condition and updates the iteration
+variable passed by reference.  Because the iterator will be inlined,
+the address-of can be optimized away.
+
+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 @code{embedded_size} & @code{embedded_init} calls to create
+such objects, and they will probably not be resizeable (so don't use
+the @dfn{safe} allocation variants).  The trailing array idiom is used
+(rather than a pointer to an array of data), because, if we allow
+@code{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 @dfn{quick} and @dfn{safe} variants.  The former presumes
+that there is sufficient allocated space for the operation to succeed
+(it dies 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
+@dfn{quick} operation.  This will ensure there are at least as many
+elements as you ask for, it will exponentially increase if there are
+too few spare slots.  If you want reserve a specific number of slots,
+but do not want the exponential increase (for instance, you know this
+is the last allocation), use a negative number for reservation.  You
+can also create a vector of a specific size from the get go.
+
+You should prefer the push and pop operations, as they append and
+remove from the end of the vector. If you need to remove several items
+in one go, use the truncate operation.  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 @code{ordered_remove}, and one which does not
+@code{unordered_remove}.  The latter function copies the end element
+into the removed slot, rather than invoke a memmove operation.  The
+@code{lower_bound} function will determine where to place an item in
+the array using insert that will maintain sorted order.
+
+If you need to directly manipulate a vector, then the @code{address}
+accessor will return the address of the start of the vector.  Also the
+@code{space} predicate will tell you whether there is spare capacity in the
+vector.  You will not normally need to use these two functions.
+
+Vector types are defined using a
+@code{DEF_VEC_@{O,P,I@}(@var{typename})} macro.  Variables of vector
+type are declared using a @code{VEC(@var{typename})} macro.  The
+characters @code{O}, @code{P} and @code{I} indicate whether
+@var{typename} is an object (@code{O}), pointer (@code{P}) or integral
+(@code{I}) type.  Be careful to pick the correct one, as you'll get an
+awkward and inefficient API if you use the wrong one.  There is a
+check, which results in a compile-time warning, for the @code{P} and
+@code{I} versions, but there is no check for the @code{O} versions, as
+that is not possible in plain C.
+
+An example of their use would be,
+
+@smallexample
+DEF_VEC_P(tree);   // non-managed tree vector.
+
+struct my_struct @{
+  VEC(tree) *v;      // A (pointer to) a vector of tree pointers.
+@};
+
+struct my_struct *s;
+
+if (VEC_length(tree, s->v)) @{ we have some contents @}
+VEC_safe_push(tree, s->v, decl); // append some decl onto the end
+for (ix = 0; VEC_iterate(tree, s->v, ix, elt); ix++)
+  @{ do something with elt @}
+
+@end smallexample
+
+The @file{vec.h} file provides details on how to invoke the various
+accessors provided.  They are enumerated here:
+
+@table @code
+@item VEC_length
+Return the number of items in the array,
+
+@item VEC_empty
+Return true if the array has no elements.
+
+@item VEC_last
+@itemx VEC_index
+Return the last or arbitrary item in the array.
+
+@item VEC_iterate
+Access an array element and indicate whether the array has been
+traversed.
+
+@item VEC_alloc
+@itemx VEC_free
+Create and destroy an array.
+
+@item VEC_embedded_size
+@itemx VEC_embedded_init
+Helpers for embedding an array as the final element of another struct.
+
+@item VEC_copy
+Duplicate an array.
+
+@item VEC_space
+Return the amount of free space in an array.
+
+@item VEC_reserve
+Ensure a certain amount of free space.
+
+@item VEC_quick_push
+@itemx VEC_safe_push
+Append to an array, either assuming the space is available, or making
+sure that it is.
+
+@item VEC_pop
+Remove the last item from an array.
+
+@item VEC_truncate
+Remove several items from the end of an array.
+
+@item VEC_safe_grow
+Add several items to the end of an array.
+
+@item VEC_replace
+Overwrite an item in the array.
+
+@item VEC_quick_insert
+@itemx VEC_safe_insert
+Insert an item into the middle of the array.  Either the space must
+already exist, or the space is created.
+
+@item VEC_ordered_remove
+@itemx VEC_unordered_remove
+Remove an item from the array, preserving order or not.
+
+@item VEC_block_remove
+Remove a set of items from the array.
+
+@item VEC_address
+Provide the address of the first element.
+
+@item VEC_lower_bound
+Binary search the array.
+
+@end table
+
 @section include
 
 @node Coding
diff --git a/gdb/vec.c b/gdb/vec.c
new file mode 100644
index 0000000..4f67e68
--- /dev/null
+++ b/gdb/vec.c
@@ -0,0 +1,120 @@
+/* Vector API for GDB.
+   Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
+   Contributed by Nathan Sidwell <nathan@codesourcery.com>
+
+   This file is part of GDB.
+
+   This program 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 of the License, or
+   (at your option) any later version.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+#include "vec.h"
+#include "defs.h"
+
+struct vec_prefix
+{
+  unsigned num;
+  unsigned alloc;
+  void *vec[1];
+};
+
+/* Calculate the new ALLOC value, making sure that abs(RESERVE) slots
+   are free.  If RESERVE < 0 grow exactly, otherwise grow
+   exponentially.  */
+
+static inline unsigned
+calculate_allocation (const struct vec_prefix *pfx, int reserve)
+{
+  unsigned alloc = 0;
+  unsigned num = 0;
+
+  if (pfx)
+    {
+      alloc = pfx->alloc;
+      num = pfx->num;
+    }
+  else if (!reserve)
+    /* If there's no prefix, and we've not requested anything, then we
+       will create a NULL vector.  */
+    return 0;
+
+  /* We must have run out of room.  */
+  gdb_assert (alloc - num < (unsigned)(reserve < 0 ? -reserve : reserve));
+
+  if (reserve < 0)
+    /* Exact size.  */
+    alloc = num + -reserve;
+  else
+    {
+      /* Exponential growth. */
+      if (!alloc)
+	alloc = 4;
+      else if (alloc < 16)
+	/* Double when small.  */
+	alloc = alloc * 2;
+      else
+	/* Grow slower when large.  */
+	alloc = (alloc * 3 / 2);
+
+      /* If this is still too small, set it to the right size. */
+      if (alloc < num + reserve)
+	alloc = num + reserve;
+    }
+  return alloc;
+}
+
+/* Ensure there are at least abs(RESERVE) free slots in VEC.  If
+   RESERVE < 0 grow exactly, else grow exponentially.  As a special
+   case, if VEC is NULL, and RESERVE is 0, no vector will be created. */
+
+void *
+vec_p_reserve (void *vec, int reserve)
+{
+  return vec_o_reserve (vec, reserve,
+			offsetof (struct vec_prefix, vec), sizeof (void *));
+}
+
+/* As vec_p_reserve, but for object vectors.  The vector's trailing
+   array is at VEC_OFFSET offset and consists of ELT_SIZE sized
+   elements.  */
+
+void *
+vec_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size)
+{
+  struct vec_prefix *pfx = vec;
+  unsigned alloc = calculate_allocation (pfx, reserve);
+
+  if (!alloc)
+    return NULL;
+
+  vec = xrealloc (vec, vec_offset + alloc * elt_size);
+  ((struct vec_prefix *)vec)->alloc = alloc;
+  if (!pfx)
+    ((struct vec_prefix *)vec)->num = 0;
+
+  return vec;
+}
+
+#if 0
+/* Example uses.  */
+DEF_VEC_I (int);
+typedef struct X
+{
+  int i;
+} obj_t;
+typedef obj_t *ptr_t;
+
+DEF_VEC_P (ptr_t);
+DEF_VEC_O (obj_t);
+#endif
diff --git a/gdb/vec.h b/gdb/vec.h
new file mode 100644
index 0000000..f6b7f07
--- /dev/null
+++ b/gdb/vec.h
@@ -0,0 +1,1000 @@
+/* Vector API for GDB.
+   Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
+   Contributed by Nathan Sidwell <nathan@codesourcery.com>
+
+   This file is part of GDB.
+
+   This program 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 of the License, or
+   (at your option) any later version.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+#if !defined (GDB_VEC_H)
+#define GDB_VEC_H
+
+#include <stddef.h>
+#include "gdb_string.h"
+#include "gdb_assert.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.
+
+   Because of the different behavior of structure objects, scalar
+   objects and of pointers, there are three flavors, one for each of
+   these variants.  Both the structure object and pointer variants
+   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.  The scalar
+   object variant is suitable for int-like objects, and the vector
+   elements are returned by value.
+
+   There are both 'index' and 'iterate' accessors.  The iterator
+   returns a boolean iteration condition and updates the iteration
+   variable passed by reference.  Because the iterator will be
+   inlined, the address-of can be optimized away.
+
+   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_size & embedded_init calls 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 dies 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.  This will ensure there are at
+   least as many elements as you ask for, it will exponentially
+   increase if there are too few spare slots.  If you want reserve a
+   specific number of slots, but do not want the exponential increase
+   (for instance, you know this is the last allocation), use a
+   negative number for reservation.  You can also create a vector of a
+   specific size from the get go.
+
+   You should prefer the push and pop operations, as they append and
+   remove from the end of the vector. If you need to remove several
+   items in one go, use the truncate operation.  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.  The
+   'lower_bound' function will determine where to place an item in the
+   array using insert that will maintain sorted order.
+
+   If you need to directly manipulate a vector, then the 'address'
+   accessor will return the address of the start of the vector.  Also
+   the 'space' predicate will tell you whether there is spare capacity
+   in the vector.  You will not normally need to use these two functions.
+
+   Vector types are defined using a DEF_VEC_{O,P,I}(TYPEDEF) macro.
+   Variables of vector type are declared using a VEC(TYPEDEF) macro.
+   The characters O, P and I indicate whether TYPEDEF is a pointer
+   (P), object (O) or integral (I) type.  Be careful to pick the
+   correct one, as you'll get an awkward and inefficient API if you
+   use the wrong one.  There is a check, which results in a
+   compile-time warning, for the P and I versions, but there is no
+   check for the O versions, as that is not possible in plain C.
+
+   An example of their use would be,
+
+   DEF_VEC_P(tree);   // non-managed tree vector.
+
+   struct my_struct {
+     VEC(tree) *v;      // A (pointer to) a vector of tree pointers.
+   };
+
+   struct my_struct *s;
+
+   if (VEC_length(tree, s->v)) { we have some contents }
+   VEC_safe_push(tree, s->v, decl); // append some decl onto the end
+   for (ix = 0; VEC_iterate(tree, s->v, ix, elt); ix++)
+     { do something with elt }
+
+*/
+
+/* 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, T 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
+   unsigned 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(T,V)	(VEC_OP(T,length)(V))
+
+
+/* Check if vector is empty
+   int VEC_T_empty(const VEC(T) *v);
+
+   Return nonzero if V is an empty vector (or V is NULL), zero otherwise.  */
+
+#define VEC_empty(T,V)	(VEC_length (T,V) == 0)
+
+
+/* Get the final element of the vector.
+   T VEC_T_last(VEC(T) *v); // Integer
+   T VEC_T_last(VEC(T) *v); // Pointer
+   T *VEC_T_last(VEC(T) *v); // Object
+
+   Return the final element.  V must not be empty.  */
+
+#define VEC_last(T,V)	(VEC_OP(T,last)(V VEC_ASSERT_INFO))
+
+/* Index into vector
+   T VEC_T_index(VEC(T) *v, unsigned ix); // Integer
+   T VEC_T_index(VEC(T) *v, unsigned ix); // Pointer
+   T *VEC_T_index(VEC(T) *v, unsigned ix); // Object
+
+   Return the IX'th element.  If IX must be in the domain of V.  */
+
+#define VEC_index(T,V,I) (VEC_OP(T,index)(V,I VEC_ASSERT_INFO))
+
+/* Iterate over vector
+   int VEC_T_iterate(VEC(T) *v, unsigned ix, T &ptr); // Integer
+   int VEC_T_iterate(VEC(T) *v, unsigned ix, T &ptr); // Pointer
+   int VEC_T_iterate(VEC(T) *v, unsigned ix, T *&ptr); // Object
+
+   Return iteration condition and update PTR to point to the IX'th
+   element.  At the end of iteration, sets PTR to NULL.  Use this to
+   iterate over the elements of a vector as follows,
+
+     for (ix = 0; VEC_iterate(T,v,ix,ptr); ix++)
+       continue;  */
+
+#define VEC_iterate(T,V,I,P)	(VEC_OP(T,iterate)(V,I,&(P)))
+
+/* Allocate new vector.
+   VEC(T,A) *VEC_T_alloc(int reserve);
+
+   Allocate a new vector with space for RESERVE objects.  If RESERVE
+   is zero, NO vector is created.  */
+
+#define VEC_alloc(T,N)	(VEC_OP(T,alloc)(N))
+
+/* Free a vector.
+   void VEC_T_free(VEC(T,A) *&);
+
+   Free a vector and set it to NULL.  */
+
+#define VEC_free(T,V)	(VEC_OP(T,free)(&V))
+
+/* Use these to determine the required size and initialization of a
+   vector embedded within another structure (as the final member).
+
+   size_t VEC_T_embedded_size(int reserve);
+   void VEC_T_embedded_init(VEC(T) *v, int reserve);
+
+   These allow the caller to perform the memory allocation.  */
+
+#define VEC_embedded_size(T,N)	 (VEC_OP(T,embedded_size)(N))
+#define VEC_embedded_init(T,O,N) (VEC_OP(T,embedded_init)(VEC_BASE(O),N))
+
+/* Copy a vector.
+   VEC(T,A) *VEC_T_copy(VEC(T) *);
+
+   Copy the live elements of a vector into a new vector.  The new and
+   old vectors need not be allocated by the same mechanism.  */
+
+#define VEC_copy(T,V) (VEC_OP(T,copy)(V))
+
+/* Determine if a vector has additional capacity.
+
+   int VEC_T_space (VEC(T) *v,int reserve)
+
+   If V has space for RESERVE additional entries, return nonzero.  You
+   usually only need to use this if you are doing your own vector
+   reallocation, for instance on an embedded vector.  This returns
+   nonzero in exactly the same circumstances that VEC_T_reserve
+   will.  */
+
+#define VEC_space(T,V,R) (VEC_OP(T,space)(V,R VEC_ASSERT_INFO))
+
+/* Reserve space.
+   int VEC_T_reserve(VEC(T,A) *&v, int reserve);
+
+   Ensure that V has at least abs(RESERVE) slots available.  The
+   signedness of RESERVE determines the reallocation behavior.  A
+   negative value will not create additional headroom beyond that
+   requested.  A positive value will create additional headroom.  Note
+   this can cause V to be reallocated.  Returns nonzero iff
+   reallocation actually occurred.  */
+
+#define VEC_reserve(T,V,R) (VEC_OP(T,reserve)(&(V),R VEC_ASSERT_INFO))
+
+/* Push object with no reallocation
+   T *VEC_T_quick_push (VEC(T) *v, T obj); // Integer
+   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.  There must
+   be sufficient space in the vector.  */
+
+#define VEC_quick_push(T,V,O) (VEC_OP(T,quick_push)(V,O VEC_ASSERT_INFO))
+
+/* Push object with reallocation
+   T *VEC_T_safe_push (VEC(T,A) *&v, T obj); // Integer
+   T *VEC_T_safe_push (VEC(T,A) *&v, T obj); // Pointer
+   T *VEC_T_safe_push (VEC(T,A) *&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(T,V,O) (VEC_OP(T,safe_push)(&(V),O VEC_ASSERT_INFO))
+
+/* Pop element off end
+   T VEC_T_pop (VEC(T) *v);		// Integer
+   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(T,V)	(VEC_OP(T,pop)(V VEC_ASSERT_INFO))
+
+/* Truncate to specific length
+   void VEC_T_truncate (VEC(T) *v, unsigned len);
+
+   Set the length as specified.  The new length must be less than or
+   equal to the current length.  This is an O(1) operation.  */
+
+#define VEC_truncate(T,V,I)		\
+	(VEC_OP(T,truncate)(V,I VEC_ASSERT_INFO))
+
+/* Grow to a specific length.
+   void VEC_T_safe_grow (VEC(T,A) *&v, int len);
+
+   Grow the vector to a specific length.  The LEN must be as
+   long or longer than the current length.  The new elements are
+   uninitialized.  */
+
+#define VEC_safe_grow(T,V,I)		\
+	(VEC_OP(T,safe_grow)(&(V),I VEC_ASSERT_INFO))
+
+/* Replace element
+   T VEC_T_replace (VEC(T) *v, unsigned ix, T val); // Integer
+   T VEC_T_replace (VEC(T) *v, unsigned ix, T val); // Pointer
+   T *VEC_T_replace (VEC(T) *v, unsigned 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(T,V,I,O) (VEC_OP(T,replace)(V,I,O VEC_ASSERT_INFO))
+
+/* Insert object with no reallocation
+   T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Integer
+   T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Pointer
+   T *VEC_T_quick_insert (VEC(T) *v, unsigned 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. There must be sufficient space.  */
+
+#define VEC_quick_insert(T,V,I,O) \
+	(VEC_OP(T,quick_insert)(V,I,O VEC_ASSERT_INFO))
+
+/* Insert object with reallocation
+   T *VEC_T_safe_insert (VEC(T,A) *&v, unsigned ix, T val); // Integer
+   T *VEC_T_safe_insert (VEC(T,A) *&v, unsigned ix, T val); // Pointer
+   T *VEC_T_safe_insert (VEC(T,A) *&v, unsigned 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(T,V,I,O)	\
+	(VEC_OP(T,safe_insert)(&(V),I,O VEC_ASSERT_INFO))
+
+/* Remove element retaining order
+   T VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Integer
+   T VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Pointer
+   void VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Object
+
+   Remove an element from the IXth position of V. Ordering of
+   remaining elements is preserved.  For pointer vectors returns the
+   removed object.  This is an O(N) operation due to a memmove.  */
+
+#define VEC_ordered_remove(T,V,I)	\
+	(VEC_OP(T,ordered_remove)(V,I VEC_ASSERT_INFO))
+
+/* Remove element destroying order
+   T VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Integer
+   T VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Pointer
+   void VEC_T_unordered_remove (VEC(T) *v, unsigned 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(T,V,I)	\
+	(VEC_OP(T,unordered_remove)(V,I VEC_ASSERT_INFO))
+
+/* Remove a block of elements
+   void VEC_T_block_remove (VEC(T) *v, unsigned ix, unsigned len);
+
+   Remove LEN elements starting at the IXth.  Ordering is retained.
+   This is an O(1) operation.  */
+
+#define VEC_block_remove(T,V,I,L)	\
+	(VEC_OP(T,block_remove)(V,I,L) VEC_ASSERT_INFO)
+
+/* Get the address of the array of elements
+   T *VEC_T_address (VEC(T) v)
+
+   If you need to directly manipulate the array (for instance, you
+   want to feed it to qsort), use this accessor.  */
+
+#define VEC_address(T,V)		(VEC_OP(T,address)(V))
+
+/* Find the first index in the vector not less than the object.
+   unsigned VEC_T_lower_bound (VEC(T) *v, const T val,
+                               int (*lessthan) (const T, const T)); // Integer
+   unsigned VEC_T_lower_bound (VEC(T) *v, const T val,
+                               int (*lessthan) (const T, const T)); // Pointer
+   unsigned VEC_T_lower_bound (VEC(T) *v, const T *val,
+                               int (*lessthan) (const T*, const T*)); // Object
+
+   Find the first position in which VAL could be inserted without
+   changing the ordering of V.  LESSTHAN is a function that returns
+   true if the first argument is strictly less than the second.  */
+
+#define VEC_lower_bound(T,V,O,LT)    \
+       (VEC_OP(T,lower_bound)(V,O,LT VEC_ASSERT_INFO))
+
+/* Reallocate an array of elements with prefix.  */
+extern void *vec_p_reserve (void *, int);
+extern void *vec_o_reserve (void *, int, size_t, size_t);
+#define vec_free(V) xfree (V)
+
+#define VEC_ASSERT_INFO ,__FILE__,__LINE__
+#define VEC_ASSERT_DECL ,const char *file_,unsigned line_
+#define VEC_ASSERT_PASS ,file_,line_
+#define vec_assert(expr, op) \
+  ((void)((expr) ? 0 : (gdb_assert_fail (op, file_, line_, ASSERT_FUNCTION), 0)))
+
+#define VEC(T) VEC_##T
+#define VEC_OP(T,OP) VEC_##T##_##OP
+
+#define VEC_T(T)							  \
+typedef struct VEC(T)							  \
+{									  \
+  unsigned num;								  \
+  unsigned alloc;							  \
+  T vec[1];								  \
+} VEC(T)
+
+/* Vector of integer-like object.  */
+#define DEF_VEC_I(T)							  \
+static inline void VEC_OP (T,must_be_integral_type) (void)		  \
+{									  \
+  (void)~(T)0;								  \
+}									  \
+									  \
+VEC_T(T);								  \
+DEF_VEC_FUNC_P(T)							  \
+DEF_VEC_ALLOC_FUNC_I(T)							  \
+struct vec_swallow_trailing_semi
+
+/* Vector of pointer to object.  */
+#define DEF_VEC_P(T)							  \
+static inline void VEC_OP (T,must_be_pointer_type) (void)		  \
+{									  \
+  (void)((T)1 == (void *)1);						  \
+}									  \
+									  \
+VEC_T(T);								  \
+DEF_VEC_FUNC_P(T)							  \
+DEF_VEC_ALLOC_FUNC_P(T)							  \
+struct vec_swallow_trailing_semi
+
+/* Vector of object.  */
+#define DEF_VEC_O(T)							  \
+VEC_T(T);								  \
+DEF_VEC_FUNC_O(T)							  \
+DEF_VEC_ALLOC_FUNC_O(T)							  \
+struct vec_swallow_trailing_semi
+
+#define DEF_VEC_ALLOC_FUNC_I(T)						  \
+static inline VEC(T) *VEC_OP (T,alloc)					  \
+     (int alloc_)							  \
+{									  \
+  /* We must request exact size allocation, hence the negation.  */	  \
+  return (VEC(T) *) vec_o_reserve (NULL, -alloc_,			  \
+                                   offsetof (VEC(T),vec), sizeof (T));	  \
+}									  \
+									  \
+static inline VEC(T) *VEC_OP (T,copy) (VEC(T) *vec_)			  \
+{									  \
+  size_t len_ = vec_ ? vec_->num : 0;					  \
+  VEC (T) *new_vec_ = NULL;						  \
+									  \
+  if (len_)								  \
+    {									  \
+      /* We must request exact size allocation, hence the negation. */	  \
+      new_vec_ = (VEC (T) *)						  \
+	vec_o_reserve (NULL, -len_, offsetof (VEC(T),vec), sizeof (T));	  \
+									  \
+      new_vec_->num = len_;						  \
+      memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_);		  \
+    }									  \
+  return new_vec_;							  \
+}									  \
+									  \
+static inline void VEC_OP (T,free)					  \
+     (VEC(T) **vec_)							  \
+{									  \
+  if (*vec_)								  \
+    vec_free (*vec_);							  \
+  *vec_ = NULL;								  \
+}									  \
+									  \
+static inline int VEC_OP (T,reserve)					  \
+     (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL)			  \
+{									  \
+  int extend = !VEC_OP (T,space)					  \
+	(*vec_, alloc_ < 0 ? -alloc_ : alloc_ VEC_ASSERT_PASS);		  \
+									  \
+  if (extend)								  \
+    *vec_ = (VEC(T) *) vec_o_reserve (*vec_, alloc_,			  \
+				      offsetof (VEC(T),vec), sizeof (T)); \
+									  \
+  return extend;							  \
+}									  \
+									  \
+static inline void VEC_OP (T,safe_grow)					  \
+     (VEC(T) **vec_, int size_ VEC_ASSERT_DECL)				  \
+{									  \
+  vec_assert (size_ >= 0 && VEC_OP(T,length) (*vec_) <= (unsigned)size_,  \
+	"safe_grow");							  \
+  VEC_OP (T,reserve) (vec_, (int)(*vec_ ? (*vec_)->num : 0) - size_	  \
+			VEC_ASSERT_PASS);				  \
+  (*vec_)->num = size_;							  \
+}									  \
+									  \
+static inline T *VEC_OP (T,safe_push)					  \
+     (VEC(T) **vec_, const T obj_ VEC_ASSERT_DECL)			  \
+{									  \
+  VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS);				  \
+									  \
+  return VEC_OP (T,quick_push) (*vec_, obj_ VEC_ASSERT_PASS);		  \
+}									  \
+									  \
+static inline T *VEC_OP (T,safe_insert)					  \
+     (VEC(T) **vec_, unsigned ix_, const T obj_ VEC_ASSERT_DECL)	  \
+{									  \
+  VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS);				  \
+									  \
+  return VEC_OP (T,quick_insert) (*vec_, ix_, obj_ VEC_ASSERT_PASS);	  \
+}
+
+#define DEF_VEC_FUNC_P(T)						  \
+static inline unsigned VEC_OP (T,length) (const VEC(T) *vec_)		  \
+{									  \
+  return vec_ ? vec_->num : 0;						  \
+}									  \
+									  \
+static inline T VEC_OP (T,last)						  \
+	(const VEC(T) *vec_ VEC_ASSERT_DECL)				  \
+{									  \
+  vec_assert (vec_ && vec_->num, "last");				  \
+									  \
+  return vec_->vec[vec_->num - 1];					  \
+}									  \
+									  \
+static inline T VEC_OP (T,index)					  \
+     (const VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL)			  \
+{									  \
+  vec_assert (vec_ && ix_ < vec_->num, "index");			  \
+									  \
+  return vec_->vec[ix_];						  \
+}									  \
+									  \
+static inline int VEC_OP (T,iterate)					  \
+     (const VEC(T) *vec_, unsigned ix_, T *ptr)				  \
+{									  \
+  if (vec_ && ix_ < vec_->num)						  \
+    {									  \
+      *ptr = vec_->vec[ix_];						  \
+      return 1;								  \
+    }									  \
+  else									  \
+    {									  \
+      *ptr = 0;								  \
+      return 0;								  \
+    }									  \
+}									  \
+									  \
+static inline size_t VEC_OP (T,embedded_size)				  \
+     (int alloc_)							  \
+{									  \
+  return offsetof (VEC(T),vec) + alloc_ * sizeof(T);			  \
+}									  \
+									  \
+static inline void VEC_OP (T,embedded_init)				  \
+     (VEC(T) *vec_, int alloc_)						  \
+{									  \
+  vec_->num = 0;							  \
+  vec_->alloc = alloc_;							  \
+}									  \
+									  \
+static inline int VEC_OP (T,space)					  \
+     (VEC(T) *vec_, int alloc_ VEC_ASSERT_DECL)				  \
+{									  \
+  vec_assert (alloc_ >= 0, "space");					  \
+  return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_;	  \
+}									  \
+									  \
+static inline T *VEC_OP (T,quick_push)					  \
+     (VEC(T) *vec_, T obj_ VEC_ASSERT_DECL)				  \
+{									  \
+  T *slot_;								  \
+									  \
+  vec_assert (vec_->num < vec_->alloc, "quick_push");			  \
+  slot_ = &vec_->vec[vec_->num++];					  \
+  *slot_ = obj_;							  \
+									  \
+  return slot_;								  \
+}									  \
+									  \
+static inline T VEC_OP (T,pop) (VEC(T) *vec_ VEC_ASSERT_DECL)		  \
+{									  \
+  T obj_;								  \
+									  \
+  vec_assert (vec_->num, "pop");					  \
+  obj_ = vec_->vec[--vec_->num];					  \
+									  \
+  return obj_;								  \
+}									  \
+									  \
+static inline void VEC_OP (T,truncate)					  \
+     (VEC(T) *vec_, unsigned size_ VEC_ASSERT_DECL)			  \
+{									  \
+  vec_assert (vec_ ? vec_->num >= size_ : !size_, "truncate");		  \
+  if (vec_)								  \
+    vec_->num = size_;							  \
+}									  \
+									  \
+static inline T VEC_OP (T,replace)					  \
+     (VEC(T) *vec_, unsigned ix_, T obj_ VEC_ASSERT_DECL)		  \
+{									  \
+  T old_obj_;								  \
+									  \
+  vec_assert (ix_ < vec_->num, "replace");				  \
+  old_obj_ = vec_->vec[ix_];						  \
+  vec_->vec[ix_] = obj_;						  \
+									  \
+  return old_obj_;							  \
+}									  \
+									  \
+static inline T *VEC_OP (T,quick_insert)				  \
+     (VEC(T) *vec_, unsigned ix_, T obj_ VEC_ASSERT_DECL)		  \
+{									  \
+  T *slot_;								  \
+									  \
+  vec_assert (vec_->num < vec_->alloc && ix_ <= vec_->num, "quick_insert"); \
+  slot_ = &vec_->vec[ix_];						  \
+  memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T));		  \
+  *slot_ = obj_;							  \
+									  \
+  return slot_;								  \
+}									  \
+									  \
+static inline T VEC_OP (T,ordered_remove)				  \
+     (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL)			  \
+{									  \
+  T *slot_;								  \
+  T obj_;								  \
+									  \
+  vec_assert (ix_ < vec_->num, "ordered_remove");			  \
+  slot_ = &vec_->vec[ix_];						  \
+  obj_ = *slot_;							  \
+  memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T));		  \
+									  \
+  return obj_;								  \
+}									  \
+									  \
+static inline T VEC_OP (T,unordered_remove)				  \
+     (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL)			  \
+{									  \
+  T *slot_;								  \
+  T obj_;								  \
+									  \
+  vec_assert (ix_ < vec_->num, "unordered_remove");			  \
+  slot_ = &vec_->vec[ix_];						  \
+  obj_ = *slot_;							  \
+  *slot_ = vec_->vec[--vec_->num];					  \
+									  \
+  return obj_;								  \
+}									  \
+									  \
+static inline void VEC_OP (T,block_remove)				  \
+     (VEC(T) *vec_, unsigned ix_, unsigned len_ VEC_ASSERT_DECL)	  \
+{									  \
+  T *slot_;								  \
+									  \
+  vec_assert (ix_ + len_ <= vec_->num, "block_remove");			  \
+  slot_ = &vec_->vec[ix_];						  \
+  vec_->num -= len_;							  \
+  memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T));	  \
+}									  \
+									  \
+static inline T *VEC_OP (T,address)					  \
+     (VEC(T) *vec_)							  \
+{									  \
+  return vec_ ? vec_->vec : 0;						  \
+}									  \
+									  \
+static inline unsigned VEC_OP (T,lower_bound)				  \
+     (VEC(T) *vec_, const T obj_,					  \
+      int (*lessthan_)(const T, const T) VEC_ASSERT_DECL)		  \
+{									  \
+   unsigned int len_ = VEC_OP (T, length) (vec_);			  \
+   unsigned int half_, middle_;						  \
+   unsigned int first_ = 0;						  \
+   while (len_ > 0)							  \
+     {									  \
+        T middle_elem_;							  \
+        half_ = len_ >> 1;						  \
+        middle_ = first_;						  \
+        middle_ += half_;						  \
+        middle_elem_ = VEC_OP (T,index) (vec_, middle_ VEC_ASSERT_PASS);  \
+        if (lessthan_ (middle_elem_, obj_))				  \
+          {								  \
+             first_ = middle_;						  \
+             ++first_;							  \
+             len_ = len_ - half_ - 1;					  \
+          }								  \
+        else								  \
+          len_ = half_;							  \
+     }									  \
+   return first_;							  \
+}
+
+#define DEF_VEC_ALLOC_FUNC_P(T)						  \
+static inline VEC(T) *VEC_OP (T,alloc)					  \
+     (int alloc_)							  \
+{									  \
+  /* We must request exact size allocation, hence the negation.  */	  \
+  return (VEC(T) *) vec_p_reserve (NULL, -alloc_);			  \
+}									  \
+									  \
+static inline void VEC_OP (T,free)					  \
+     (VEC(T) **vec_)							  \
+{									  \
+  if (*vec_)								  \
+    vec_free (*vec_);							  \
+  *vec_ = NULL;								  \
+}									  \
+									  \
+static inline VEC(T) *VEC_OP (T,copy) (VEC(T) *vec_)			  \
+{									  \
+  size_t len_ = vec_ ? vec_->num : 0;					  \
+  VEC (T) *new_vec_ = NULL;						  \
+									  \
+  if (len_)								  \
+    {									  \
+      /* We must request exact size allocation, hence the negation. */	  \
+      new_vec_ = (VEC (T) *)(vec_p_reserve (NULL, -len_));		  \
+									  \
+      new_vec_->num = len_;						  \
+      memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_);		  \
+    }									  \
+  return new_vec_;							  \
+}									  \
+									  \
+static inline int VEC_OP (T,reserve)					  \
+     (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL)			  \
+{									  \
+  int extend = !VEC_OP (T,space)					  \
+	(*vec_, alloc_ < 0 ? -alloc_ : alloc_ VEC_ASSERT_PASS);		  \
+									  \
+  if (extend)								  \
+    *vec_ = (VEC(T) *) vec_p_reserve (*vec_, alloc_);			  \
+									  \
+  return extend;							  \
+}									  \
+									  \
+static inline void VEC_OP (T,safe_grow)					  \
+     (VEC(T) **vec_, int size_ VEC_ASSERT_DECL)				  \
+{									  \
+  vec_assert (size_ >= 0 && VEC_OP(T,length) (*vec_) <= (unsigned)size_,  \
+	"safe_grow");							  \
+  VEC_OP (T,reserve)							  \
+	(vec_, (int)(*vec_ ? (*vec_)->num : 0) - size_ VEC_ASSERT_PASS);  \
+  (*vec_)->num = size_;							  \
+}									  \
+									  \
+static inline T *VEC_OP (T,safe_push)					  \
+     (VEC(T) **vec_, T obj_ VEC_ASSERT_DECL)				  \
+{									  \
+  VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS);				  \
+									  \
+  return VEC_OP (T,quick_push) (*vec_, obj_ VEC_ASSERT_PASS);		  \
+}									  \
+									  \
+static inline T *VEC_OP (T,safe_insert)					  \
+     (VEC(T) **vec_, unsigned ix_, T obj_ VEC_ASSERT_DECL)		  \
+{									  \
+  VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS);				  \
+									  \
+  return VEC_OP (T,quick_insert) (*vec_, ix_, obj_ VEC_ASSERT_PASS);	  \
+}
+
+#define DEF_VEC_FUNC_O(T)						  \
+static inline unsigned VEC_OP (T,length) (const VEC(T) *vec_)		  \
+{									  \
+  return vec_ ? vec_->num : 0;						  \
+}									  \
+									  \
+static inline T *VEC_OP (T,last) (VEC(T) *vec_ VEC_ASSERT_DECL)		  \
+{									  \
+  vec_assert (vec_ && vec_->num, "last");				  \
+									  \
+  return &vec_->vec[vec_->num - 1];					  \
+}									  \
+									  \
+static inline T *VEC_OP (T,index)					  \
+     (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL)			  \
+{									  \
+  vec_assert (vec_ && ix_ < vec_->num, "index");			  \
+									  \
+  return &vec_->vec[ix_];						  \
+}									  \
+									  \
+static inline int VEC_OP (T,iterate)					  \
+     (VEC(T) *vec_, unsigned ix_, T **ptr)				  \
+{									  \
+  if (vec_ && ix_ < vec_->num)						  \
+    {									  \
+      *ptr = &vec_->vec[ix_];						  \
+      return 1;								  \
+    }									  \
+  else									  \
+    {									  \
+      *ptr = 0;								  \
+      return 0;								  \
+    }									  \
+}									  \
+									  \
+static inline size_t VEC_OP (T,embedded_size)				  \
+     (int alloc_)							  \
+{									  \
+  return offsetof (VEC(T),vec) + alloc_ * sizeof(T);			  \
+}									  \
+									  \
+static inline void VEC_OP (T,embedded_init)				  \
+     (VEC(T) *vec_, int alloc_)						  \
+{									  \
+  vec_->num = 0;							  \
+  vec_->alloc = alloc_;							  \
+}									  \
+									  \
+static inline int VEC_OP (T,space)					  \
+     (VEC(T) *vec_, int alloc_ VEC_ASSERT_DECL)				  \
+{									  \
+  vec_assert (alloc_ >= 0, "space");					  \
+  return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_;	  \
+}									  \
+									  \
+static inline T *VEC_OP (T,quick_push)					  \
+     (VEC(T) *vec_, const T *obj_ VEC_ASSERT_DECL)			  \
+{									  \
+  T *slot_;								  \
+									  \
+  vec_assert (vec_->num < vec_->alloc, "quick_push");			  \
+  slot_ = &vec_->vec[vec_->num++];					  \
+  if (obj_)								  \
+    *slot_ = *obj_;							  \
+									  \
+  return slot_;								  \
+}									  \
+									  \
+static inline void VEC_OP (T,pop) (VEC(T) *vec_ VEC_ASSERT_DECL)	  \
+{									  \
+  vec_assert (vec_->num, "pop");					  \
+  --vec_->num;								  \
+}									  \
+									  \
+static inline void VEC_OP (T,truncate)					  \
+     (VEC(T) *vec_, unsigned size_ VEC_ASSERT_DECL)			  \
+{									  \
+  vec_assert (vec_ ? vec_->num >= size_ : !size_, "truncate");		  \
+  if (vec_)								  \
+    vec_->num = size_;							  \
+}									  \
+									  \
+static inline T *VEC_OP (T,replace)					  \
+     (VEC(T) *vec_, unsigned ix_, const T *obj_ VEC_ASSERT_DECL)	  \
+{									  \
+  T *slot_;								  \
+									  \
+  vec_assert (ix_ < vec_->num, "replace");				  \
+  slot_ = &vec_->vec[ix_];						  \
+  if (obj_)								  \
+    *slot_ = *obj_;							  \
+									  \
+  return slot_;								  \
+}									  \
+									  \
+static inline T *VEC_OP (T,quick_insert)				  \
+     (VEC(T) *vec_, unsigned ix_, const T *obj_ VEC_ASSERT_DECL)	  \
+{									  \
+  T *slot_;								  \
+									  \
+  vec_assert (vec_->num < vec_->alloc && ix_ <= vec_->num, "quick_insert"); \
+  slot_ = &vec_->vec[ix_];						  \
+  memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T));		  \
+  if (obj_)								  \
+    *slot_ = *obj_;							  \
+									  \
+  return slot_;								  \
+}									  \
+									  \
+static inline void VEC_OP (T,ordered_remove)				  \
+     (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL)			  \
+{									  \
+  T *slot_;								  \
+									  \
+  vec_assert (ix_ < vec_->num, "ordered_remove");			  \
+  slot_ = &vec_->vec[ix_];						  \
+  memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T));		  \
+}									  \
+									  \
+static inline void VEC_OP (T,unordered_remove)				  \
+     (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL)			  \
+{									  \
+  vec_assert (ix_ < vec_->num, "unordered_remove");			  \
+  vec_->vec[ix_] = vec_->vec[--vec_->num];				  \
+}									  \
+									  \
+static inline void VEC_OP (T,block_remove)				  \
+     (VEC(T) *vec_, unsigned ix_, unsigned len_ VEC_ASSERT_DECL)	  \
+{									  \
+  T *slot_;								  \
+									  \
+  vec_assert (ix_ + len_ <= vec_->num, "block_remove");			  \
+  slot_ = &vec_->vec[ix_];						  \
+  vec_->num -= len_;							  \
+  memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T));	  \
+}									  \
+									  \
+static inline T *VEC_OP (T,address)					  \
+     (VEC(T) *vec_)							  \
+{									  \
+  return vec_ ? vec_->vec : 0;						  \
+}									  \
+									  \
+static inline unsigned VEC_OP (T,lower_bound)				  \
+     (VEC(T) *vec_, const T *obj_,					  \
+      int (*lessthan_)(const T *, const T *) VEC_ASSERT_DECL)		  \
+{									  \
+   unsigned int len_ = VEC_OP (T, length) (vec_);			  \
+   unsigned int half_, middle_;						  \
+   unsigned int first_ = 0;						  \
+   while (len_ > 0)							  \
+     {									  \
+        T *middle_elem_;						  \
+        half_ = len_ >> 1;						  \
+        middle_ = first_;						  \
+        middle_ += half_;						  \
+        middle_elem_ = VEC_OP (T,index) (vec_, middle_ VEC_ASSERT_PASS);  \
+        if (lessthan_ (middle_elem_, obj_))				  \
+          {								  \
+             first_ = middle_;						  \
+             ++first_;							  \
+             len_ = len_ - half_ - 1;					  \
+          }								  \
+        else								  \
+          len_ = half_;							  \
+     }									  \
+   return first_;							  \
+}
+
+#define DEF_VEC_ALLOC_FUNC_O(T)						  \
+static inline VEC(T) *VEC_OP (T,alloc)					  \
+     (int alloc_)							  \
+{									  \
+  /* We must request exact size allocation, hence the negation.  */	  \
+  return (VEC(T) *) vec_o_reserve (NULL, -alloc_,			  \
+                                   offsetof (VEC(T),vec), sizeof (T));	  \
+}									  \
+									  \
+static inline VEC(T) *VEC_OP (T,copy) (VEC(T) *vec_)			  \
+{									  \
+  size_t len_ = vec_ ? vec_->num : 0;					  \
+  VEC (T) *new_vec_ = NULL;						  \
+									  \
+  if (len_)								  \
+    {									  \
+      /* We must request exact size allocation, hence the negation. */	  \
+      new_vec_ = (VEC (T) *)						  \
+	vec_o_reserve  (NULL, -len_, offsetof (VEC(T),vec), sizeof (T));  \
+									  \
+      new_vec_->num = len_;						  \
+      memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_);		  \
+    }									  \
+  return new_vec_;							  \
+}									  \
+									  \
+static inline void VEC_OP (T,free)					  \
+     (VEC(T) **vec_)							  \
+{									  \
+  if (*vec_)								  \
+    vec_free (*vec_);							  \
+  *vec_ = NULL;								  \
+}									  \
+									  \
+static inline int VEC_OP (T,reserve)					  \
+     (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL)			  \
+{									  \
+  int extend = !VEC_OP (T,space) (*vec_, alloc_ < 0 ? -alloc_ : alloc_	  \
+				  VEC_ASSERT_PASS);			  \
+									  \
+  if (extend)								  \
+    *vec_ = (VEC(T) *)							  \
+	vec_o_reserve (*vec_, alloc_, offsetof (VEC(T),vec), sizeof (T)); \
+									  \
+  return extend;							  \
+}									  \
+									  \
+static inline void VEC_OP (T,safe_grow)					  \
+     (VEC(T) **vec_, int size_ VEC_ASSERT_DECL)				  \
+{									  \
+  vec_assert (size_ >= 0 && VEC_OP(T,length) (*vec_) <= (unsigned)size_,  \
+	"safe_grow");							  \
+  VEC_OP (T,reserve)							  \
+	(vec_, (int)(*vec_ ? (*vec_)->num : 0) - size_ VEC_ASSERT_PASS);  \
+  (*vec_)->num = size_;							  \
+}									  \
+									  \
+static inline T *VEC_OP (T,safe_push)					  \
+     (VEC(T) **vec_, const T *obj_ VEC_ASSERT_DECL)			  \
+{									  \
+  VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS);				  \
+									  \
+  return VEC_OP (T,quick_push) (*vec_, obj_ VEC_ASSERT_PASS);		  \
+}									  \
+									  \
+static inline T *VEC_OP (T,safe_insert)					  \
+     (VEC(T) **vec_, unsigned ix_, const T *obj_ VEC_ASSERT_DECL)	  \
+{									  \
+  VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS);				  \
+									  \
+  return VEC_OP (T,quick_insert) (*vec_, ix_, obj_ VEC_ASSERT_PASS);	  \
+}
+
+#endif /* GDB_VEC_H */