diff options
41 files changed, 45 insertions, 1312 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index e6bd246..8328a9b 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,46 @@ 2019-10-15 Andrew Burgess <andrew.burgess@embecosm.com> + * Makefile.in: Remove references to vec.h and vec.c. + * aarch64-tdep.c: No longer include vec.h. + * ada-lang.c: Likewise. + * ada-lang.h: Likewise. + * arm-tdep.c: Likewise. + * ax.h: Likewise. + * breakpoint.h: Likewise. + * charset.c: Likewise. + * cp-support.h: Likewise. + * dtrace-probe.c: Likewise. + * dwarf2read.c: Likewise. + * extension.h: Likewise. + * gdb_bfd.c: Likewise. + * gdbsupport/gdb_vecs.h: Likewise. + * gdbsupport/vec.c: Remove. + * gdbsupport/vec.h: Remove. + * gdbthread.h: Likewise. + * guile/scm-type.c: Likewise. + * inline-frame.c: Likewise. + * machoread.c: Likewise. + * memattr.c: Likewise. + * memrange.h: Likewise. + * namespace.h: Likewise. + * nat/linux-btrace.h: Likewise. + * osdata.c: Likewise. + * parser-defs.h: Likewise. + * progspace.h: Likewise. + * python/py-type.c: Likewise. + * record-btrace.c: Likewise. + * rust-exp.y: Likewise. + * solib-target.c: Likewise. + * stap-probe.c: Likewise. + * target-descriptions.c: Likewise. + * target-memory.c: Likewise. + * target.h: Likewise. + * varobj.c: Likewise. + * varobj.h: Likewise. + * xml-support.h: Likewise. + +2019-10-15 Andrew Burgess <andrew.burgess@embecosm.com> + * gdb/dwarf2read.c (dwarf2_per_objfile::~dwarf2_per_objfile): Update for new std::vector based implementation. (process_psymtab_comp_unit_reader): Likewise. diff --git a/gdb/Makefile.in b/gdb/Makefile.in index 36650ad..af4b14d 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -980,7 +980,6 @@ COMMON_SFILES = \ gdbsupport/signals.c \ gdbsupport/signals-state-save-restore.c \ gdbsupport/tdesc.c \ - gdbsupport/vec.c \ gdbsupport/xml-utils.c \ complaints.c \ completer.c \ @@ -1480,7 +1479,6 @@ HFILES_NO_SRCDIR = \ gdbsupport/signals-state-save-restore.h \ gdbsupport/symbol.h \ gdbsupport/tdesc.h \ - gdbsupport/vec.h \ gdbsupport/version.h \ gdbsupport/x86-xstate.h \ gdbsupport/xml-utils.h \ diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c index e512118..d1ee78d 100644 --- a/gdb/aarch64-tdep.c +++ b/gdb/aarch64-tdep.c @@ -52,8 +52,6 @@ #include "elf-bfd.h" #include "elf/aarch64.h" -#include "gdbsupport/vec.h" - #include "record.h" #include "record-full.h" #include "arch/aarch64-insn.h" diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 154f985..a2ae89d 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -49,7 +49,6 @@ #include "valprint.h" #include "source.h" #include "observable.h" -#include "gdbsupport/vec.h" #include "stack.h" #include "gdbsupport/gdb_vecs.h" #include "typeprint.h" diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h index c7279d5..b68dd4e 100644 --- a/gdb/ada-lang.h +++ b/gdb/ada-lang.h @@ -28,7 +28,6 @@ struct parser_state; #include "value.h" #include "gdbtypes.h" #include "breakpoint.h" -#include "gdbsupport/vec.h" /* Names of specific files known to be part of the runtime system and that might consider (confusing) debugging information. diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c index c247052..5c1476a 100644 --- a/gdb/arm-tdep.c +++ b/gdb/arm-tdep.c @@ -55,8 +55,6 @@ #include "coff/internal.h" #include "elf/arm.h" -#include "gdbsupport/vec.h" - #include "record.h" #include "record-full.h" #include <algorithm> @@ -19,8 +19,6 @@ #ifndef AX_H #define AX_H -#include "gdbsupport/vec.h" - /* It's sometimes useful to be able to debug programs that you can't really stop for more than a fraction of a second. To this end, the user can specify a tracepoint (like a breakpoint, but you don't diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h index 7472c0e..da26f64 100644 --- a/gdb/breakpoint.h +++ b/gdb/breakpoint.h @@ -21,7 +21,6 @@ #include "frame.h" #include "value.h" -#include "gdbsupport/vec.h" #include "ax.h" #include "command.h" #include "gdbsupport/break-common.h" diff --git a/gdb/charset.c b/gdb/charset.c index 7313165..7568e47 100644 --- a/gdb/charset.c +++ b/gdb/charset.c @@ -23,7 +23,6 @@ #include "gdb_obstack.h" #include "gdbsupport/gdb_wait.h" #include "charset-list.h" -#include "gdbsupport/vec.h" #include "gdbsupport/environ.h" #include "arch-utils.h" #include "gdbsupport/gdb_vecs.h" diff --git a/gdb/cp-support.h b/gdb/cp-support.h index 9878507..a2be977 100644 --- a/gdb/cp-support.h +++ b/gdb/cp-support.h @@ -25,7 +25,6 @@ /* We need this for 'domain_enum', alas... */ #include "symtab.h" -#include "gdbsupport/vec.h" #include "gdbsupport/gdb_vecs.h" #include "gdb_obstack.h" #include "gdbsupport/array-view.h" diff --git a/gdb/dtrace-probe.c b/gdb/dtrace-probe.c index e9e71fd..9eaed2b 100644 --- a/gdb/dtrace-probe.c +++ b/gdb/dtrace-probe.c @@ -21,7 +21,6 @@ #include "defs.h" #include "probe.h" -#include "gdbsupport/vec.h" #include "elf-bfd.h" #include "gdbtypes.h" #include "obstack.h" diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index ab3f43c..0443b55 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -55,7 +55,6 @@ #include "addrmap.h" #include "typeprint.h" #include "psympriv.h" -#include "gdbsupport/vec.h" #include "c-lang.h" #include "go-lang.h" #include "valprint.h" diff --git a/gdb/extension.h b/gdb/extension.h index 581afc2..fc8e3e2 100644 --- a/gdb/extension.h +++ b/gdb/extension.h @@ -21,7 +21,6 @@ #define EXTENSION_H #include "mi/mi-cmds.h" /* For PRINT_NO_VALUES, etc. */ -#include "gdbsupport/vec.h" #include "gdbsupport/array-view.h" struct breakpoint; diff --git a/gdb/gdb_bfd.c b/gdb/gdb_bfd.c index 69618a2..2a070d7 100644 --- a/gdb/gdb_bfd.c +++ b/gdb/gdb_bfd.c @@ -23,7 +23,6 @@ #include "gdbcmd.h" #include "hashtab.h" #include "gdbsupport/filestuff.h" -#include "gdbsupport/vec.h" #ifdef HAVE_MMAP #include <sys/mman.h> #ifndef MAP_FAILED diff --git a/gdb/gdbserver/ChangeLog b/gdb/gdbserver/ChangeLog index 1b67a28..402546b 100644 --- a/gdb/gdbserver/ChangeLog +++ b/gdb/gdbserver/ChangeLog @@ -1,3 +1,7 @@ +2019-10-15 Andrew Burgess <andrew.burgess@embecosm.com> + + * Makefile.in: Remove references to vec.c. + 2019-10-02 Christian Biesinger <cbiesinger@google.com> * server.c (server_waiting): Change to bool. diff --git a/gdb/gdbserver/Makefile.in b/gdb/gdbserver/Makefile.in index d79424b..c83cb3d 100644 --- a/gdb/gdbserver/Makefile.in +++ b/gdb/gdbserver/Makefile.in @@ -221,7 +221,6 @@ SFILES = \ $(srcdir)/gdbsupport/ptid.c \ $(srcdir)/gdbsupport/rsp-low.c \ $(srcdir)/gdbsupport/tdesc.c \ - $(srcdir)/gdbsupport/vec.c \ $(srcdir)/gdbsupport/xml-utils.c \ $(srcdir)/nat/aarch64-sve-linux-ptrace.c \ $(srcdir)/nat/linux-btrace.c \ @@ -270,7 +269,6 @@ OBS = \ gdbsupport/signals.o \ gdbsupport/signals-state-save-restore.o \ gdbsupport/tdesc.o \ - gdbsupport/vec.o \ gdbsupport/xml-utils.o \ debug.o \ dll.o \ diff --git a/gdb/gdbsupport/gdb_vecs.h b/gdb/gdbsupport/gdb_vecs.h index 017bf93..e87ebe2 100644 --- a/gdb/gdbsupport/gdb_vecs.h +++ b/gdb/gdbsupport/gdb_vecs.h @@ -20,8 +20,6 @@ #ifndef COMMON_GDB_VECS_H #define COMMON_GDB_VECS_H -#include "vec.h" - /* Split STR, a list of DELIMITER-separated fields, into a char pointer vector. You may modify the returned strings. */ diff --git a/gdb/gdbsupport/vec.c b/gdb/gdbsupport/vec.c deleted file mode 100644 index a889544..0000000 --- a/gdb/gdbsupport/vec.c +++ /dev/null @@ -1,118 +0,0 @@ -/* Vector API for GDB. - Copyright (C) 2004-2019 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 3 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, see <http://www.gnu.org/licenses/>. */ - -#include "common-defs.h" -#include "vec.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 = (struct vec_prefix *) 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/gdbsupport/vec.h b/gdb/gdbsupport/vec.h deleted file mode 100644 index 8ac146d..0000000 --- a/gdb/gdbsupport/vec.h +++ /dev/null @@ -1,1150 +0,0 @@ -/* Vector API for GDB. - Copyright (C) 2004-2019 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 3 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, see <http://www.gnu.org/licenses/>. */ - -#ifndef COMMON_VEC_H -#define COMMON_VEC_H - -#include "diagnostics.h" - -/* clang has a bug that makes it warn (-Wunused-function) about unused functions - that are the result of the DEF_VEC_* macro expansion. See: - - https://bugs.llvm.org/show_bug.cgi?id=22712 - - We specifically ignore this warning for the vec functions when the compiler - is clang. */ -#ifdef __clang__ -# define DIAGNOSTIC_IGNORE_UNUSED_VEC_FUNCTION \ - DIAGNOSTIC_IGNORE_UNUSED_FUNCTION -#else -# define DIAGNOSTIC_IGNORE_UNUSED_VEC_FUNCTION -#endif - -/* 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)) - -/* A cleanup function for a vector. - void VEC_T_cleanup(void *); - - Clean up a vector. */ - -#define VEC_cleanup(T) (VEC_OP(T,cleanup)) - -/* 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)) - -/* Merge two vectors. - VEC(T,A) *VEC_T_merge(VEC(T) *, VEC(T) *); - - Copy the live elements of both vectors into a new vector. The new - and old vectors need not be allocated by the same mechanism. */ -#define VEC_merge(T,V1,V2) (VEC_OP(T,merge)(V1, V2)) - -/* 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(N) operation due to memmove. */ - -#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_, \ - FUNCTION_NAME), 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) \ -DIAGNOSTIC_PUSH \ -DIAGNOSTIC_IGNORE_UNUSED_VEC_FUNCTION \ -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) \ -DIAGNOSTIC_POP \ -struct vec_swallow_trailing_semi - -/* Vector of pointer to object. */ -#define DEF_VEC_P(T) \ -DIAGNOSTIC_PUSH \ -DIAGNOSTIC_IGNORE_UNUSED_VEC_FUNCTION \ -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) \ -DIAGNOSTIC_POP \ -struct vec_swallow_trailing_semi - -/* Vector of object. */ -#define DEF_VEC_O(T) \ -DIAGNOSTIC_PUSH \ -DIAGNOSTIC_IGNORE_UNUSED_VEC_FUNCTION \ -VEC_T(T); \ -DEF_VEC_FUNC_O(T) \ -DEF_VEC_ALLOC_FUNC_O(T) \ -DIAGNOSTIC_POP \ -struct vec_swallow_trailing_semi - -/* Avoid offsetof (or its usual C implementation) as it triggers - -Winvalid-offsetof warnings with enum_flags types with G++ <= 4.4, - even though those types are memcpyable. This requires allocating a - dummy local VEC in all routines that use this, but that has the - advantage that it only works if T is default constructible, which - is exactly a check we want, to keep C compatibility. */ -#define vec_offset(T, VPTR) ((size_t) ((char *) &(VPTR)->vec - (char *) VPTR)) - -#define DEF_VEC_ALLOC_FUNC_I(T) \ -static inline VEC(T) *VEC_OP (T,alloc) \ - (int alloc_) \ -{ \ - VEC(T) dummy; \ - \ - /* We must request exact size allocation, hence the negation. */ \ - return (VEC(T) *) vec_o_reserve (NULL, -alloc_, \ - vec_offset (T, &dummy), 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_) \ - { \ - VEC(T) dummy; \ - \ - /* We must request exact size allocation, hence the negation. */ \ - new_vec_ = (VEC (T) *) \ - vec_o_reserve (NULL, -len_, vec_offset (T, &dummy), sizeof (T)); \ - \ - new_vec_->num = len_; \ - memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_); \ - } \ - return new_vec_; \ -} \ - \ -static inline VEC(T) *VEC_OP (T,merge) (VEC(T) *vec1_, VEC(T) *vec2_) \ -{ \ - if (vec1_ && vec2_) \ - { \ - VEC(T) dummy; \ - size_t len_ = vec1_->num + vec2_->num; \ - VEC (T) *new_vec_ = NULL; \ - \ - /* We must request exact size allocation, hence the negation. */ \ - new_vec_ = (VEC (T) *) \ - vec_o_reserve (NULL, -len_, vec_offset (T, &dummy), sizeof (T)); \ - \ - new_vec_->num = len_; \ - memcpy (new_vec_->vec, vec1_->vec, sizeof (T) * vec1_->num); \ - memcpy (new_vec_->vec + vec1_->num, vec2_->vec, \ - sizeof (T) * vec2_->num); \ - \ - return new_vec_; \ - } \ - else \ - return VEC_copy (T, vec1_ ? vec1_ : vec2_); \ -} \ - \ -static inline void VEC_OP (T,free) \ - (VEC(T) **vec_) \ -{ \ - if (*vec_) \ - vec_free_ (*vec_); \ - *vec_ = NULL; \ -} \ - \ -static inline void VEC_OP (T,cleanup) \ - (void *arg_) \ -{ \ - VEC(T) **vec_ = (VEC(T) **) arg_; \ - if (*vec_) \ - vec_free_ (*vec_); \ - *vec_ = NULL; \ -} \ - \ -static inline int VEC_OP (T,reserve) \ - (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL) \ -{ \ - VEC(T) dummy; \ - int extend = !VEC_OP (T,space) \ - (*vec_, alloc_ < 0 ? -alloc_ : alloc_ VEC_ASSERT_PASS); \ - \ - if (extend) \ - *vec_ = (VEC(T) *) vec_o_reserve (*vec_, alloc_, \ - vec_offset (T, &dummy), 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 = (T) 0; \ - return 0; \ - } \ -} \ - \ -static inline size_t VEC_OP (T,embedded_size) \ - (int alloc_) \ -{ \ - VEC(T) dummy; \ - \ - return vec_offset (T, &dummy) + 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 void VEC_OP (T,cleanup) \ - (void *arg_) \ -{ \ - VEC(T) **vec_ = (VEC(T) **) arg_; \ - 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 VEC(T) *VEC_OP (T,merge) (VEC(T) *vec1_, VEC(T) *vec2_) \ -{ \ - if (vec1_ && vec2_) \ - { \ - size_t len_ = vec1_->num + vec2_->num; \ - VEC (T) *new_vec_ = NULL; \ - \ - /* 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, vec1_->vec, sizeof (T) * vec1_->num); \ - memcpy (new_vec_->vec + vec1_->num, vec2_->vec, \ - sizeof (T) * vec2_->num); \ - \ - return new_vec_; \ - } \ - else \ - return VEC_copy (T, vec1_ ? vec1_ : vec2_); \ -} \ - \ -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_) \ -{ \ - VEC(T) dummy; \ - \ - return vec_offset (T, &dummy) + 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_) \ -{ \ - VEC(T) dummy; \ - \ - /* We must request exact size allocation, hence the negation. */ \ - return (VEC(T) *) vec_o_reserve (NULL, -alloc_, \ - vec_offset (T, &dummy), 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_) \ - { \ - VEC(T) dummy; \ - \ - /* We must request exact size allocation, hence the negation. */ \ - new_vec_ = (VEC (T) *) \ - vec_o_reserve (NULL, -len_, vec_offset (T, &dummy), sizeof (T)); \ - \ - new_vec_->num = len_; \ - memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_); \ - } \ - return new_vec_; \ -} \ - \ -static inline VEC(T) *VEC_OP (T,merge) (VEC(T) *vec1_, VEC(T) *vec2_) \ -{ \ - if (vec1_ && vec2_) \ - { \ - VEC(T) dummy; \ - size_t len_ = vec1_->num + vec2_->num; \ - VEC (T) *new_vec_ = NULL; \ - \ - /* We must request exact size allocation, hence the negation. */ \ - new_vec_ = (VEC (T) *) \ - vec_o_reserve (NULL, -len_, vec_offset (T, &dummy), sizeof (T)); \ - \ - new_vec_->num = len_; \ - memcpy (new_vec_->vec, vec1_->vec, sizeof (T) * vec1_->num); \ - memcpy (new_vec_->vec + vec1_->num, vec2_->vec, \ - sizeof (T) * vec2_->num); \ - \ - return new_vec_; \ - } \ - else \ - return VEC_copy (T, vec1_ ? vec1_ : vec2_); \ -} \ - \ -static inline void VEC_OP (T,free) \ - (VEC(T) **vec_) \ -{ \ - if (*vec_) \ - vec_free_ (*vec_); \ - *vec_ = NULL; \ -} \ - \ -static inline void VEC_OP (T,cleanup) \ - (void *arg_) \ -{ \ - VEC(T) **vec_ = (VEC(T) **) arg_; \ - if (*vec_) \ - vec_free_ (*vec_); \ - *vec_ = NULL; \ -} \ - \ -static inline int VEC_OP (T,reserve) \ - (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL) \ -{ \ - VEC(T) dummy; \ - int extend = !VEC_OP (T,space) (*vec_, alloc_ < 0 ? -alloc_ : alloc_ \ - VEC_ASSERT_PASS); \ - \ - if (extend) \ - *vec_ = (VEC(T) *) \ - vec_o_reserve (*vec_, alloc_, vec_offset (T, &dummy), 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 /* COMMON_VEC_H */ diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h index 0daea9c..370141e 100644 --- a/gdb/gdbthread.h +++ b/gdb/gdbthread.h @@ -27,7 +27,6 @@ struct symtab; #include "frame.h" #include "ui-out.h" #include "btrace.h" -#include "gdbsupport/vec.h" #include "target/waitstatus.h" #include "cli/cli-utils.h" #include "gdbsupport/refcounted-object.h" diff --git a/gdb/guile/scm-type.c b/gdb/guile/scm-type.c index b32ec4f..953e17b 100644 --- a/gdb/guile/scm-type.c +++ b/gdb/guile/scm-type.c @@ -26,7 +26,6 @@ #include "gdbtypes.h" #include "objfiles.h" #include "language.h" -#include "gdbsupport/vec.h" #include "bcache.h" #include "dwarf2loc.h" #include "typeprint.h" diff --git a/gdb/inline-frame.c b/gdb/inline-frame.c index b039ab8..5840e3e 100644 --- a/gdb/inline-frame.c +++ b/gdb/inline-frame.c @@ -27,7 +27,6 @@ #include "gdbthread.h" #include "regcache.h" #include "symtab.h" -#include "gdbsupport/vec.h" #include "frame.h" #include <algorithm> diff --git a/gdb/machoread.c b/gdb/machoread.c index a015d29..db884b0 100644 --- a/gdb/machoread.c +++ b/gdb/machoread.c @@ -28,7 +28,6 @@ #include "gdbcore.h" #include "mach-o.h" #include "aout/stab_gnu.h" -#include "gdbsupport/vec.h" #include "psympriv.h" #include "complaints.h" #include "gdb_bfd.h" diff --git a/gdb/memattr.c b/gdb/memattr.c index 0475780..7a961af 100644 --- a/gdb/memattr.c +++ b/gdb/memattr.c @@ -25,7 +25,6 @@ #include "target-dcache.h" #include "value.h" #include "language.h" -#include "gdbsupport/vec.h" #include "breakpoint.h" #include "cli/cli-utils.h" #include <algorithm> diff --git a/gdb/memrange.h b/gdb/memrange.h index f2fd664..4f84e20 100644 --- a/gdb/memrange.h +++ b/gdb/memrange.h @@ -20,8 +20,6 @@ #ifndef MEMRANGE_H #define MEMRANGE_H -#include "gdbsupport/vec.h" - /* Defines a [START, START + LENGTH) memory range. */ struct mem_range diff --git a/gdb/namespace.h b/gdb/namespace.h index 740d5b0..980b1eb 100644 --- a/gdb/namespace.h +++ b/gdb/namespace.h @@ -19,7 +19,6 @@ #ifndef NAMESPACE_H #define NAMESPACE_H -#include "gdbsupport/vec.h" #include "gdbsupport/gdb_vecs.h" #include "gdb_obstack.h" diff --git a/gdb/nat/linux-btrace.h b/gdb/nat/linux-btrace.h index 1d5c745..0520ae4 100644 --- a/gdb/nat/linux-btrace.h +++ b/gdb/nat/linux-btrace.h @@ -23,7 +23,6 @@ #define NAT_LINUX_BTRACE_H #include "gdbsupport/btrace-common.h" -#include "gdbsupport/vec.h" #if HAVE_LINUX_PERF_EVENT_H # include <linux/perf_event.h> #endif diff --git a/gdb/osdata.c b/gdb/osdata.c index ea3b7dc..4bd1a0b 100644 --- a/gdb/osdata.c +++ b/gdb/osdata.c @@ -19,7 +19,6 @@ #include "defs.h" #include "target.h" -#include "gdbsupport/vec.h" #include "xml-support.h" #include "osdata.h" #include "ui-out.h" diff --git a/gdb/parser-defs.h b/gdb/parser-defs.h index 64aa9b8..b6c7753 100644 --- a/gdb/parser-defs.h +++ b/gdb/parser-defs.h @@ -23,7 +23,6 @@ #if !defined (PARSER_DEFS_H) #define PARSER_DEFS_H 1 -#include "gdbsupport/vec.h" #include "expression.h" #include "symtab.h" diff --git a/gdb/progspace.h b/gdb/progspace.h index 073da1f..5a053b9 100644 --- a/gdb/progspace.h +++ b/gdb/progspace.h @@ -22,7 +22,6 @@ #define PROGSPACE_H #include "target.h" -#include "gdbsupport/vec.h" #include "gdb_bfd.h" #include "gdbsupport/gdb_vecs.h" #include "registry.h" diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c index 134f76d..a2fca97 100644 --- a/gdb/python/py-type.c +++ b/gdb/python/py-type.c @@ -26,7 +26,6 @@ #include "demangle.h" #include "objfiles.h" #include "language.h" -#include "gdbsupport/vec.h" #include "typeprint.h" typedef struct pyty_type_object diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index c923b36..65dfe70 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -38,7 +38,6 @@ #include "infrun.h" #include "event-loop.h" #include "inf-loop.h" -#include "gdbsupport/vec.h" #include "inferior.h" #include <algorithm> #include "gdbarch.h" diff --git a/gdb/rust-exp.y b/gdb/rust-exp.y index 60ce2cd..a15e0de 100644 --- a/gdb/rust-exp.y +++ b/gdb/rust-exp.y @@ -40,7 +40,6 @@ #include "parser-defs.h" #include "gdbsupport/selftest.h" #include "value.h" -#include "gdbsupport/vec.h" #include "gdbarch.h" #define GDB_YY_REMAP_PREFIX rust diff --git a/gdb/solib-target.c b/gdb/solib-target.c index 3fd1808..2b473d6 100644 --- a/gdb/solib-target.c +++ b/gdb/solib-target.c @@ -23,7 +23,6 @@ #include "symtab.h" #include "symfile.h" #include "target.h" -#include "gdbsupport/vec.h" #include "solib-target.h" #include <vector> diff --git a/gdb/stap-probe.c b/gdb/stap-probe.c index 700b657..ea206cb 100644 --- a/gdb/stap-probe.c +++ b/gdb/stap-probe.c @@ -20,7 +20,6 @@ #include "defs.h" #include "stap-probe.h" #include "probe.h" -#include "gdbsupport/vec.h" #include "ui-out.h" #include "objfiles.h" #include "arch-utils.h" diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c index 6bd08d9..f4368bb 100644 --- a/gdb/target-descriptions.c +++ b/gdb/target-descriptions.c @@ -26,7 +26,6 @@ #include "reggroups.h" #include "target.h" #include "target-descriptions.h" -#include "gdbsupport/vec.h" #include "xml-support.h" #include "xml-tdesc.h" #include "osabi.h" diff --git a/gdb/target-memory.c b/gdb/target-memory.c index ce964ba..4b84431 100644 --- a/gdb/target-memory.c +++ b/gdb/target-memory.c @@ -19,7 +19,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "defs.h" -#include "gdbsupport/vec.h" #include "target.h" #include "memory-map.h" diff --git a/gdb/target.h b/gdb/target.h index 8dbd2d6..91e8a83 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -74,7 +74,6 @@ struct inferior; #include "bfd.h" #include "symtab.h" #include "memattr.h" -#include "gdbsupport/vec.h" #include "gdbsupport/gdb_signals.h" #include "btrace.h" #include "record.h" diff --git a/gdb/varobj.c b/gdb/varobj.c index 827a1b0..6265b2f 100644 --- a/gdb/varobj.c +++ b/gdb/varobj.c @@ -26,7 +26,6 @@ #include "gdb_regex.h" #include "varobj.h" -#include "gdbsupport/vec.h" #include "gdbthread.h" #include "inferior.h" #include "varobj-iter.h" diff --git a/gdb/varobj.h b/gdb/varobj.h index 8f00d78..eb01da1 100644 --- a/gdb/varobj.h +++ b/gdb/varobj.h @@ -19,7 +19,6 @@ #include "symtab.h" #include "gdbtypes.h" -#include "gdbsupport/vec.h" #include "value.h" /* Enumeration for the format types */ diff --git a/gdb/xml-support.h b/gdb/xml-support.h index 7ceb938..5012767 100644 --- a/gdb/xml-support.h +++ b/gdb/xml-support.h @@ -22,7 +22,6 @@ #define XML_SUPPORT_H #include "gdb_obstack.h" -#include "gdbsupport/vec.h" #include "gdbsupport/xml-utils.h" #include "gdbsupport/byte-vector.h" #include "gdbsupport/gdb_optional.h" |