diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 0196e263f53..f96a2ef8d0b 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,13 @@ +2015-06-01 Martin Liska + + * alloc-pool.c (create_alloc_pool): Remove. + (empty_alloc_pool): Likewise. + (free_alloc_pool): Likewise. + (free_alloc_pool_if_empty): Likewise. + (pool_alloc): Likewise. + (pool_free): Likewise. + * alloc-pool.h: Remove old declarations. + 2015-06-01 Martin Liska * ira-build.c (initiate_allocnos): Use new type-based pool allocator. diff --git a/gcc/alloc-pool.c b/gcc/alloc-pool.c index 829556fe25a..e9fdc86b016 100644 --- a/gcc/alloc-pool.c +++ b/gcc/alloc-pool.c @@ -27,39 +27,6 @@ along with GCC; see the file COPYING3. If not see ALLOC_POOL_ID_TYPE last_id; -#define align_eight(x) (((x+7) >> 3) << 3) - -/* The internal allocation object. */ -typedef struct allocation_object_def -{ -#ifdef ENABLE_CHECKING - /* The ID of alloc pool which the object was allocated from. */ - ALLOC_POOL_ID_TYPE id; -#endif - - union - { - /* The data of the object. */ - char data[1]; - - /* Because we want any type of data to be well aligned after the ID, - the following elements are here. They are never accessed so - the allocated object may be even smaller than this structure. - We do not care about alignment for floating-point types. */ - char *align_p; - int64_t align_i; - } u; -} allocation_object; - -/* Convert a pointer to allocation_object from a pointer to user data. */ -#define ALLOCATION_OBJECT_PTR_FROM_USER_PTR(X) \ - ((allocation_object *) (((char *) (X)) \ - - offsetof (allocation_object, u.data))) - -/* Convert a pointer to user data from a pointer to allocation_object. */ -#define USER_PTR_FROM_ALLOCATION_OBJECT_PTR(X) \ - ((void *) (((allocation_object *) (X))->u.data)) - /* Hashtable mapping alloc_pool names to descriptors. */ hash_map *alloc_pool_hash; @@ -74,247 +41,6 @@ allocate_pool_descriptor (const char *name) return &alloc_pool_hash->get_or_insert (name); } - -/* Create a pool of things of size SIZE, with NUM in each block we - allocate. */ - -alloc_pool -create_alloc_pool (const char *name, size_t size, size_t num) -{ - alloc_pool pool; - size_t header_size; - - gcc_checking_assert (name); - - /* Make size large enough to store the list header. */ - if (size < sizeof (alloc_pool_list)) - size = sizeof (alloc_pool_list); - - /* Now align the size to a multiple of 4. */ - size = align_eight (size); - -#ifdef ENABLE_CHECKING - /* Add the aligned size of ID. */ - size += offsetof (allocation_object, u.data); -#endif - - /* Um, we can't really allocate 0 elements per block. */ - gcc_checking_assert (num); - - /* Allocate memory for the pool structure. */ - pool = XNEW (struct alloc_pool_def); - - /* Now init the various pieces of our pool structure. */ - pool->name = /*xstrdup (name)*/name; - pool->elt_size = size; - pool->elts_per_block = num; - - if (GATHER_STATISTICS) - { - struct alloc_pool_descriptor *desc = allocate_pool_descriptor (name); - desc->elt_size = size; - desc->created++; - } - - /* List header size should be a multiple of 8. */ - header_size = align_eight (sizeof (struct alloc_pool_list_def)); - - pool->block_size = (size * num) + header_size; - pool->returned_free_list = NULL; - pool->virgin_free_list = NULL; - pool->virgin_elts_remaining = 0; - pool->elts_allocated = 0; - pool->elts_free = 0; - pool->blocks_allocated = 0; - pool->block_list = NULL; - -#ifdef ENABLE_CHECKING - /* Increase the last used ID and use it for this pool. - ID == 0 is used for free elements of pool so skip it. */ - last_id++; - if (last_id == 0) - last_id++; - - pool->id = last_id; -#endif - - return (pool); -} - -/* Free all memory allocated for the given memory pool. */ -void -empty_alloc_pool (alloc_pool pool) -{ - alloc_pool_list block, next_block; - - gcc_checking_assert (pool); - - /* Free each block allocated to the pool. */ - for (block = pool->block_list; block != NULL; block = next_block) - { - next_block = block->next; - free (block); - } - - if (GATHER_STATISTICS) - { - struct alloc_pool_descriptor *desc = allocate_pool_descriptor (pool->name); - desc->current -= (pool->elts_allocated - pool->elts_free) * pool->elt_size; - } - - pool->returned_free_list = NULL; - pool->virgin_free_list = NULL; - pool->virgin_elts_remaining = 0; - pool->elts_allocated = 0; - pool->elts_free = 0; - pool->blocks_allocated = 0; - pool->block_list = NULL; -} - -/* Free all memory allocated for the given memory pool and the pool itself. */ -void -free_alloc_pool (alloc_pool pool) -{ - /* First empty the pool. */ - empty_alloc_pool (pool); -#ifdef ENABLE_CHECKING - memset (pool, 0xaf, sizeof (*pool)); -#endif - /* Lastly, free the pool. */ - free (pool); -} - -/* Frees the alloc_pool, if it is empty and zero *POOL in this case. */ -void -free_alloc_pool_if_empty (alloc_pool *pool) -{ - if ((*pool)->elts_free == (*pool)->elts_allocated) - { - free_alloc_pool (*pool); - *pool = NULL; - } -} - -/* Allocates one element from the pool specified. */ -void * -pool_alloc (alloc_pool pool) -{ - alloc_pool_list header; -#ifdef ENABLE_VALGRIND_ANNOTATIONS - int size; -#endif - - if (GATHER_STATISTICS) - { - struct alloc_pool_descriptor *desc = allocate_pool_descriptor (pool->name); - - desc->allocated += pool->elt_size; - desc->current += pool->elt_size; - if (desc->peak < desc->current) - desc->peak = desc->current; - } - - gcc_checking_assert (pool); -#ifdef ENABLE_VALGRIND_ANNOTATIONS - size = pool->elt_size - offsetof (allocation_object, u.data); -#endif - - /* If there are no more free elements, make some more!. */ - if (!pool->returned_free_list) - { - char *block; - if (!pool->virgin_elts_remaining) - { - alloc_pool_list block_header; - - /* Make the block. */ - block = XNEWVEC (char, pool->block_size); - block_header = (alloc_pool_list) block; - block += align_eight (sizeof (struct alloc_pool_list_def)); - - /* Throw it on the block list. */ - block_header->next = pool->block_list; - pool->block_list = block_header; - - /* Make the block available for allocation. */ - pool->virgin_free_list = block; - pool->virgin_elts_remaining = pool->elts_per_block; - - /* Also update the number of elements we have free/allocated, and - increment the allocated block count. */ - pool->elts_allocated += pool->elts_per_block; - pool->elts_free += pool->elts_per_block; - pool->blocks_allocated += 1; - } - - - /* We now know that we can take the first elt off the virgin list and - put it on the returned list. */ - block = pool->virgin_free_list; - header = (alloc_pool_list) USER_PTR_FROM_ALLOCATION_OBJECT_PTR (block); - header->next = NULL; -#ifdef ENABLE_CHECKING - /* Mark the element to be free. */ - ((allocation_object *) block)->id = 0; -#endif - VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (header,size)); - pool->returned_free_list = header; - pool->virgin_free_list += pool->elt_size; - pool->virgin_elts_remaining--; - - } - - /* Pull the first free element from the free list, and return it. */ - header = pool->returned_free_list; - VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (header, sizeof (*header))); - pool->returned_free_list = header->next; - pool->elts_free--; - -#ifdef ENABLE_CHECKING - /* Set the ID for element. */ - ALLOCATION_OBJECT_PTR_FROM_USER_PTR (header)->id = pool->id; -#endif - VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (header, size)); - - return ((void *) header); -} - -/* Puts PTR back on POOL's free list. */ -void -pool_free (alloc_pool pool, void *ptr) -{ - alloc_pool_list header; -#if defined(ENABLE_VALGRIND_ANNOTATIONS) || defined(ENABLE_CHECKING) - int size; - size = pool->elt_size - offsetof (allocation_object, u.data); -#endif - -#ifdef ENABLE_CHECKING - gcc_assert (ptr - /* Check if we free more than we allocated, which is Bad (TM). */ - && pool->elts_free < pool->elts_allocated - /* Check whether the PTR was allocated from POOL. */ - && pool->id == ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id); - - memset (ptr, 0xaf, size); - - /* Mark the element to be free. */ - ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id = 0; -#endif - - header = (alloc_pool_list) ptr; - header->next = pool->returned_free_list; - pool->returned_free_list = header; - VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (ptr, size)); - pool->elts_free++; - - if (GATHER_STATISTICS) - { - struct alloc_pool_descriptor *desc = allocate_pool_descriptor (pool->name); - desc->current -= pool->elt_size; - } -} - /* Output per-alloc_pool statistics. */ /* Used to accumulate statistics about alloc_pool sizes. */ diff --git a/gcc/alloc-pool.h b/gcc/alloc-pool.h index ec671dcd6f4..65087265527 100644 --- a/gcc/alloc-pool.h +++ b/gcc/alloc-pool.h @@ -22,46 +22,6 @@ along with GCC; see the file COPYING3. If not see #include "hash-map.h" -typedef unsigned long ALLOC_POOL_ID_TYPE; - -typedef struct alloc_pool_list_def -{ - struct alloc_pool_list_def *next; -} - *alloc_pool_list; - -typedef struct alloc_pool_def -{ - const char *name; - ALLOC_POOL_ID_TYPE id; - size_t elts_per_block; - - /* These are the elements that have been allocated at least once and freed. */ - alloc_pool_list returned_free_list; - - /* These are the elements that have not yet been allocated out of - the last block obtained from XNEWVEC. */ - char* virgin_free_list; - - /* The number of elements in the virgin_free_list that can be - allocated before needing another block. */ - size_t virgin_elts_remaining; - - size_t elts_allocated; - size_t elts_free; - size_t blocks_allocated; - alloc_pool_list block_list; - size_t block_size; - size_t elt_size; -} - *alloc_pool; - -extern alloc_pool create_alloc_pool (const char *, size_t, size_t); -extern void free_alloc_pool (alloc_pool); -extern void empty_alloc_pool (alloc_pool); -extern void free_alloc_pool_if_empty (alloc_pool *); -extern void *pool_alloc (alloc_pool) ATTRIBUTE_MALLOC; -extern void pool_free (alloc_pool, void *); extern void dump_alloc_pool_statistics (void); typedef unsigned long ALLOC_POOL_ID_TYPE; @@ -76,21 +36,10 @@ public: potentially IGNORE_TYPE_SIZE. */ pool_allocator (const char *name, size_t num, size_t extra_size = 0, bool ignore_type_size = false); - - /* Default destuctor. */ ~pool_allocator (); - - /* Release internal data structures. */ void release (); - - /* Release internal data structures if the pool has not allocated - an object. */ void release_if_empty (); - - /* Allocate a new object. */ T *allocate () ATTRIBUTE_MALLOC; - - /* Release OBJECT that must come from the pool. */ void remove (T *object); private: