This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [PATCH 1/5] rm a bunch of _stat allocation functions


On Tue, May 13, 2014 at 8:41 AM,  <tsaunders@mozilla.com> wrote:
> From: Trevor Saunders <tsaunders@mozilla.com>
>
> Hi,
>
> basically this patch is unchanged from the last time I sent this series, except
> I reordered the includes in rtl.c to have ggc.h come before vec.h because vec.h
> declares some functions from ggc.h if building a binary to run on the build
> machine.  The problem is if the function takes default args it can't be
> declared with the default args twice.  So the simplest solution is include
> ggc.h first then vec.h will never try and declare those functions.
>
> Trev
>
> bootstrapped + regtested again, just to be safe ok?

Ok.

Thanks,
Richard.

>
>
> gcc/ChangeLog:
>
> 2014-04-23  tbsaunde  <tbsaunde@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  <tbsaunde@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/rtl.c            |  2 +-
>  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 ++--
>  15 files changed, 49 insertions(+), 67 deletions(-)
>
> diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
> index 5874d73..21833ed 100644
> --- a/gcc/dwarf2out.c
> +++ b/gcc/dwarf2out.c
> @@ -16048,7 +16048,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 1c13eea..bb2c9fb 100644
> --- a/gcc/gengtype.c
> +++ b/gcc/gengtype.c
> @@ -4974,7 +4974,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..9bb0642 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 CXX_MEM_STAT_INFO)
>  {
> -    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 091467e..3dfe97c 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/rtl.c b/gcc/rtl.c
> index d241c83..520f9a8 100644
> --- a/gcc/rtl.c
> +++ b/gcc/rtl.c
> @@ -28,8 +28,8 @@ along with GCC; see the file COPYING3.  If not see
>  #include "system.h"
>  #include "coretypes.h"
>  #include "tm.h"
> -#include "rtl.h"
>  #include "ggc.h"
> +#include "rtl.h"
>  #ifdef GENERATOR_FILE
>  # include "errors.h"
>  #else
> 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 4c334bd..384e73e 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 a578c92..5bd70ef 100644
> --- a/gcc/tree.c
> +++ b/gcc/tree.c
> @@ -2016,7 +2016,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.rc2
>


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]