From: Trevor Saunders <tsaund...@mozilla.com>
Hi,
C++ default args allow us to name the function foo instead of foo_stat with a
wrapper macro foo.
bootstrapped + regtested x86_64-unknown-linux-gnu, ok?
Trev
gcc/ChangeLog:
2014-04-23 tbsaunde <tbsau...@my.domain.org>
* dwarf2out.c (tree_add_const_value_attribute): Call
ggc_internal_cleared_alloc instead of ggc_alloc_cleared_atomic.
* gengtype.c (write_typed_alloc_def): Call ggc_internal_<x>alloc
instead of ggc_internal_<x>alloc_stat.
* ggc-common.c (ggc_internal_cleared_alloc): Drop _stat suffix.
(ggc_realloc): Likewise.
* ggc-none.c (ggc_internal_alloc): Likewise.
(ggc_internal_cleared_alloc): Likewise.
* ggc-page.c: Likewise.
* ggc.h (ggc_internal_alloc_stat): Likewise.
(ggc_internal_alloc): Remove macro.
(ggc_internal_cleared_alloc_stat): Drop _stat suffix.
(ggc_internal_cleared_alloc): Remove macro.
(GGC_RESIZEVEC): Adjust.
(ggc_resizevar): Remove macro.
(ggc_internal_vec_alloc_stat): Drop _stat suffix.
(ggc_internal_cleared_vec_alloc_stat): Likewise.
(ggc_internal_vec_cleared_alloc): Remove macro.
(ggc_alloc_atomic_stat): Drop _stat suffix.
(ggc_alloc_atomic): Remove macro.
(ggc_alloc_cleared_atomic): Remove macro.
(ggc_alloc_string_stat): Drop _stat suffix.
(ggc_alloc_string): Remove macro.
(ggc_alloc_rtx_def_stat): Adjust.
(ggc_alloc_tree_node_stat): Likewise.
(ggc_alloc_cleared_tree_node_stat): Likewise.
(ggc_alloc_cleared_gimple_statement_stat): Likewise.
(ggc_alloc_cleared_simd_clone_stat): Likewise.
* gimple.c (gimple_build_omp_for): Likewise.
(gimple_copy): Likewise.
* stringpool.c (ggc_alloc_string_stat): Drop _stat suffix.
* toplev.c (realloc_for_line_map): Adjust.
* tree-data-ref.h (lambda_vector_new): Likewise.
* tree-phinodes.c (allocate_phi_node): Likewise.
* tree.c (grow_tree_vec_stat): Likewise.
* vec.h (va_gc::reserve): Adjust.
gcc/java/ChangeLog:
2014-04-23 tbsaunde <tbsau...@my.domain.org>
* constants.c (set_constant_entry): Adjust.
---
gcc/dwarf2out.c | 2 +-
gcc/gengtype.c | 2 +-
gcc/ggc-common.c | 10 ++++----
gcc/ggc-none.c | 4 ++--
gcc/ggc-page.c | 2 +-
gcc/ggc.h | 65 +++++++++++++++++++---------------------------------
gcc/gimple.c | 8 +++----
gcc/java/constants.c | 4 ++--
gcc/stringpool.c | 4 ++--
gcc/toplev.c | 2 +-
gcc/tree-data-ref.h | 2 +-
gcc/tree-phinodes.c | 2 +-
gcc/tree.c | 2 +-
gcc/vec.h | 5 ++--
14 files changed, 48 insertions(+), 66 deletions(-)
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 1272326..6133fa3 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -15875,7 +15875,7 @@ tree_add_const_value_attribute (dw_die_ref die, tree t)
if (size > 0 && (int) size == size)
{
unsigned char *array = (unsigned char *)
- ggc_alloc_cleared_atomic (size);
+ ggc_internal_cleared_alloc (size);
if (native_encode_initializer (init, array, size))
{
diff --git a/gcc/gengtype.c b/gcc/gengtype.c
index 031004a..e8fcd9f 100644
--- a/gcc/gengtype.c
+++ b/gcc/gengtype.c
@@ -4975,7 +4975,7 @@ write_typed_alloc_def (outf_p f,
(two_args ? ", " : ""),
(quantity == vector) ? "n" : "");
oprintf (f, "((%s%s *)", type_specifier, type_name);
- oprintf (f, "(ggc_internal_%salloc_stat (", allocator_type);
+ oprintf (f, "(ggc_internal_%salloc (", allocator_type);
if (variable_size)
oprintf (f, "SIZE");
else
diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c
index 97c9b87..e1cc48e 100644
--- a/gcc/ggc-common.c
+++ b/gcc/ggc-common.c
@@ -174,22 +174,22 @@ ggc_mark_roots (void)
/* Allocate a block of memory, then clear it. */
void *
-ggc_internal_cleared_alloc_stat (size_t size MEM_STAT_DECL)
+ggc_internal_cleared_alloc (size_t size MEM_STAT_DECL)
{
- void *buf = ggc_internal_alloc_stat (size PASS_MEM_STAT);
+ void *buf = ggc_internal_alloc (size PASS_MEM_STAT);
memset (buf, 0, size);
return buf;
}
/* Resize a block of memory, possibly re-allocating it. */
void *
-ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL)
+ggc_realloc (void *x, size_t size MEM_STAT_DECL)
{
void *r;
size_t old_size;
if (x == NULL)
- return ggc_internal_alloc_stat (size PASS_MEM_STAT);
+ return ggc_internal_alloc (size PASS_MEM_STAT);
old_size = ggc_get_size (x);
@@ -211,7 +211,7 @@ ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL)
return x;
}
- r = ggc_internal_alloc_stat (size PASS_MEM_STAT);
+ r = ggc_internal_alloc (size PASS_MEM_STAT);
/* Since ggc_get_size returns the size of the pool, not the size of the
individually allocated object, we'd access parts of the old object
diff --git a/gcc/ggc-none.c b/gcc/ggc-none.c
index e690019..aad89bf 100644
--- a/gcc/ggc-none.c
+++ b/gcc/ggc-none.c
@@ -41,13 +41,13 @@ ggc_round_alloc_size (size_t requested_size)
}
void *
-ggc_internal_alloc_stat (size_t size MEM_STAT_DECL)
+ggc_internal_alloc (size_t size MEM_STAT_DECL)
{
return xmalloc (size);
}
void *
-ggc_internal_cleared_alloc_stat (size_t size MEM_STAT_DECL)
+ggc_internal_cleared_alloc (size_t size MEM_STAT_DECL)
{
return xcalloc (size, 1);
}
diff --git a/gcc/ggc-page.c b/gcc/ggc-page.c
index ccc87ea..ae5e88a 100644
--- a/gcc/ggc-page.c
+++ b/gcc/ggc-page.c
@@ -1202,7 +1202,7 @@ ggc_round_alloc_size (size_t requested_size)
/* Allocate a chunk of memory of SIZE bytes. Its contents are undefined. */
void *
-ggc_internal_alloc_stat (size_t size MEM_STAT_DECL)
+ggc_internal_alloc (size_t size MEM_STAT_DECL)
{
size_t order, word, bit, object_offset, object_size;
struct page_entry *entry;
diff --git a/gcc/ggc.h b/gcc/ggc.h
index 55f3fe9..0af69f5 100644
--- a/gcc/ggc.h
+++ b/gcc/ggc.h
@@ -136,59 +136,44 @@ extern void gt_pch_save (FILE *f);
/* Allocation. */
/* The internal primitive. */
-extern void *ggc_internal_alloc_stat (size_t MEM_STAT_DECL)
- ATTRIBUTE_MALLOC;
+extern void *ggc_internal_alloc (size_t CXX_MEM_STAT_INFO) ATTRIBUTE_MALLOC;
extern size_t ggc_round_alloc_size (size_t requested_size);
-#define ggc_internal_alloc(s) ggc_internal_alloc_stat (s MEM_STAT_INFO)
-
/* Allocates cleared memory. */
-extern void *ggc_internal_cleared_alloc_stat (size_t MEM_STAT_DECL)
+extern void *ggc_internal_cleared_alloc (size_t CXX_MEM_STAT_INFO)
ATTRIBUTE_MALLOC;
-#define ggc_internal_cleared_alloc(s) ggc_internal_cleared_alloc_stat (s
MEM_STAT_INFO)
/* Resize a block. */
-extern void *ggc_realloc_stat (void *, size_t MEM_STAT_DECL);
+extern void *ggc_realloc (void *, size_t CXX_MEM_STAT_INFO);
/* Free a block. To be used when known for certain it's not reachable. */
extern void ggc_free (void *);
extern void dump_ggc_loc_statistics (bool);
-/* Reallocators. */
+/* Reallocator. */
#define GGC_RESIZEVEC(T, P, N) \
- ((T *) ggc_realloc_stat ((P), (N) * sizeof (T) MEM_STAT_INFO))
-
-#define GGC_RESIZEVAR(T, P, N) \
- ((T *) ggc_realloc_stat ((P), (N) MEM_STAT_INFO))
+ ((T *) ggc_realloc ((P), (N) * sizeof (T) MEM_STAT_INFO))
static inline void *
-ggc_internal_vec_alloc_stat (size_t s, size_t c MEM_STAT_DECL)
+ggc_internal_vec_alloc (size_t s, size_t c MEM_STAT_DECL)
{
- return ggc_internal_alloc_stat (c * s PASS_MEM_STAT);
+ return ggc_internal_alloc (c * s PASS_MEM_STAT);
}
static inline void *
-ggc_internal_cleared_vec_alloc_stat (size_t s, size_t c MEM_STAT_DECL)
+ggc_internal_cleared_vec_alloc (size_t s, size_t c CXX_MEM_STAT_INFO)
{
- return ggc_internal_cleared_alloc_stat (c * s PASS_MEM_STAT);
+ return ggc_internal_cleared_alloc (c * s PASS_MEM_STAT);
}
-#define ggc_internal_cleared_vec_alloc(s, c) \
- (ggc_internal_cleared_vec_alloc_stat ((s), (c) MEM_STAT_INFO))
-
static inline void *
-ggc_alloc_atomic_stat (size_t s MEM_STAT_DECL)
+ggc_alloc_atomic (size_t s CXX_MEM_STAT_INFO)
{
- return ggc_internal_alloc_stat (s PASS_MEM_STAT);
+ return ggc_internal_alloc (s PASS_MEM_STAT);
}
-#define ggc_alloc_atomic(S) (ggc_alloc_atomic_stat ((S) MEM_STAT_INFO))
-
-#define ggc_alloc_cleared_atomic(S) \
- (ggc_internal_cleared_alloc_stat ((S) MEM_STAT_INFO))
-
extern void *ggc_cleared_alloc_htab_ignore_args (size_t, size_t)
ATTRIBUTE_MALLOC;
@@ -213,13 +198,11 @@ extern void ggc_splay_dont_free (void *, void *);
/* Allocate a gc-able string, and fill it with LENGTH bytes from CONTENTS.
If LENGTH is -1, then CONTENTS is assumed to be a
null-terminated string and the memory sized accordingly. */
-extern const char *ggc_alloc_string_stat (const char *contents, int length
- MEM_STAT_DECL);
-
-#define ggc_alloc_string(c, l) ggc_alloc_string_stat (c, l MEM_STAT_INFO)
+extern const char *ggc_alloc_string (const char *contents, int length
+ CXX_MEM_STAT_INFO);
/* Make a copy of S, in GC-able memory. */
-#define ggc_strdup(S) ggc_alloc_string_stat ((S), -1 MEM_STAT_INFO)
+#define ggc_strdup(S) ggc_alloc_string ((S), -1 MEM_STAT_INFO)
/* Invoke the collector. Garbage collection occurs only when this
function is called, not during allocations. */
@@ -253,35 +236,35 @@ extern void init_ggc_heuristics (void);
/* Memory statistics passing versions of some allocators. Too few of them to
make gengtype produce them, so just define the needed ones here. */
static inline struct rtx_def *
-ggc_alloc_rtx_def_stat (size_t s MEM_STAT_DECL)
+ggc_alloc_rtx_def_stat (size_t s CXX_MEM_STAT_INFO)
{
- return (struct rtx_def *) ggc_internal_alloc_stat (s PASS_MEM_STAT);
+ return (struct rtx_def *) ggc_internal_alloc (s PASS_MEM_STAT);
}
static inline union tree_node *
-ggc_alloc_tree_node_stat (size_t s MEM_STAT_DECL)
+ggc_alloc_tree_node_stat (size_t s CXX_MEM_STAT_INFO)
{
- return (union tree_node *) ggc_internal_alloc_stat (s PASS_MEM_STAT);
+ return (union tree_node *) ggc_internal_alloc (s PASS_MEM_STAT);
}
static inline union tree_node *
-ggc_alloc_cleared_tree_node_stat (size_t s MEM_STAT_DECL)
+ggc_alloc_cleared_tree_node_stat (size_t s CXX_MEM_STAT_INFO)
{
- return (union tree_node *) ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
+ return (union tree_node *) ggc_internal_cleared_alloc (s PASS_MEM_STAT);
}
static inline struct gimple_statement_base *
-ggc_alloc_cleared_gimple_statement_stat (size_t s MEM_STAT_DECL)
+ggc_alloc_cleared_gimple_statement_stat (size_t s CXX_MEM_STAT_INFO)
{
return (struct gimple_statement_base *)
- ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
+ ggc_internal_cleared_alloc (s PASS_MEM_STAT);
}
static inline struct simd_clone *
-ggc_alloc_cleared_simd_clone_stat (size_t s MEM_STAT_DECL)
+ggc_alloc_cleared_simd_clone_stat (size_t s CXX_MEM_STAT_INFO)
{
return (struct simd_clone *)
- ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
+ ggc_internal_cleared_alloc (s PASS_MEM_STAT);
}
#endif
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 8552a17..fc6ecb9 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -836,8 +836,7 @@ gimple_build_omp_for (gimple_seq body, int kind, tree
clauses, size_t collapse,
gimple_omp_for_set_kind (p, kind);
p->collapse = collapse;
p->iter = static_cast <struct gimple_omp_for_iter *> (
- ggc_internal_cleared_vec_alloc_stat (sizeof (*p->iter),
- collapse MEM_STAT_INFO));
+ ggc_internal_cleared_vec_alloc (sizeof (*p->iter), collapse));
if (pre_body)
gimple_omp_for_set_pre_body (p, pre_body);
@@ -1667,9 +1666,8 @@ gimple_copy (gimple stmt)
as_a <gimple_statement_omp_for *> (copy);
omp_for_copy->iter =
static_cast <struct gimple_omp_for_iter *> (
- ggc_internal_vec_alloc_stat (sizeof (struct
gimple_omp_for_iter),
- gimple_omp_for_collapse (stmt)
- MEM_STAT_INFO));
+ ggc_internal_vec_alloc (sizeof (struct gimple_omp_for_iter),
+ gimple_omp_for_collapse (stmt)));
}
for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
{
diff --git a/gcc/java/constants.c b/gcc/java/constants.c
index 7e9cf2e..c0295e9 100644
--- a/gcc/java/constants.c
+++ b/gcc/java/constants.c
@@ -46,8 +46,8 @@ set_constant_entry (CPool *cpool, int index, int tag, jword
value)
if (cpool->data == NULL)
{
cpool->capacity = 100;
- cpool->tags = (uint8 *) ggc_alloc_cleared_atomic (sizeof (uint8)
- * cpool->capacity);
+ cpool->tags = (uint8 *) ggc_internal_cleared_alloc (sizeof (uint8)
+ * cpool->capacity);
cpool->data = ggc_alloc_cleared_vec_cpool_entry (sizeof
(union cpool_entry),
cpool->capacity);
diff --git a/gcc/stringpool.c b/gcc/stringpool.c
index 4b6900c..e317525 100644
--- a/gcc/stringpool.c
+++ b/gcc/stringpool.c
@@ -79,7 +79,7 @@ alloc_node (cpp_hash_table *table ATTRIBUTE_UNUSED)
nul-terminated string, and the length is calculated using strlen. */
const char *
-ggc_alloc_string_stat (const char *contents, int length MEM_STAT_DECL)
+ggc_alloc_string (const char *contents, int length MEM_STAT_DECL)
{
char *result;
@@ -91,7 +91,7 @@ ggc_alloc_string_stat (const char *contents, int length
MEM_STAT_DECL)
if (length == 1 && ISDIGIT (contents[0]))
return digit_string (contents[0] - '0');
- result = (char *) ggc_alloc_atomic_stat (length + 1 PASS_MEM_STAT);
+ result = (char *) ggc_internal_cleared_alloc (length + 1 PASS_MEM_STAT);
memcpy (result, contents, length);
result[length] = '\0';
return (const char *) result;
diff --git a/gcc/toplev.c b/gcc/toplev.c
index 0f7d452..9535bd0 100644
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -957,7 +957,7 @@ init_asm_output (const char *name)
static void *
realloc_for_line_map (void *ptr, size_t len)
{
- return GGC_RESIZEVAR (void, ptr, len);
+ return ggc_realloc (ptr, len);
}
/* A helper function: used as the allocator function for
diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h
index 9d819e4..8810a3e 100644
--- a/gcc/tree-data-ref.h
+++ b/gcc/tree-data-ref.h
@@ -565,7 +565,7 @@ lambda_vector_gcd (lambda_vector vector, int size)
static inline lambda_vector
lambda_vector_new (int size)
{
- return (lambda_vector) ggc_alloc_cleared_atomic (sizeof (int) * size);
+ return (lambda_vector) ggc_internal_cleared_alloc (sizeof (int) * size);
}
/* Clear out vector VEC1 of length SIZE. */
diff --git a/gcc/tree-phinodes.c b/gcc/tree-phinodes.c
index 0be431e..5bd8233 100644
--- a/gcc/tree-phinodes.c
+++ b/gcc/tree-phinodes.c
@@ -124,7 +124,7 @@ allocate_phi_node (size_t len)
else
{
phi = static_cast <gimple_statement_phi *> (
- ggc_internal_alloc_stat (size MEM_STAT_INFO));
+ ggc_internal_alloc (size));
if (GATHER_STATISTICS)
{
enum gimple_alloc_kind kind = gimple_alloc_kind (GIMPLE_PHI);
diff --git a/gcc/tree.c b/gcc/tree.c
index 8b44ecc..aa74fd0 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -1892,7 +1892,7 @@ grow_tree_vec_stat (tree v, int len MEM_STAT_DECL)
record_node_allocation_statistics (TREE_VEC, length - oldlength);
- v = (tree) ggc_realloc_stat (v, length PASS_MEM_STAT);
+ v = (tree) ggc_realloc (v, length PASS_MEM_STAT);
TREE_VEC_LENGTH (v) = len;
diff --git a/gcc/vec.h b/gcc/vec.h
index 5873023..2e5313d 100644
--- a/gcc/vec.h
+++ b/gcc/vec.h
@@ -48,9 +48,10 @@ along with GCC; see the file COPYING3. If not see
weak. There are files compiled with -DGENERATOR_FILE that already
include ggc.h. We only need to provide these definitions if ggc.h
has not been included. Sigh. */
+
extern void ggc_free (void *);
extern size_t ggc_round_alloc_size (size_t requested_size);
- extern void *ggc_realloc_stat (void *, size_t MEM_STAT_DECL);
+ extern void *ggc_realloc (void *, size_t CXX_MEM_STAT_INFO);
# endif // GCC_GGC_H
#endif // VEC_GC_ENABLED
@@ -396,7 +397,7 @@ va_gc::reserve (vec<T, A, vl_embed> *&v, unsigned reserve,
bool exact
size = vec_offset + alloc * elt_size;
unsigned nelem = v ? v->length () : 0;
- v = static_cast <vec<T, A, vl_embed> *> (::ggc_realloc_stat (v, size
+ v = static_cast <vec<T, A, vl_embed> *> (::ggc_realloc (v, size
PASS_MEM_STAT));
v->embedded_init (alloc, nelem);
}
--
2.0.0.rc0
