On Tue, Apr 29, 2014 at 1:08 PM, <tsaund...@mozilla.com> wrote:
> 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?
Ok if it also bootstraps with --enable-gather-detailed-mem-stats.
Thanks,
Richard.
> 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
>
