From a0ef884f73d791abd09ca3f5a9ccf725ead5fe39 Mon Sep 17 00:00:00 2001 From: Nathan Sidwell Date: Fri, 27 May 2005 13:26:02 +0000 Subject: [PATCH] vec.h: Implement integral type vector specialization. * vec.h: Implement integral type vector specialization. (VEC_T): Define a non-GTY structure. (VEC_T_GTY): Define a GTY structure. (VEC_TA): Rename to ... (VEC_TA_GTY): ... here. (DEF_VEC_I, DEF_VEC_ALLOC_I): New. (DEF_VEC_P, DEF_VEC_ALLOC_P): Adjust. (DEF_VEC_FUNC_P, DEF_VEC_ALLOC_FUNC_P): New, broken out of DEF_VEC_P and DEF_VEC_ALLOC_P. (DEF_VEC_O, DEF_VEC_ALLOC_O): Adjust. (DEF_VEC_FUNC_O, DEF_VEC_ALLOC_FUNC_O): New, broken out of DEF_VEC_O and DEF_VEC_ALLOC_O. * global.c: Use DEF_VEC_I, DEF_VEC_ALLOC_I. * lambda-code.c: Likewise. * tree-into-ssa.c: Likewise. * tree-ssa-live.c: Likewise. From-SVN: r100251 --- gcc/ChangeLog | 19 +++++++ gcc/global.c | 4 +- gcc/lambda-code.c | 4 +- gcc/tree-into-ssa.c | 4 +- gcc/tree-ssa-live.c | 4 +- gcc/vec.h | 152 +++++++++++++++++++++++++++++++++------------------- 6 files changed, 125 insertions(+), 62 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 4c67cab..77d2700 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,22 @@ +2005-05-27 Nathan Sidwell + + * vec.h: Implement integral type vector specialization. + (VEC_T): Define a non-GTY structure. + (VEC_T_GTY): Define a GTY structure. + (VEC_TA): Rename to ... + (VEC_TA_GTY): ... here. + (DEF_VEC_I, DEF_VEC_ALLOC_I): New. + (DEF_VEC_P, DEF_VEC_ALLOC_P): Adjust. + (DEF_VEC_FUNC_P, DEF_VEC_ALLOC_FUNC_P): New, broken out of + DEF_VEC_P and DEF_VEC_ALLOC_P. + (DEF_VEC_O, DEF_VEC_ALLOC_O): Adjust. + (DEF_VEC_FUNC_O, DEF_VEC_ALLOC_FUNC_O): New, broken out of + DEF_VEC_O and DEF_VEC_ALLOC_O. + * global.c: Use DEF_VEC_I, DEF_VEC_ALLOC_I. + * lambda-code.c: Likewise. + * tree-into-ssa.c: Likewise. + * tree-ssa-live.c: Likewise. + 2005-05-27 Kazu Hirata * tree-into-ssa.c (update_ssa): Ensure that the operand cache diff --git a/gcc/global.c b/gcc/global.c index b11e6d7..dea1fc5 100644 --- a/gcc/global.c +++ b/gcc/global.c @@ -2098,8 +2098,8 @@ mark_reg_change (rtx reg, rtx setter, void *data) /* Classes of registers which could be early clobbered in the current insn. */ -DEF_VEC_P(int); -DEF_VEC_ALLOC_P(int,heap); +DEF_VEC_I(int); +DEF_VEC_ALLOC_I(int,heap); static VEC(int,heap) *earlyclobber_regclass; diff --git a/gcc/lambda-code.c b/gcc/lambda-code.c index 13115b0..738ea7a 100644 --- a/gcc/lambda-code.c +++ b/gcc/lambda-code.c @@ -115,8 +115,8 @@ Fourier-Motzkin elimination is used to compute the bounds of the base space of the lattice. */ -DEF_VEC_P(int); -DEF_VEC_ALLOC_P(int,heap); +DEF_VEC_I(int); +DEF_VEC_ALLOC_I(int,heap); static bool perfect_nestify (struct loops *, struct loop *, VEC(tree,heap) *, diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c index e7ff242..f1da55a 100644 --- a/gcc/tree-into-ssa.c +++ b/gcc/tree-into-ssa.c @@ -107,8 +107,8 @@ static VEC(tree,heap) *block_defs_stack; /* Basic block vectors used in this file ought to be allocated in the heap. We use pointer vector, because ints can be easily passed by value. */ -DEF_VEC_P(int); -DEF_VEC_ALLOC_P(int,heap); +DEF_VEC_I(int); +DEF_VEC_ALLOC_I(int,heap); /* Set of existing SSA names being replaced by update_ssa. */ static sbitmap old_ssa_names; diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c index f40df90..e80ef8f 100644 --- a/gcc/tree-ssa-live.c +++ b/gcc/tree-ssa-live.c @@ -1281,8 +1281,8 @@ add_conflicts_if_valid (tpa_p tpa, conflict_graph graph, } } -DEF_VEC_P(int); -DEF_VEC_ALLOC_P(int,heap); +DEF_VEC_I(int); +DEF_VEC_ALLOC_I(int,heap); /* Return a conflict graph for the information contained in LIVE_INFO. Only conflicts between items in the same TPA list are added. If optional diff --git a/gcc/vec.h b/gcc/vec.h index 13c4ed6..9b16976 100644 --- a/gcc/vec.h +++ b/gcc/vec.h @@ -29,17 +29,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA out-of-line generic functions. The vectors are designed to interoperate with the GTY machinery. - Because of the different behavior of objects and of pointers to - objects, there are two flavors. One to deal with a vector of - pointers to objects, and one to deal with a vector of objects - themselves. Both of these pass pointers to objects around -- in - the former case the pointers are stored into the vector and in the - latter case the pointers are dereferenced and the objects copied - into the vector. Therefore, when using a vector of pointers, the - objects pointed to must be long lived, but when dealing with a - vector of objects, the source objects need not be. The vector of - pointers API is also appropriate for small register sized objects - like integers. + 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 @@ -96,20 +93,24 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA 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}(TYPEDEF) macro, to + Vector types are defined using a DEF_VEC_{O,P,I}(TYPEDEF) macro, to get the non-memory allocation version, and then a - DEF_VEC_ALLOC_{O,P}(TYPEDEF,ALLOC) macro to get memory managed + DEF_VEC_ALLOC_{O,P,I}(TYPEDEF,ALLOC) macro to get memory managed vectors. Variables of vector type are declared using a VEC(TYPEDEF,ALLOC) macro. The ALLOC argument specifies the allocation strategy, and can be either 'gc' or 'heap' for garbage collected and heap allocated respectively. It can be 'none' to get a vector that must be explicitly allocated (for instance as a - trailing array of another structure). The characters O and P - indicate whether TYPEDEF is a pointer (P) or object (O) type. Be - careful to pick the correct one, as you'll get an awkward and - inefficient API if you get the wrong one. There is a check, which - results in a compile-time warning, for the P versions, but there is - no check for the O versions, as that is not possible in plain C. + trailing array of another structure). 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. Due to the way GTY works, you must annotate + any structures you wish to insert or reference from a vector with a + GTY(()) tag. You need to do this even if you never declare the GC + allocated variants. An example of their use would be, @@ -147,6 +148,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define VEC_length(T,V) (VEC_OP(T,base,length)(VEC_BASE(V))) /* 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 @@ -155,6 +157,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define VEC_last(T,V) (VEC_OP(T,base,last)(VEC_BASE(V) VEC_CHECK_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 @@ -163,6 +166,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define VEC_index(T,V,I) (VEC_OP(T,base,index)(VEC_BASE(V),I VEC_CHECK_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 @@ -228,6 +232,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA (VEC_OP(T,A,reserve)(&(V),R VEC_CHECK_INFO MEM_STAT_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 @@ -240,6 +245,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA (VEC_OP(T,base,quick_push)(VEC_BASE(V),O VEC_CHECK_INFO)) /* Push object with reallocation + T *VEC_T_A_safe_push (VEC(T,A) *&v, T obj); // Integer T *VEC_T_A_safe_push (VEC(T,A) *&v, T obj); // Pointer T *VEC_T_A_safe_push (VEC(T,A) *&v, T *obj); // Object @@ -251,6 +257,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA (VEC_OP(T,A,safe_push)(&(V),O VEC_CHECK_INFO MEM_STAT_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 @@ -279,6 +286,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA (VEC_OP(T,A,safe_grow)(&(V),I VEC_CHECK_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 @@ -292,6 +300,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA (VEC_OP(T,base,replace)(VEC_BASE(V),I,O VEC_CHECK_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 @@ -304,6 +313,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA (VEC_OP(T,base,quick_insert)(VEC_BASE(V),I,O VEC_CHECK_INFO)) /* Insert object with reallocation + T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T val); // Integer T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T val); // Pointer T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T *val); // Object @@ -316,6 +326,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA (VEC_OP(T,A,safe_insert)(&(V),I,O VEC_CHECK_INFO MEM_STAT_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 @@ -327,6 +338,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA (VEC_OP(T,base,ordered_remove)(VEC_BASE(V),I VEC_CHECK_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 @@ -347,6 +359,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA /* Find the first index in the vector not less than the object. unsigned VEC_T_lower_bound (VEC(T) *v, const T val, + bool (*lessthan) (const T, const T)); // Integer + unsigned VEC_T_lower_bound (VEC(T) *v, const T val, bool (*lessthan) (const T, const T)); // Pointer unsigned VEC_T_lower_bound (VEC(T) *v, const T *val, bool (*lessthan) (const T*, const T*)); // Object @@ -397,6 +411,14 @@ extern void vec_assert_fail (const char *, const char * VEC_CHECK_DECL) /* Base of vector type, not user visible. */ #define VEC_T(T,B) \ +typedef struct VEC(T,B) \ +{ \ + unsigned num; \ + unsigned alloc; \ + T vec[1]; \ +} VEC(T,B) + +#define VEC_T_GTY(T,B) \ typedef struct VEC(T,B) GTY(()) \ { \ unsigned num; \ @@ -405,7 +427,7 @@ typedef struct VEC(T,B) GTY(()) \ } VEC(T,B) /* Derived vector type, user visible. */ -#define VEC_TA(T,B,A,GTY) \ +#define VEC_TA_GTY(T,B,A,GTY) \ typedef struct VEC(T,A) GTY \ { \ VEC(T,B) base; \ @@ -414,20 +436,49 @@ typedef struct VEC(T,A) GTY \ /* Convert to base type. */ #define VEC_BASE(P) ((P) ? &(P)->base : 0) +/* Vector of integer-like object. */ +#if IN_GENGTYPE +{"DEF_VEC_I", VEC_STRINGIFY (VEC_T(#0,#1)) ";", "none"}, +{"DEF_VEC_ALLOC_I", VEC_STRINGIFY (VEC_TA (#0,#1,#2,#3)) ";", NULL}, +#else +#define DEF_VEC_I(T) \ +static inline void VEC_OP (T,must_be,integral_type) (void) \ +{ \ + (void)~(T)0; \ +} \ + \ +VEC_T(T,base); \ +VEC_TA_GTY(T,base,none,); \ +DEF_VEC_FUNC_P(T) \ +struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_I(T,A) \ +VEC_TA_GTY(T,base,A,); \ +DEF_VEC_ALLOC_FUNC_P(T,A) \ +struct vec_swallow_trailing_semi +#endif + /* Vector of pointer to object. */ #if IN_GENGTYPE -{"DEF_VEC_P", VEC_STRINGIFY (VEC_T(#0,#1)) ";", "none"}, -{"DEF_VEC_ALLOC_P", VEC_STRINGIFY (VEC_TA (#0,#1,#2,#3)) ";", NULL}, +{"DEF_VEC_P", VEC_STRINGIFY (VEC_T_GTY(#0,#1)) ";", "none"}, +{"DEF_VEC_ALLOC_P", VEC_STRINGIFY (VEC_TA_GTY (#0,#1,#2,#3)) ";", NULL}, #else - #define DEF_VEC_P(T) \ -VEC_T(T,base); \ - \ -static inline void VEC_OP (T,must,be_a_pointer_or_integer) (void) \ +static inline void VEC_OP (T,must_be,pointer_type) (void) \ { \ - (void)((T)0 == (void *)0); \ + (void)((T)1 == (void *)1); \ } \ \ +VEC_T_GTY(T,base); \ +VEC_TA_GTY(T,base,none,); \ +DEF_VEC_FUNC_P(T) \ +struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_P(T,A) \ +VEC_TA_GTY(T,base,A,); \ +DEF_VEC_ALLOC_FUNC_P(T,A) \ +struct vec_swallow_trailing_semi +#endif + +#define DEF_VEC_FUNC_P(T) \ static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \ { \ return vec_ ? vec_->num : 0; \ @@ -598,13 +649,9 @@ static inline unsigned VEC_OP (T,base,lower_bound) \ len_ = half_; \ } \ return first_; \ -} \ - \ -VEC_TA(T,base,none,) - -#define DEF_VEC_ALLOC_P(T,A) \ -VEC_TA(T,base,A,); \ - \ +} + +#define DEF_VEC_ALLOC_FUNC_P(T,A) \ static inline VEC(T,A) *VEC_OP (T,A,alloc) \ (int alloc_ MEM_STAT_DECL) \ { \ @@ -659,20 +706,25 @@ static inline T *VEC_OP (T,A,safe_insert) \ \ return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ VEC_CHECK_PASS); \ -} \ - \ -struct vec_swallow_trailing_semi -#endif +} /* Vector of object. */ #if IN_GENGTYPE -{"DEF_VEC_O", VEC_STRINGIFY (VEC_T(#0,#1)) ";", "none"}, -{"DEF_VEC_ALLOC_O", VEC_STRINGIFY (VEC_TA(#0,#1,#2,#3)) ";", NULL}, +{"DEF_VEC_O", VEC_STRINGIFY (VEC_T_GTY(#0,#1)) ";", "none"}, +{"DEF_VEC_ALLOC_O", VEC_STRINGIFY (VEC_TA_GTY(#0,#1,#2,#3)) ";", NULL}, #else - #define DEF_VEC_O(T) \ -VEC_T(T,base); \ - \ +VEC_T_GTY(T,base); \ +VEC_TA_GTY(T,base,none,); \ +DEF_VEC_FUNC_O(T) \ +struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_O(T,A) \ +VEC_TA_GTY(T,base,A,); \ +DEF_VEC_ALLOC_FUNC_O(T,A) \ +struct vec_swallow_trailing_semi +#endif + +#define DEF_VEC_FUNC_O(T) \ static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \ { \ return vec_ ? vec_->num : 0; \ @@ -830,13 +882,9 @@ static inline unsigned VEC_OP (T,base,lower_bound) \ len_ = half_; \ } \ return first_; \ -} \ - \ -VEC_TA(T,base,none,) +} -#define DEF_VEC_ALLOC_O(T,A) \ -VEC_TA(T,base,A,); \ - \ +#define DEF_VEC_ALLOC_FUNC_O(T,A) \ static inline VEC(T,A) *VEC_OP (T,A,alloc) \ (int alloc_ MEM_STAT_DECL) \ { \ @@ -899,9 +947,5 @@ static inline T *VEC_OP (T,A,safe_insert) \ \ return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ VEC_CHECK_PASS); \ -} \ - \ -struct vec_swallow_trailing_semi -#endif - +} #endif /* GCC_VEC_H */ -- 2.7.4