/* Functions to support a pool of allocatable objects.
- Copyright (C) 1987, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
- 2007, 2008, 2010 Free Software Foundation, Inc.
+ Copyright (C) 1987-2014 Free Software Foundation, Inc.
Contributed by Daniel Berlin <dan@cgsoftware.com>
This file is part of GCC.
#include "config.h"
#include "system.h"
+#include "coretypes.h"
#include "alloc-pool.h"
-#include "hashtab.h"
+#include "hash-table.h"
+#include "hash-map.h"
#define align_eight(x) (((x+7) >> 3) << 3)
the allocated object may be even smaller than this structure.
We do not care about alignment for floating-point types. */
char *align_p;
- HOST_WIDEST_INT align_i;
+ int64_t align_i;
} u;
} allocation_object;
size for that pool. */
struct alloc_pool_descriptor
{
- const char *name;
/* Number of pools allocated. */
unsigned long created;
/* Gross allocated storage. */
};
/* Hashtable mapping alloc_pool names to descriptors. */
-static htab_t alloc_pool_hash;
-
-/* Hashtable helpers. */
-static hashval_t
-hash_descriptor (const void *p)
-{
- const struct alloc_pool_descriptor *const d =
- (const struct alloc_pool_descriptor * )p;
- return htab_hash_pointer (d->name);
-}
-static int
-eq_descriptor (const void *p1, const void *p2)
-{
- const struct alloc_pool_descriptor *const d =
- (const struct alloc_pool_descriptor *) p1;
- return d->name == p2;
-}
+static hash_map<const char *, alloc_pool_descriptor> *alloc_pool_hash;
/* For given name, return descriptor, create new if needed. */
static struct alloc_pool_descriptor *
-alloc_pool_descriptor (const char *name)
+allocate_pool_descriptor (const char *name)
{
- struct alloc_pool_descriptor **slot;
-
if (!alloc_pool_hash)
- alloc_pool_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
-
- slot = (struct alloc_pool_descriptor **)
- htab_find_slot_with_hash (alloc_pool_hash, name,
- htab_hash_pointer (name),
- INSERT);
- if (*slot)
- return *slot;
- *slot = XCNEW (struct alloc_pool_descriptor);
- (*slot)->name = name;
- return *slot;
+ alloc_pool_hash = new hash_map<const char *, alloc_pool_descriptor> (10);
+
+ return &alloc_pool_hash->get_or_insert (name);
}
/* Create a pool of things of size SIZE, with NUM in each block we
/* Now align the size to a multiple of 4. */
size = align_eight (size);
- if (ENABLE_CHECKING)
- {
- /* Add the aligned size of ID. */
- size += offsetof (allocation_object, u.data);
- }
+#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);
if (GATHER_STATISTICS)
{
- struct alloc_pool_descriptor *desc = alloc_pool_descriptor (name);
+ struct alloc_pool_descriptor *desc = allocate_pool_descriptor (name);
desc->elt_size = size;
desc->created++;
}
if (GATHER_STATISTICS)
{
- struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
+ struct alloc_pool_descriptor *desc = allocate_pool_descriptor (pool->name);
desc->current -= (pool->elts_allocated - pool->elts_free) * pool->elt_size;
}
pool_alloc (alloc_pool pool)
{
alloc_pool_list header;
+#ifdef ENABLE_VALGRIND_ANNOTATIONS
+ int size;
+#endif
if (GATHER_STATISTICS)
{
- struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
+ struct alloc_pool_descriptor *desc = allocate_pool_descriptor (pool->name);
desc->allocated += pool->elt_size;
desc->current += pool->elt_size;
}
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)
/* 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--;
/* 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);
}
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 whether the PTR was allocated from POOL. */
&& pool->id == ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id);
- memset (ptr, 0xaf, pool->elt_size - offsetof (allocation_object, u.data));
+ memset (ptr, 0xaf, size);
/* Mark the element to be free. */
ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id = 0;
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 = alloc_pool_descriptor (pool->name);
+ 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. */
-struct output_info
+struct pool_output_info
{
unsigned long total_created;
unsigned long total_allocated;
};
-/* Called via htab_traverse. Output alloc_pool descriptor pointed out by SLOT
- and update statistics. */
-static int
-print_statistics (void **slot, void *b)
+/* Called via hash_map.traverse. Output alloc_pool descriptor pointed out by
+ SLOT and update statistics. */
+bool
+print_alloc_pool_statistics (const char *const &name,
+ const alloc_pool_descriptor &d,
+ struct pool_output_info *i)
{
- struct alloc_pool_descriptor *d = (struct alloc_pool_descriptor *) *slot;
- struct output_info *i = (struct output_info *) b;
-
- if (d->allocated)
+ if (d.allocated)
{
- fprintf (stderr, "%-22s %6d %10lu %10lu(%10lu) %10lu(%10lu) %10lu(%10lu)\n", d->name,
- d->elt_size, d->created, d->allocated, d->allocated / d->elt_size,
- d->peak, d->peak / d->elt_size,
- d->current, d->current / d->elt_size);
- i->total_allocated += d->allocated;
- i->total_created += d->created;
+ fprintf (stderr,
+ "%-22s %6d %10lu %10lu(%10lu) %10lu(%10lu) %10lu(%10lu)\n",
+ name, d.elt_size, d.created, d.allocated,
+ d.allocated / d.elt_size, d.peak, d.peak / d.elt_size,
+ d.current, d.current / d.elt_size);
+ i->total_allocated += d.allocated;
+ i->total_created += d.created;
}
return 1;
}
void
dump_alloc_pool_statistics (void)
{
- struct output_info info;
+ struct pool_output_info info;
if (! GATHER_STATISTICS)
return;
fprintf (stderr, "--------------------------------------------------------------------------------------------------------------\n");
info.total_created = 0;
info.total_allocated = 0;
- htab_traverse (alloc_pool_hash, print_statistics, &info);
+ alloc_pool_hash->traverse <struct pool_output_info *,
+ print_alloc_pool_statistics> (&info);
fprintf (stderr, "--------------------------------------------------------------------------------------------------------------\n");
fprintf (stderr, "%-22s %7lu %10lu\n",
"Total", info.total_created, info.total_allocated);
projects / gcc.git / blobdiff