rm a bunch of _stat allocation functions

Now that we can use c++ default arguments there's no reason to use
functions and wrapper macros.

gcc/ChangeLog:

	* 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:

	* constants.c (set_constant_entry): Adjust.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@210565 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index fa738a524ccb04b9bc76f9f63f558b68a792dfd2..a82873adc0f872b9ad65fe9c9beac70882683d50 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,42 @@
+2014-05-17  Trevor Saunders  <tsaunders@mozilla.com>
+
+       * 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.
+
 2014-05-17  Ajit Agarwal <ajitkum@xilinx.com>
 
        * config/microblaze/microblaze.c

diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 5874d73821b31480a508ac02017296a7c100e8fd..21833edb0102d05c2226bb8e4923e8af8c79504d 100644 (file)
--- 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 21da84b77d9958fbc54a3eaf23806c915ede0598..4abeba6b33554e020d2fead3b85b40db95da8fc6 100644 (file)
--- a/gcc/gengtype.c
+++ b/gcc/gengtype.c
@@ -5009,7 +5009,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 97c9b87fc1675e479b9b35dce2ac1b87dad99462..e1cc48e6e676150e63e35022ca6cd94ea562dc8d 100644 (file)
--- 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 e6900195457d12a5007d4928b0dee5b9378dea66..aad89bfe00970e9a23d12509dcf05a92a0d6c9b9 100644 (file)
--- 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 ccc87eaa5bea14877044cd512f98347b8f73b906..ae5e88ac00ec333f0a816e6cd04137298bb46603 100644 (file)
--- 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 55f3fe9b0bc5dd85c08fdf2290cbf121ac910335..9bb0642e61098c562e0d8bfdf87d6e58126e034c 100644 (file)
--- 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 091467e99d2f6fa4b44269432c7c1dda511d57b4..3dfe97cf5d74c7f873741fcc08334e32d8500cb2 100644 (file)
--- 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/ChangeLog b/gcc/java/ChangeLog
index 1c357fe25a5cdb12c65d50dfd3c4d9344e5d0522..b6b6c19d2ce69c5717ef3767b19bfcc046859f91 100644 (file)
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,7 @@
+2014-05-17  Trevor Saunders  <tsaunders@mozilla.com>
+
+       * constants.c (set_constant_entry): Adjust.
+
 2014-05-06  Richard Sandiford  <r.sandiford@uk.ibm.com>
 
        * boehm.c (mark_reference_fields): Don't update the mask when

diff --git a/gcc/java/constants.c b/gcc/java/constants.c
index 7e9cf2e7552b5786bb5084f0246ef7bb4b4033c0..c0295e9a2facc7764244291529bfb92e38e3a510 100644 (file)
--- 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 d241c83885b279e41dd5a61b1244e0a5c4cbc34b..520f9a8eb7f110df293e4aa10c1c4a26f751e229 100644 (file)
--- 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 4b6900cd1b791773910c498c4e1e38a1ec1da126..e3175250ede1eeb4098f2c399457d00b93a80ed3 100644 (file)
--- 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 4c334bd451a98d92f3e7f6343b73594f9b822f24..384e73ef645708afc551a54e494c81836c45bd92 100644 (file)
--- 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 9d819e4a0ffb0b9a6128d20c1c856f042614fe33..8810a3ec559a93ae842f4dca0f923fad7e9be0bb 100644 (file)
--- 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 0be431e60680c823721bf477546f59740dd749bb..5bd8233569897d5d22341c0b1d9d33dc7721bb16 100644 (file)
--- 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 4655227e660c3aa5e8f86985b07ebc9bce78f96b..1b89b91dd0409509463da0cda4ff0b842f3324ab 100644 (file)
--- 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 587302344d5deb629e9e9ae68e22b89a813ef0e8..2e5313dd14682d0ac569e515f440ac552d91e2e0 100644 (file)
--- 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);
 }