Skip to content

R
riscv-gcc-1
Commit 7de5bccc by Nathan Sidwell Committed by Nathan Sidwell
Options

vec.c (vec_p_reserve, [...]): Allocation is signed. 

.:	* vec.c (vec_p_reserve, vec_o_reserve): Allocation is signed.
	* vec.h (VEC_alloc, VEC_embedded_size, VEC_embedded_init):
	Allocation is signed.
	(VEC_reserve): Return flag, allocation is signed.
cp:
	* name-lookup.c (push_binding): Use VEC_reserve.

From-SVN: r84281
parent 5df6d966
Showing with 95 additions and 67 deletions
gcc/ChangeLog
2004-07-08 Nathan Sidwell <nathan@codesourcery.com>
* vec.c (vec_p_reserve, vec_o_reserve): Allocation is signed.
* vec.h (VEC_alloc, VEC_embedded_size, VEC_embedded_init):
Allocation is signed.
(VEC_reserve): Return flag, allocation is signed.
2004-07-08 Richard Henderson <rth@redhat.com> 2004-07-08 Richard Henderson <rth@redhat.com>
* tree-ssa-ccp.c (fold_stmt): Get type directly from * tree-ssa-ccp.c (fold_stmt): Get type directly from
......
gcc/cp/ChangeLog
2004-07-08 Nathan Sidwell <nathan@codesourcery.com>
* name-lookup.c (push_binding): Use VEC_reserve.
2004-07-08 Richard Henderson <rth@redhat.com> 2004-07-08 Richard Henderson <rth@redhat.com>
* cp-tree.h (expand_eh_spec_block): Remove. * cp-tree.h (expand_eh_spec_block): Remove.
......
gcc/cp/name-lookup.c
...@@ -381,22 +381,22 @@ push_binding (tree id, tree decl, cxx_scope* level) ...@@ -381,22 +381,22 @@ push_binding (tree id, tree decl, cxx_scope* level)
else else
{ {
cp_class_binding *cb; cp_class_binding *cb;
size_t length;
size_t i;
bool need_fixup;
length = VEC_length (cp_class_binding, level->class_shadowed); if (VEC_reserve (cp_class_binding, level->class_shadowed, -1))
need_fixup = (length && length == level->class_shadowed->alloc); {
cb = VEC_safe_push (cp_class_binding, level->class_shadowed, NULL); /* Fixup the current bindings, as they might have moved. */
size_t i;
for (i = 0;
(cb = VEC_iterate (cp_class_binding, level->class_shadowed, i));
i++)
IDENTIFIER_BINDING (cb->identifier) = &cb->base;
}
cb = VEC_quick_push (cp_class_binding, level->class_shadowed, NULL);
cb->identifier = id; cb->identifier = id;
binding = &cb->base; binding = &cb->base;
cxx_binding_init (binding, decl, NULL_TREE); cxx_binding_init (binding, decl, NULL_TREE);
if (need_fixup)
for (i = 0; i < length; ++i)
{
cb = VEC_index (cp_class_binding, level->class_shadowed, i);
IDENTIFIER_BINDING (cb->identifier) = &cb->base;
}
} }
/* Now, fill in the binding information. */ /* Now, fill in the binding information. */
......
gcc/vec.c
...@@ -34,44 +34,45 @@ struct vec_prefix ...@@ -34,44 +34,45 @@ struct vec_prefix
void *vec[1]; void *vec[1];
}; };
/* Ensure there are at least RESERVE free slots in VEC, if RESERVE != /* Ensure there are at least RESERVE free slots in VEC, if RESERVE >=
~0u. If RESERVE == ~0u increase the current allocation 0. If RESERVE < 0 increase the current allocation exponentially.
exponentially. VEC can be NULL, to create a new vector. */ VEC can be NULL, to create a new vector. */
void * void *
vec_p_reserve (void *vec, size_t reserve MEM_STAT_DECL) vec_p_reserve (void *vec, int reserve MEM_STAT_DECL)
{ {
return vec_o_reserve (vec, reserve, return vec_o_reserve (vec, reserve,
offsetof (struct vec_prefix, vec), sizeof (void *) offsetof (struct vec_prefix, vec), sizeof (void *)
PASS_MEM_STAT); PASS_MEM_STAT);
} }
/* Ensure there are at least RESERVE free slots in VEC, if RESERVE != /* Ensure there are at least RESERVE free slots in VEC, if RESERVE >=
~0u. If RESERVE == ~0u, increase the current allocation 0. If RESERVE < 0, increase the current allocation exponentially.
exponentially. VEC can be NULL, in which case a new vector is VEC can be NULL, in which case a new vector is created. The
created. The vector's trailing array is at VEC_OFFSET offset and vector's trailing array is at VEC_OFFSET offset and consistes of
consistes of ELT_SIZE sized elements. */ ELT_SIZE sized elements. */
void * void *
vec_o_reserve (void *vec, size_t reserve, size_t vec_offset, size_t elt_size vec_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size
MEM_STAT_DECL) MEM_STAT_DECL)
{ {
struct vec_prefix *pfx = vec; struct vec_prefix *pfx = vec;
size_t alloc; size_t alloc = pfx ? pfx->num : 0;
if (reserve + 1) if (reserve >= 0)
alloc = (pfx ? pfx->num : 0) + reserve; alloc += reserve;
else if (alloc)
alloc *= 2;
else else
alloc = pfx ? pfx->alloc * 2 : 4; alloc = 4;
if (pfx && pfx->alloc >= alloc)
abort ();
if (!pfx || pfx->alloc < alloc) vec = ggc_realloc_stat (vec, vec_offset + alloc * elt_size PASS_MEM_STAT);
{ ((struct vec_prefix *)vec)->alloc = alloc;
vec = ggc_realloc_stat (vec, vec_offset + alloc * elt_size if (!pfx)
PASS_MEM_STAT); ((struct vec_prefix *)vec)->num = 0;
((struct vec_prefix *)vec)->alloc = alloc;
if (!pfx)
((struct vec_prefix *)vec)->num = 0;
}
return vec; return vec;
} }
......
gcc/vec.h
...@@ -58,7 +58,9 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA ...@@ -58,7 +58,9 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
vector, if needed. Reallocation causes an exponential increase in vector, if needed. Reallocation causes an exponential increase in
vector size. If you know you will be adding N elements, it would vector size. If you know you will be adding N elements, it would
be more efficient to use the reserve operation before adding the be more efficient to use the reserve operation before adding the
elements with the 'quick' operation. elements with the 'quick' operation. You may also use the reserve
operation with a -1 operand, to gain control over exactly when
reallocation occurs.
You should prefer the push and pop operations, as they append and 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 remove from the end of the vector. If you need to remove several
...@@ -132,27 +134,33 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA ...@@ -132,27 +134,33 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#define VEC_iterate(TDEF,V,I) (VEC_OP(TDEF,iterate)(V,I)) #define VEC_iterate(TDEF,V,I) (VEC_OP(TDEF,iterate)(V,I))
/* Allocate new vector. /* Allocate new vector.
VEC(T) *VEC_T_alloc(size_t reserve); VEC(T) *VEC_T_alloc(int reserve);
Allocate a new vector with space for RESERVE objects. */ Allocate a new vector with space for RESERVE objects. If RESERVE
is <= 0, a default number of slots are created. */
#define VEC_alloc(TDEF,A) (VEC_OP(TDEF,alloc)(A MEM_STAT_INFO)) #define VEC_alloc(TDEF,A) (VEC_OP(TDEF,alloc)(A MEM_STAT_INFO))
/* Use these to determine the required size and initialization of a /* Use these to determine the required size and initialization of a
vector embedded within another structure (as the final member). vector embedded within another structure (as the final member).
size_t VEC_T_embedded_size(size_t reserve); size_t VEC_T_embedded_size(int reserve);
void VEC_T_embedded_init(VEC(T) *v, size_t reserve); void VEC_T_embedded_init(VEC(T) *v, int reserve);
These allow the caller to perform the memory allocation. */ These allow the caller to perform the memory allocation. */
#define VEC_embedded_size(TDEF,A) (VEC_OP(TDEF,embedded_size)(A)) #define VEC_embedded_size(TDEF,A) (VEC_OP(TDEF,embedded_size)(A))
#define VEC_embedded_init(TDEF,O,A) (VEC_OP(TDEF,embedded_init)(O,A)) #define VEC_embedded_init(TDEF,O,A) (VEC_OP(TDEF,embedded_init)(O,A))
/* Reserve space. /* Reserve space.
void VEC_T_reserve(VEC(T) *&v, size_t reserve); int VEC_T_reserve(VEC(T) *&v, int reserve);
Ensure that V has at least RESERVE slots available. Note this can Ensure that V has at least RESERVE slots available, if RESERVE is
cause V to be reallocated. */ >= 0. If RESERVE < 0, ensure that there is at least one spare
#define VEC_reserve(TDEF,V,R) (VEC_OP(TDEF,reserve)(&(V),R MEM_STAT_INFO)) slot. These differ in their reallocation behaviour, the first will
not create additionsl headroom, but the second mechanism will
perform the usual exponential headroom increase. Note this can
cause V to be reallocated. Returns non-zero iff reallocation
actually occurred. */
#define VEC_reserve(TDEF,V,R) (VEC_OP(TDEF,reserve)(&(V),R MEM_STAT_INFO))
/* Push object with no reallocation /* Push object with no reallocation
T *VEC_T_quick_push (VEC(T) *v, T obj); // Pointer T *VEC_T_quick_push (VEC(T) *v, T obj); // Pointer
...@@ -238,8 +246,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA ...@@ -238,8 +246,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#if !IN_GENGTYPE #if !IN_GENGTYPE
/* Reallocate an array of elements with prefix. */ /* Reallocate an array of elements with prefix. */
extern void *vec_p_reserve (void *, size_t MEM_STAT_DECL); extern void *vec_p_reserve (void *, int MEM_STAT_DECL);
extern void *vec_o_reserve (void *, size_t, size_t, size_t MEM_STAT_DECL); extern void *vec_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL);
#if ENABLE_CHECKING #if ENABLE_CHECKING
extern void vec_assert_fail (const char *, const char *, extern void vec_assert_fail (const char *, const char *,
...@@ -310,28 +318,34 @@ static inline TDEF VEC_OP (TDEF,iterate) \ ...@@ -310,28 +318,34 @@ static inline TDEF VEC_OP (TDEF,iterate) \
} \ } \
\ \
static inline VEC (TDEF) *VEC_OP (TDEF,alloc MEM_STAT_DECL) \ static inline VEC (TDEF) *VEC_OP (TDEF,alloc MEM_STAT_DECL) \
(size_t alloc_) \ (int alloc_) \
{ \ { \
return vec_p_reserve (NULL, alloc_ - !alloc_ PASS_MEM_STAT); \ return vec_p_reserve (NULL, alloc_ - !alloc_ PASS_MEM_STAT); \
} \ } \
\ \
static inline size_t VEC_OP (TDEF,embedded_size) \ static inline size_t VEC_OP (TDEF,embedded_size) \
(size_t alloc_) \ (int alloc_) \
{ \ { \
return offsetof (VEC(TDEF),vec) + alloc_ * sizeof(TDEF); \ return offsetof (VEC(TDEF),vec) + alloc_ * sizeof(TDEF); \
} \ } \
\ \
static inline void VEC_OP (TDEF,embedded_init) \ static inline void VEC_OP (TDEF,embedded_init) \
(VEC (TDEF) *vec_, size_t alloc_) \ (VEC (TDEF) *vec_, int alloc_) \
{ \ { \
vec_->num = 0; \ vec_->num = 0; \
vec_->alloc = alloc_; \ vec_->alloc = alloc_; \
} \ } \
\ \
static inline void VEC_OP (TDEF,reserve) \ static inline int VEC_OP (TDEF,reserve) \
(VEC (TDEF) **vec_, size_t alloc_ MEM_STAT_DECL) \ (VEC (TDEF) **vec_, int alloc_ MEM_STAT_DECL) \
{ \ { \
*vec_ = vec_p_reserve (*vec_, alloc_ PASS_MEM_STAT); \ int extend = !*vec_ || ((*vec_)->alloc - (*vec_)->num \
< (size_t)(alloc_ < 0 ? 1 : alloc_)); \
\
if (extend) \
*vec_ = vec_p_reserve (*vec_, alloc_ PASS_MEM_STAT); \
\
return extend; \
} \ } \
\ \
static inline TDEF *VEC_OP (TDEF,quick_push) \ static inline TDEF *VEC_OP (TDEF,quick_push) \
...@@ -349,8 +363,7 @@ static inline TDEF *VEC_OP (TDEF,quick_push) \ ...@@ -349,8 +363,7 @@ static inline TDEF *VEC_OP (TDEF,quick_push) \
static inline TDEF *VEC_OP (TDEF,safe_push) \ static inline TDEF *VEC_OP (TDEF,safe_push) \
(VEC (TDEF) **vec_, TDEF obj_ MEM_STAT_DECL) \ (VEC (TDEF) **vec_, TDEF obj_ MEM_STAT_DECL) \
{ \ { \
if (!*vec_ || (*vec_)->num == (*vec_)->alloc) \ VEC_OP (TDEF,reserve) (vec_, -1 PASS_MEM_STAT); \
VEC_OP (TDEF,reserve) (vec_, ~(size_t)0 PASS_MEM_STAT); \
\ \
return VEC_OP (TDEF,quick_push) (*vec_, obj_); \ return VEC_OP (TDEF,quick_push) (*vec_, obj_); \
} \ } \
...@@ -402,8 +415,7 @@ static inline TDEF *VEC_OP (TDEF,quick_insert) \ ...@@ -402,8 +415,7 @@ static inline TDEF *VEC_OP (TDEF,quick_insert) \
static inline TDEF *VEC_OP (TDEF,safe_insert) \ static inline TDEF *VEC_OP (TDEF,safe_insert) \
(VEC (TDEF) **vec_, size_t ix_, TDEF obj_ MEM_STAT_DECL) \ (VEC (TDEF) **vec_, size_t ix_, TDEF obj_ MEM_STAT_DECL) \
{ \ { \
if (!*vec_ || (*vec_)->num == (*vec_)->alloc) \ VEC_OP (TDEF,reserve) (vec_, -1 PASS_MEM_STAT); \
VEC_OP (TDEF,reserve) (vec_, ~(size_t)0 PASS_MEM_STAT); \
\ \
return VEC_OP (TDEF,quick_insert) (*vec_, ix_, obj_); \ return VEC_OP (TDEF,quick_insert) (*vec_, ix_, obj_); \
} \ } \
...@@ -476,7 +488,7 @@ static inline TDEF *VEC_OP (TDEF,iterate) \ ...@@ -476,7 +488,7 @@ static inline TDEF *VEC_OP (TDEF,iterate) \
} \ } \
\ \
static inline VEC (TDEF) *VEC_OP (TDEF,alloc) \ static inline VEC (TDEF) *VEC_OP (TDEF,alloc) \
(size_t alloc_ MEM_STAT_DECL) \ (int alloc_ MEM_STAT_DECL) \
{ \ { \
return vec_o_reserve (NULL, alloc_ - !alloc_, \ return vec_o_reserve (NULL, alloc_ - !alloc_, \
offsetof (VEC(TDEF),vec), sizeof (TDEF) \ offsetof (VEC(TDEF),vec), sizeof (TDEF) \
...@@ -484,24 +496,30 @@ static inline VEC (TDEF) *VEC_OP (TDEF,alloc) \ ...@@ -484,24 +496,30 @@ static inline VEC (TDEF) *VEC_OP (TDEF,alloc) \
} \ } \
\ \
static inline size_t VEC_OP (TDEF,embedded_size) \ static inline size_t VEC_OP (TDEF,embedded_size) \
(size_t alloc_) \ (int alloc_) \
{ \ { \
return offsetof (VEC(TDEF),vec) + alloc_ * sizeof(TDEF); \ return offsetof (VEC(TDEF),vec) + alloc_ * sizeof(TDEF); \
} \ } \
\ \
static inline void VEC_OP (TDEF,embedded_init) \ static inline void VEC_OP (TDEF,embedded_init) \
(VEC (TDEF) *vec_, size_t alloc_) \ (VEC (TDEF) *vec_, int alloc_) \
{ \ { \
vec_->num = 0; \ vec_->num = 0; \
vec_->alloc = alloc_; \ vec_->alloc = alloc_; \
} \ } \
\ \
static inline void VEC_OP (TDEF,reserve) \ static inline int VEC_OP (TDEF,reserve) \
(VEC (TDEF) **vec_, size_t alloc_ MEM_STAT_DECL) \ (VEC (TDEF) **vec_, int alloc_ MEM_STAT_DECL) \
{ \ { \
*vec_ = vec_o_reserve (*vec_, alloc_, \ int extend = !*vec_ || ((*vec_)->alloc - (*vec_)->num \
offsetof (VEC(TDEF),vec), sizeof (TDEF) \ < (size_t)(alloc_ < 0 ? 1 : alloc_)); \
PASS_MEM_STAT); \ \
if (extend) \
*vec_ = vec_o_reserve (*vec_, alloc_, \
offsetof (VEC(TDEF),vec), sizeof (TDEF) \
PASS_MEM_STAT); \
\
return extend; \
} \ } \
\ \
static inline TDEF *VEC_OP (TDEF,quick_push) \ static inline TDEF *VEC_OP (TDEF,quick_push) \
...@@ -520,8 +538,7 @@ static inline TDEF *VEC_OP (TDEF,quick_push) \ ...@@ -520,8 +538,7 @@ static inline TDEF *VEC_OP (TDEF,quick_push) \
static inline TDEF *VEC_OP (TDEF,safe_push) \ static inline TDEF *VEC_OP (TDEF,safe_push) \
(VEC (TDEF) **vec_, const TDEF *obj_ MEM_STAT_DECL) \ (VEC (TDEF) **vec_, const TDEF *obj_ MEM_STAT_DECL) \
{ \ { \
if (!*vec_ || (*vec_)->num == (*vec_)->alloc) \ VEC_OP (TDEF,reserve) (vec_, -1 PASS_MEM_STAT); \
VEC_OP (TDEF,reserve) (vec_, ~(size_t)0 PASS_MEM_STAT); \
\ \
return VEC_OP (TDEF,quick_push) (*vec_, obj_); \ return VEC_OP (TDEF,quick_push) (*vec_, obj_); \
} \ } \
...@@ -571,8 +588,7 @@ static inline TDEF *VEC_OP (TDEF,quick_insert) \ ...@@ -571,8 +588,7 @@ static inline TDEF *VEC_OP (TDEF,quick_insert) \
static inline TDEF *VEC_OP (TDEF,safe_insert) \ static inline TDEF *VEC_OP (TDEF,safe_insert) \
(VEC (TDEF) **vec_, size_t ix_, const TDEF *obj_ MEM_STAT_DECL) \ (VEC (TDEF) **vec_, size_t ix_, const TDEF *obj_ MEM_STAT_DECL) \
{ \ { \
if (!*vec_ || (*vec_)->num == (*vec_)->alloc) \ VEC_OP (TDEF,reserve) (vec_, -1 PASS_MEM_STAT); \
VEC_OP (TDEF,reserve) (vec_, ~(size_t)0 PASS_MEM_STAT); \
\ \
return VEC_OP (TDEF,quick_insert) (*vec_, ix_, obj_); \ return VEC_OP (TDEF,quick_insert) (*vec_, ix_, obj_); \
} \ } \
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment