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]

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


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?



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]