Index: sbitmap.h
===================================================================
--- sbitmap.h	(revision 189785)
+++ sbitmap.h	(working copy)
@@ -25,17 +25,9 @@ along with GCC; see the file COPYING3.  
    It should be straightforward to convert so for now we keep things simple
    while more important issues are dealt with.  */
 
-#define SBITMAP_ELT_BITS ((unsigned) HOST_BITS_PER_WIDEST_FAST_INT)
+#define SBITMAP_ELT_BITS (HOST_BITS_PER_WIDEST_FAST_INT * 1u)
 #define SBITMAP_ELT_TYPE unsigned HOST_WIDEST_FAST_INT
 
-/* Can't use SBITMAP_ELT_BITS in this macro because it contains a
-   cast.  There is no perfect macro in GCC to test against.  This
-   suffices for roughly 99% of the hosts we run on, and the rest
-   don't have 256 bit integers.  */
-#if HOST_BITS_PER_WIDEST_FAST_INT > 255
-#error Need to increase size of datatype used for popcount
-#endif
-
 struct simple_bitmap_def
 {
   unsigned char *popcount;      /* Population count.  */
Index: sbitmap.c
===================================================================
--- sbitmap.c	(revision 189785)
+++ sbitmap.c	(working copy)
@@ -23,10 +23,16 @@ along with GCC; see the file COPYING3.  
 #include "coretypes.h"
 #include "sbitmap.h"
 
+/* This suffices for roughly 99% of the hosts we run on, and the rest
+   don't have 256 bit integers.  */
+#if SBITMAP_ELT_BITS > 255
+#error Need to increase size of datatype used for popcount
+#endif
+
 #if GCC_VERSION >= 3400
-#  if HOST_BITS_PER_WIDEST_FAST_INT == HOST_BITS_PER_LONG
+#  if SBITMAP_ELT_BITS == HOST_BITS_PER_LONG
 #    define do_popcount(x) __builtin_popcountl(x)
-#  elif HOST_BITS_PER_WIDEST_FAST_INT == HOST_BITS_PER_LONGLONG
+#  elif SBITMAP_ELT_BITS == HOST_BITS_PER_LONGLONG
 #    define do_popcount(x) __builtin_popcountll(x)
 #  else
 #    error "internal error: sbitmap.h and hwint.h are inconsistent"
Index: configure.ac
===================================================================
--- configure.ac	(revision 189784)
+++ configure.ac	(working copy)
@@ -588,10 +588,9 @@ AC_ARG_ENABLE(gather-detailed-mem-stats,
 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
 		[enable detailed memory allocation stats gathering])], [],
 [enable_gather_detailed_mem_stats=no])
-if test x$enable_gather_detailed_mem_stats = xyes ; then
-  AC_DEFINE(GATHER_STATISTICS, 1,
-        [Define to enable detailed memory allocation stats gathering.])
-fi
+gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
+AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
+[Define to enable detailed memory allocation stats gathering.])
 
 # -------------------------------
 # Miscenalleous configure options
Index: configure
===================================================================
--- configure	(revision 189784)
+++ configure	(working copy)
@@ -6986,11 +6986,12 @@ else
   enable_gather_detailed_mem_stats=no
 fi
 
-if test x$enable_gather_detailed_mem_stats = xyes ; then
+gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
 
-$as_echo "#define GATHER_STATISTICS 1" >>confdefs.h
+cat >>confdefs.h <<_ACEOF
+#define GATHER_STATISTICS $gather_stats
+_ACEOF
 
-fi
 
 # -------------------------------
 # Miscenalleous configure options
Index: statistics.h
===================================================================
--- statistics.h	(revision 189784)
+++ statistics.h	(working copy)
@@ -22,20 +22,33 @@
 #ifndef GCC_STATISTICS
 #define GCC_STATISTICS
 
-#ifdef GATHER_STATISTICS
-#define MEM_STAT_DECL , const char * ARG_UNUSED (_loc_name), int ARG_UNUSED (_loc_line), const char * ARG_UNUSED (_loc_function)
-#define ALONE_MEM_STAT_DECL const char * ARG_UNUSED (_loc_name), int ARG_UNUSED (_loc_line), const char * ARG_UNUSED (_loc_function)
-#define PASS_MEM_STAT , _loc_name, _loc_line,  _loc_function
+#if ! defined GATHER_STATISTICS
+#error GATHER_STATISTICS must be defined
+#endif
+
+#define GCC_MEM_STAT_ARGUMENTS const char * ARG_UNUSED (_loc_name), int ARG_UNUSED (_loc_line), const char * ARG_UNUSED (_loc_function)
+#if GATHER_STATISTICS
+#define ALONE_MEM_STAT_DECL GCC_MEM_STAT_ARGUMENTS
+#define ALONE_FINAL_MEM_STAT_DECL ALONE_MEM_STAT_INFO
 #define ALONE_PASS_MEM_STAT _loc_name, _loc_line,  _loc_function
-#define MEM_STAT_INFO , __FILE__, __LINE__, __FUNCTION__
+#define ALONE_FINAL_PASS_MEM_STAT ALONE_PASS_MEM_STAT
 #define ALONE_MEM_STAT_INFO __FILE__, __LINE__, __FUNCTION__
+#define MEM_STAT_DECL , ALONE_MEM_STAT_DECL
+#define FINAL_MEM_STAT_DECL , ALONE_FINAL_MEM_STAT_DECL
+#define PASS_MEM_STAT , ALONE_PASS_MEM_STAT
+#define FINAL_PASS_MEM_STAT , ALONE_FINAL_PASS_MEM_STAT
+#define MEM_STAT_INFO , ALONE_MEM_STAT_INFO
 #else
-#define MEM_STAT_DECL
 #define ALONE_MEM_STAT_DECL void
-#define PASS_MEM_STAT
+#define ALONE_FINAL_MEM_STAT_DECL GCC_MEM_STAT_ARGUMENTS
 #define ALONE_PASS_MEM_STAT
-#define MEM_STAT_INFO
+#define ALONE_FINAL_PASS_MEM_STAT 0,0,0
 #define ALONE_MEM_STAT_INFO
+#define MEM_STAT_DECL
+#define FINAL_MEM_STAT_DECL , ALONE_FINAL_MEM_STAT_DECL
+#define PASS_MEM_STAT
+#define FINAL_PASS_MEM_STAT , ALONE_FINAL_PASS_MEM_STAT
+#define MEM_STAT_INFO ALONE_MEM_STAT_INFO
 #endif
 
 struct function;
Index: ggc-internal.h
===================================================================
--- ggc-internal.h	(revision 189784)
+++ ggc-internal.h	(working copy)
@@ -94,7 +94,7 @@ extern void ggc_pch_read (FILE *, void *
 /* When set, ggc_collect will do collection.  */
 extern bool ggc_force_collect;
 
-extern void ggc_record_overhead (size_t, size_t, void * MEM_STAT_DECL);
+extern void ggc_record_overhead (size_t, size_t, void * FINAL_MEM_STAT_DECL);
 
 extern void ggc_free_overhead (void *);
 
Index: ggc.h
===================================================================
--- ggc.h	(revision 189784)
+++ ggc.h	(working copy)
@@ -166,10 +166,6 @@ extern void *ggc_realloc_stat (void *, s
 /* Free a block.  To be used when known for certain it's not reachable.  */
 extern void ggc_free (void *);
 
-extern void ggc_record_overhead (size_t, size_t, void * MEM_STAT_DECL);
-extern void ggc_free_overhead (void *);
-extern void ggc_prune_overhead_list (void);
-
 extern void dump_ggc_loc_statistics (bool);
 
 /* Reallocators.  */
Index: ggc-common.c
===================================================================
--- ggc-common.c	(revision 189784)
+++ ggc-common.c	(working copy)
@@ -845,8 +845,6 @@ init_ggc_heuristics (void)
 #endif
 }
 
-#ifdef GATHER_STATISTICS
-
 /* Datastructure used to store per-call-site statistics.  */
 struct loc_descriptor
 {
@@ -1040,16 +1038,18 @@ add_statistics (void **slot, void *b)
 }
 
 /* Dump per-site memory statistics.  */
-#endif
+
 void
-dump_ggc_loc_statistics (bool final ATTRIBUTE_UNUSED)
+dump_ggc_loc_statistics (bool final)
 {
-#ifdef GATHER_STATISTICS
   int nentries = 0;
   char s[4096];
   size_t collected = 0, freed = 0, allocated = 0, overhead = 0, times = 0;
   int i;
 
+  if (! GATHER_STATISTICS)
+    return;
+
   ggc_force_collect = true;
   ggc_collect ();
 
@@ -1102,5 +1102,4 @@ dump_ggc_loc_statistics (bool final ATTR
 	   "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
   fprintf (stderr, "-------------------------------------------------------\n");
   ggc_force_collect = false;
-#endif
 }
Index: ggc-zone.c
===================================================================
--- ggc-zone.c	(revision 189784)
+++ ggc-zone.c	(working copy)
@@ -216,10 +216,8 @@ typedef struct page_entry
   /* The zone that this page entry belongs to.  */
   struct alloc_zone *zone;
 
-#ifdef GATHER_STATISTICS
   /* How many collections we've survived.  */
   size_t survived;
-#endif
 
   /* Does this page contain small objects, or one large object?  */
   bool large_p;
@@ -403,7 +401,6 @@ struct alloc_zone
   /* True if this zone should be destroyed after the next collection.  */
   bool dead;
 
-#ifdef GATHER_STATISTICS
   struct
   {
     /* Total GC-allocated memory.  */
@@ -424,7 +421,6 @@ struct alloc_zone
     unsigned long long total_allocated_under128;
     unsigned long long total_overhead_under128;
   } stats;
-#endif
 } main_zone;
 
 /* Some default zones.  */
@@ -931,9 +927,7 @@ alloc_large_page (size_t size, struct al
   entry->common.large_p = true;
   entry->common.pch_p = false;
   entry->common.zone = zone;
-#ifdef GATHER_STATISTICS
   entry->common.survived = 0;
-#endif
   entry->mark_p = false;
   entry->bytes = size;
   entry->prev = NULL;
@@ -1250,9 +1244,7 @@ ggc_internal_alloc_zone_stat (size_t ori
     {
       struct large_page_entry *entry = alloc_large_page (size, zone);
 
-#ifdef GATHER_STATISTICS
       entry->common.survived = 0;
-#endif
 
       entry->next = zone->large_pages;
       if (zone->large_pages)
@@ -1315,8 +1307,8 @@ ggc_internal_alloc_zone_stat (size_t ori
 
   timevar_ggc_mem_total += size;
 
-#ifdef GATHER_STATISTICS
-  ggc_record_overhead (orig_size, size - orig_size, result PASS_MEM_STAT);
+  if (GATHER_STATISTICS)
+    ggc_record_overhead (orig_size, size - orig_size, result FINAL_PASS_MEM_STAT);
 
   {
     size_t object_size = size;
@@ -1413,9 +1405,8 @@ ggc_free (void *p)
 {
   struct page_entry *page;
 
-#ifdef GATHER_STATISTICS
-  ggc_free_overhead (p);
-#endif
+  if (GATHER_STATISTICS)
+    ggc_free_overhead (p);
 
   poison_region (p, ggc_get_size (p));
 
@@ -1753,10 +1744,8 @@ sweep_pages (struct alloc_zone *zone)
 
       lnext = lp->next;
 
-#ifdef GATHER_STATISTICS
       /* This page has now survived another collection.  */
       lp->common.survived++;
-#endif
 
       if (lp->mark_p)
 	{
@@ -1791,10 +1780,8 @@ sweep_pages (struct alloc_zone *zone)
 
       snext = sp->next;
 
-#ifdef GATHER_STATISTICS
       /* This page has now survived another collection.  */
       sp->common.survived++;
-#endif
 
       /* Step through all chunks, consolidate those that are free and
 	 insert them into the free lists.  Note that consolidation
@@ -1948,9 +1935,8 @@ ggc_collect_1 (struct alloc_zone *zone, 
     {
       zone_allocate_marks ();
       ggc_mark_roots ();
-#ifdef GATHER_STATISTICS
-      ggc_prune_overhead_list ();
-#endif
+      if (GATHER_STATISTICS)
+	ggc_prune_overhead_list ();
     }
 
   sweep_pages (zone);
@@ -1962,7 +1948,6 @@ ggc_collect_1 (struct alloc_zone *zone, 
   return true;
 }
 
-#ifdef GATHER_STATISTICS
 /* Calculate the average page survival rate in terms of number of
    collections.  */
 
@@ -1985,7 +1970,6 @@ calculate_average_page_survival (struct 
     }
   return survival/count;
 }
-#endif
 
 /* Top level collection routine.  */
 
@@ -2047,9 +2031,8 @@ ggc_collect (void)
 	}
     }
 
-#ifdef GATHER_STATISTICS
   /* Print page survival stats, if someone wants them.  */
-  if (GGC_DEBUG_LEVEL >= 2)
+  if (GATHER_STATISTICS && GGC_DEBUG_LEVEL >= 2)
     {
       for (zone = G.zones; zone; zone = zone->next_zone)
 	{
@@ -2061,7 +2044,6 @@ ggc_collect (void)
 	    }
 	}
     }
-#endif
 
   if (marked)
     zone_free_marks ();
@@ -2210,54 +2192,53 @@ ggc_print_statistics (void)
 	   SCALE (total_allocated), LABEL(total_allocated),
 	   SCALE (total_overhead), LABEL (total_overhead));
 
-#ifdef GATHER_STATISTICS
-  {
-    unsigned long long all_overhead = 0, all_allocated = 0;
-    unsigned long long all_overhead_under32 = 0, all_allocated_under32 = 0;
-    unsigned long long all_overhead_under64 = 0, all_allocated_under64 = 0;
-    unsigned long long all_overhead_under128 = 0, all_allocated_under128 = 0;
-
-    fprintf (stderr, "\nTotal allocations and overheads during the compilation process\n");
-
-    for (zone = G.zones; zone; zone = zone->next_zone)
-      {
-	all_overhead += zone->stats.total_overhead;
-	all_allocated += zone->stats.total_allocated;
-
-	all_allocated_under32 += zone->stats.total_allocated_under32;
-	all_overhead_under32 += zone->stats.total_overhead_under32;
+  if (GATHER_STATISTICS)
+    {
+      unsigned long long all_overhead = 0, all_allocated = 0;
+      unsigned long long all_overhead_under32 = 0, all_allocated_under32 = 0;
+      unsigned long long all_overhead_under64 = 0, all_allocated_under64 = 0;
+      unsigned long long all_overhead_under128 = 0, all_allocated_under128 = 0;
 
-	all_allocated_under64 += zone->stats.total_allocated_under64;
-	all_overhead_under64 += zone->stats.total_overhead_under64;
+      fprintf (stderr, "\nTotal allocations and overheads during the compilation process\n");
 
-	all_allocated_under128 += zone->stats.total_allocated_under128;
-	all_overhead_under128 += zone->stats.total_overhead_under128;
+      for (zone = G.zones; zone; zone = zone->next_zone)
+	{
+	  all_overhead += zone->stats.total_overhead;
+	  all_allocated += zone->stats.total_allocated;
 
-	fprintf (stderr, "%20s:                  %10lld\n",
-		 zone->name, zone->stats.total_allocated);
-      }
+	  all_allocated_under32 += zone->stats.total_allocated_under32;
+	  all_overhead_under32 += zone->stats.total_overhead_under32;
 
-    fprintf (stderr, "\n");
+	  all_allocated_under64 += zone->stats.total_allocated_under64;
+	  all_overhead_under64 += zone->stats.total_overhead_under64;
 
-    fprintf (stderr, "Total Overhead:                        %10lld\n",
-             all_overhead);
-    fprintf (stderr, "Total Allocated:                       %10lld\n",
-             all_allocated);
-
-    fprintf (stderr, "Total Overhead  under  32B:            %10lld\n",
-             all_overhead_under32);
-    fprintf (stderr, "Total Allocated under  32B:            %10lld\n",
-             all_allocated_under32);
-    fprintf (stderr, "Total Overhead  under  64B:            %10lld\n",
-             all_overhead_under64);
-    fprintf (stderr, "Total Allocated under  64B:            %10lld\n",
-             all_allocated_under64);
-    fprintf (stderr, "Total Overhead  under 128B:            %10lld\n",
-             all_overhead_under128);
-    fprintf (stderr, "Total Allocated under 128B:            %10lld\n",
-             all_allocated_under128);
-  }
-#endif
+	  all_allocated_under128 += zone->stats.total_allocated_under128;
+	  all_overhead_under128 += zone->stats.total_overhead_under128;
+
+	  fprintf (stderr, "%20s:                  %10lld\n",
+		   zone->name, zone->stats.total_allocated);
+	}
+
+      fprintf (stderr, "\n");
+
+      fprintf (stderr, "Total Overhead:                        %10lld\n",
+	       all_overhead);
+      fprintf (stderr, "Total Allocated:                       %10lld\n",
+	       all_allocated);
+
+      fprintf (stderr, "Total Overhead  under  32B:            %10lld\n",
+	       all_overhead_under32);
+      fprintf (stderr, "Total Allocated under  32B:            %10lld\n",
+	       all_allocated_under32);
+      fprintf (stderr, "Total Overhead  under  64B:            %10lld\n",
+	       all_overhead_under64);
+      fprintf (stderr, "Total Allocated under  64B:            %10lld\n",
+	       all_allocated_under64);
+      fprintf (stderr, "Total Overhead  under 128B:            %10lld\n",
+	       all_overhead_under128);
+      fprintf (stderr, "Total Allocated under 128B:            %10lld\n",
+	       all_allocated_under128);
+    }
 }
 
 /* Precompiled header support.  */
@@ -2472,13 +2453,14 @@ ggc_pch_read (FILE *f, void *addr)
   pch_zone.page = (char *) addr;
   pch_zone.end = (char *) pch_zone.alloc_bits;
 
-  /* We've just read in a PCH file.  So, every object that used to be
-     allocated is now free.  */
-#ifdef GATHER_STATISTICS
-  zone_allocate_marks ();
-  ggc_prune_overhead_list ();
-  zone_free_marks ();
-#endif
+  if (GATHER_STATISTICS)
+    {
+      /* We've just read in a PCH file.  So, every object that used to be
+	 allocated is now free.  */
+      zone_allocate_marks ();
+      ggc_prune_overhead_list ();
+      zone_free_marks ();
+    }
 
   for (zone = G.zones; zone; zone = zone->next_zone)
     {
Index: ggc-page.c
===================================================================
--- ggc-page.c	(revision 189784)
+++ ggc-page.c	(working copy)
@@ -432,7 +432,6 @@ static struct globals
   struct free_object *free_object_list;
 #endif
 
-#ifdef GATHER_STATISTICS
   struct
   {
     /* Total GC-allocated memory.  */
@@ -459,7 +458,6 @@ static struct globals
     /* The overhead for each of the allocation orders.  */
     unsigned long long total_overhead_per_order[NUM_ORDERS];
   } stats;
-#endif
 } G;
 
 /* The size in bytes required to maintain a bitmap for the objects
@@ -1324,10 +1322,9 @@ ggc_internal_alloc_stat (size_t size MEM
 
   /* Calculate the object's address.  */
   result = entry->page + object_offset;
-#ifdef GATHER_STATISTICS
-  ggc_record_overhead (OBJECT_SIZE (order), OBJECT_SIZE (order) - size,
-		       result PASS_MEM_STAT);
-#endif
+  if (GATHER_STATISTICS)
+    ggc_record_overhead (OBJECT_SIZE (order), OBJECT_SIZE (order) - size,
+			 result FINAL_PASS_MEM_STAT);
 
 #ifdef ENABLE_GC_CHECKING
   /* Keep poisoning-by-writing-0xaf the object, in an attempt to keep the
@@ -1358,32 +1355,31 @@ ggc_internal_alloc_stat (size_t size MEM
   /* For timevar statistics.  */
   timevar_ggc_mem_total += object_size;
 
-#ifdef GATHER_STATISTICS
-  {
-    size_t overhead = object_size - size;
+  if (GATHER_STATISTICS)
+    {
+      size_t overhead = object_size - size;
 
-    G.stats.total_overhead += overhead;
-    G.stats.total_allocated += object_size;
-    G.stats.total_overhead_per_order[order] += overhead;
-    G.stats.total_allocated_per_order[order] += object_size;
+      G.stats.total_overhead += overhead;
+      G.stats.total_allocated += object_size;
+      G.stats.total_overhead_per_order[order] += overhead;
+      G.stats.total_allocated_per_order[order] += object_size;
 
-    if (size <= 32)
-      {
-	G.stats.total_overhead_under32 += overhead;
-	G.stats.total_allocated_under32 += object_size;
-      }
-    if (size <= 64)
-      {
-	G.stats.total_overhead_under64 += overhead;
-	G.stats.total_allocated_under64 += object_size;
-      }
-    if (size <= 128)
-      {
-	G.stats.total_overhead_under128 += overhead;
-	G.stats.total_allocated_under128 += object_size;
-      }
-  }
-#endif
+      if (size <= 32)
+	{
+	  G.stats.total_overhead_under32 += overhead;
+	  G.stats.total_allocated_under32 += object_size;
+	}
+      if (size <= 64)
+	{
+	  G.stats.total_overhead_under64 += overhead;
+	  G.stats.total_allocated_under64 += object_size;
+	}
+      if (size <= 128)
+	{
+	  G.stats.total_overhead_under128 += overhead;
+	  G.stats.total_allocated_under128 += object_size;
+	}
+    }
 
   if (GGC_DEBUG_LEVEL >= 3)
     fprintf (G.debug_file,
@@ -1524,9 +1520,8 @@ ggc_free (void *p)
   size_t order = pe->order;
   size_t size = OBJECT_SIZE (order);
 
-#ifdef GATHER_STATISTICS
-  ggc_free_overhead (p);
-#endif
+  if (GATHER_STATISTICS)
+    ggc_free_overhead (p);
 
   if (GGC_DEBUG_LEVEL >= 3)
     fprintf (G.debug_file,
@@ -2070,9 +2065,10 @@ ggc_collect (void)
 
   clear_marks ();
   ggc_mark_roots ();
-#ifdef GATHER_STATISTICS
-  ggc_prune_overhead_list ();
-#endif
+
+  if (GATHER_STATISTICS)
+    ggc_prune_overhead_list ();
+
   poison_pages ();
   validate_free_objects ();
   sweep_pages ();
@@ -2160,40 +2156,39 @@ ggc_print_statistics (void)
 	   SCALE (G.allocated), STAT_LABEL(G.allocated),
 	   SCALE (total_overhead), STAT_LABEL (total_overhead));
 
-#ifdef GATHER_STATISTICS
-  {
-    fprintf (stderr, "\nTotal allocations and overheads during the compilation process\n");
+  if (GATHER_STATISTICS)
+    {
+      fprintf (stderr, "\nTotal allocations and overheads during the compilation process\n");
 
-    fprintf (stderr, "Total Overhead:                        %10lld\n",
-             G.stats.total_overhead);
-    fprintf (stderr, "Total Allocated:                       %10lld\n",
-             G.stats.total_allocated);
-
-    fprintf (stderr, "Total Overhead  under  32B:            %10lld\n",
-             G.stats.total_overhead_under32);
-    fprintf (stderr, "Total Allocated under  32B:            %10lld\n",
-             G.stats.total_allocated_under32);
-    fprintf (stderr, "Total Overhead  under  64B:            %10lld\n",
-             G.stats.total_overhead_under64);
-    fprintf (stderr, "Total Allocated under  64B:            %10lld\n",
-             G.stats.total_allocated_under64);
-    fprintf (stderr, "Total Overhead  under 128B:            %10lld\n",
-             G.stats.total_overhead_under128);
-    fprintf (stderr, "Total Allocated under 128B:            %10lld\n",
-             G.stats.total_allocated_under128);
+      fprintf (stderr, "Total Overhead:                        %10lld\n",
+	       G.stats.total_overhead);
+      fprintf (stderr, "Total Allocated:                       %10lld\n",
+	       G.stats.total_allocated);
+
+      fprintf (stderr, "Total Overhead  under  32B:            %10lld\n",
+	       G.stats.total_overhead_under32);
+      fprintf (stderr, "Total Allocated under  32B:            %10lld\n",
+	       G.stats.total_allocated_under32);
+      fprintf (stderr, "Total Overhead  under  64B:            %10lld\n",
+	       G.stats.total_overhead_under64);
+      fprintf (stderr, "Total Allocated under  64B:            %10lld\n",
+	       G.stats.total_allocated_under64);
+      fprintf (stderr, "Total Overhead  under 128B:            %10lld\n",
+	       G.stats.total_overhead_under128);
+      fprintf (stderr, "Total Allocated under 128B:            %10lld\n",
+	       G.stats.total_allocated_under128);
 
-    for (i = 0; i < NUM_ORDERS; i++)
-      if (G.stats.total_allocated_per_order[i])
-        {
-          fprintf (stderr, "Total Overhead  page size %7lu:     %10lld\n",
-                   (unsigned long) OBJECT_SIZE (i),
-		   G.stats.total_overhead_per_order[i]);
-          fprintf (stderr, "Total Allocated page size %7lu:     %10lld\n",
-                   (unsigned long) OBJECT_SIZE (i),
-		   G.stats.total_allocated_per_order[i]);
-        }
+      for (i = 0; i < NUM_ORDERS; i++)
+	if (G.stats.total_allocated_per_order[i])
+	  {
+	    fprintf (stderr, "Total Overhead  page size %7lu:     %10lld\n",
+		     (unsigned long) OBJECT_SIZE (i),
+		     G.stats.total_overhead_per_order[i]);
+	    fprintf (stderr, "Total Allocated page size %7lu:     %10lld\n",
+		     (unsigned long) OBJECT_SIZE (i),
+		     G.stats.total_allocated_per_order[i]);
+	  }
   }
-#endif
 }
 
 struct ggc_pch_ondisk
Index: bitmap.h
===================================================================
--- bitmap.h	(revision 189784)
+++ bitmap.h	(working copy)
@@ -78,9 +78,7 @@ typedef struct GTY(()) bitmap_head_def {
   unsigned int indx;		/* Index of last element looked at.  */
   bitmap_obstack *obstack;	/* Obstack to allocate elements from.
 				   If NULL, then use GGC allocation.  */
-#ifdef GATHER_STATISTICS
   struct bitmap_descriptor GTY((skip)) *desc;
-#endif
 } bitmap_head;
 
 /* Global data */
@@ -166,9 +164,8 @@ bitmap_initialize_stat (bitmap head, bit
 {
   head->first = head->current = NULL;
   head->obstack = obstack;
-#ifdef GATHER_STATISTICS
-  bitmap_register (head PASS_MEM_STAT);
-#endif
+  if (GATHER_STATISTICS)
+    bitmap_register (head PASS_MEM_STAT);
 }
 #define bitmap_initialize(h,o) bitmap_initialize_stat (h,o MEM_STAT_INFO)
 
Index: gimple.h
===================================================================
--- gimple.h	(revision 189784)
+++ gimple.h	(working copy)
@@ -5270,7 +5270,6 @@ tree walk_gimple_stmt (gimple_stmt_itera
 		       struct walk_stmt_info *);
 tree walk_gimple_op (gimple, walk_tree_fn, struct walk_stmt_info *);
 
-#ifdef GATHER_STATISTICS
 /* Enum and arrays used for allocation stats.  Keep in sync with
    gimple.c:gimple_alloc_kind_names.  */
 enum gimple_alloc_kind
@@ -5301,7 +5300,6 @@ gimple_alloc_kind (enum gimple_code code
 	return gimple_alloc_kind_rest;
     }
 }
-#endif /* GATHER_STATISTICS */
 
 extern void dump_gimple_statistics (void);
 
Index: tree-flow.h
===================================================================
--- tree-flow.h	(revision 189784)
+++ tree-flow.h	(working copy)
@@ -511,9 +511,7 @@ extern void remove_phi_args (edge);
 extern void remove_phi_node (gimple_stmt_iterator *, bool);
 extern void remove_phi_nodes (basic_block);
 extern void release_phi_node (gimple);
-#ifdef GATHER_STATISTICS
 extern void phinodes_print_statistics (void);
-#endif
 
 /* In gimple-low.c  */
 extern void record_vars_into (tree, tree);
@@ -599,9 +597,7 @@ extern void set_ptr_info_alignment (stru
 extern void adjust_ptr_info_misalignment (struct ptr_info_def *,
 					  unsigned int);
 
-#ifdef GATHER_STATISTICS
 extern void ssanames_print_statistics (void);
-#endif
 
 /* In tree-ssa-ccp.c  */
 tree fold_const_aggregate_ref (tree);
Index: vec.h
===================================================================
--- vec.h	(revision 189784)
+++ vec.h	(working copy)
@@ -482,12 +482,7 @@ extern void *vec_heap_o_reserve (void *,
 extern void *vec_heap_o_reserve_exact (void *, int, size_t, size_t
 				       MEM_STAT_DECL);
 extern void dump_vec_loc_statistics (void);
-#ifdef GATHER_STATISTICS
-void vec_heap_free (void *);
-#else
-/* Avoid problems with frontends that #define free(x).  */
-#define vec_heap_free(V) (free) (V)
-#endif
+extern void vec_heap_free (void *);
 
 #if ENABLE_CHECKING
 #define VEC_CHECK_INFO ,__FILE__,__LINE__,__FUNCTION__
@@ -1356,7 +1351,8 @@ extern void *vec_stack_o_reserve_exact (
 					 MEM_STAT_DECL);
 extern void vec_stack_free (void *);
 
-#ifdef GATHER_STATISTICS
+/* Unfortunately, we cannot use MEM_STAT_DECL here.  */
+#if GATHER_STATISTICS
 #define VEC_stack_alloc(T,alloc,name,line,function)			  \
   (VEC_OP (T,stack,alloc1)						  \
    (alloc, XALLOCAVAR (VEC(T,stack), VEC_embedded_size (T, alloc))))
Index: alloc-pool.c
===================================================================
--- alloc-pool.c	(revision 189784)
+++ alloc-pool.c	(working copy)
@@ -62,8 +62,6 @@ typedef struct allocation_object_def
 static ALLOC_POOL_ID_TYPE last_id;
 #endif
 
-#ifdef GATHER_STATISTICS
-
 /* Store information about each particular alloc_pool.  Note that this
    will underestimate the amount the amount of storage used by a small amount:
    1) The overhead in a pool is not accounted for.
@@ -123,7 +121,6 @@ alloc_pool_descriptor (const char *name)
   (*slot)->name = name;
   return *slot;
 }
-#endif
 
 /* Create a pool of things of size SIZE, with NUM in each block we
    allocate.  */
@@ -133,9 +130,6 @@ create_alloc_pool (const char *name, siz
 {
   alloc_pool pool;
   size_t header_size;
-#ifdef GATHER_STATISTICS
-  struct alloc_pool_descriptor *desc;
-#endif
 
   gcc_checking_assert (name);
 
@@ -146,10 +140,11 @@ create_alloc_pool (const char *name, siz
   /* Now align the size to a multiple of 4.  */
   size = align_eight (size);
 
-#ifdef ENABLE_CHECKING
-  /* Add the aligned size of ID.  */
-  size += offsetof (allocation_object, u.data);
-#endif
+  if (ENABLE_CHECKING)
+    {
+      /* Add the aligned size of ID.  */
+      size += offsetof (allocation_object, u.data);
+    }
 
   /* Um, we can't really allocate 0 elements per block.  */
   gcc_checking_assert (num);
@@ -159,14 +154,16 @@ create_alloc_pool (const char *name, siz
 
   /* Now init the various pieces of our pool structure.  */
   pool->name = /*xstrdup (name)*/name;
-#ifdef GATHER_STATISTICS
-  desc = alloc_pool_descriptor (name);
-  desc->elt_size = size;
-  desc->created++;
-#endif
   pool->elt_size = size;
   pool->elts_per_block = num;
 
+  if (GATHER_STATISTICS)
+    {
+      struct alloc_pool_descriptor *desc = alloc_pool_descriptor (name);
+      desc->elt_size = size;
+      desc->created++;
+    }
+
   /* List header size should be a multiple of 8.  */
   header_size = align_eight (sizeof (struct alloc_pool_list_def));
 
@@ -197,9 +194,6 @@ void
 empty_alloc_pool (alloc_pool pool)
 {
   alloc_pool_list block, next_block;
-#ifdef GATHER_STATISTICS
-  struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
-#endif
 
   gcc_checking_assert (pool);
 
@@ -210,9 +204,12 @@ empty_alloc_pool (alloc_pool pool)
       free (block);
     }
 
-#ifdef GATHER_STATISTICS
-  desc->current -= (pool->elts_allocated - pool->elts_free) * pool->elt_size;
-#endif
+  if (GATHER_STATISTICS)
+    {
+      struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
+      desc->current -= (pool->elts_allocated - pool->elts_free) * pool->elt_size;
+    }
+
   pool->returned_free_list = NULL;
   pool->virgin_free_list = NULL;
   pool->virgin_elts_remaining = 0;
@@ -251,14 +248,16 @@ void *
 pool_alloc (alloc_pool pool)
 {
   alloc_pool_list header;
-#ifdef GATHER_STATISTICS
-  struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
 
-  desc->allocated += pool->elt_size;
-  desc->current += pool->elt_size;
-  if (desc->peak < desc->current)
-    desc->peak = desc->current;
-#endif
+  if (GATHER_STATISTICS)
+    {
+      struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
+
+      desc->allocated += pool->elt_size;
+      desc->current += pool->elt_size;
+      if (desc->peak < desc->current)
+	desc->peak = desc->current;
+    }
 
   gcc_checking_assert (pool);
 
@@ -324,10 +323,6 @@ void
 pool_free (alloc_pool pool, void *ptr)
 {
   alloc_pool_list header;
-#ifdef GATHER_STATISTICS
-  struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
-#endif
-
 
 #ifdef ENABLE_CHECKING
   gcc_assert (ptr
@@ -340,7 +335,6 @@ pool_free (alloc_pool pool, void *ptr)
 
   /* Mark the element to be free.  */
   ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id = 0;
-#else
 #endif
 
   header = (alloc_pool_list) ptr;
@@ -348,13 +342,14 @@ pool_free (alloc_pool pool, void *ptr)
   pool->returned_free_list = header;
   pool->elts_free++;
 
-#ifdef GATHER_STATISTICS
-  desc->current -= pool->elt_size;
-#endif
-
+  if (GATHER_STATISTICS)
+    {
+      struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
+      desc->current -= pool->elt_size;
+    }
 }
+
 /* Output per-alloc_pool statistics.  */
-#ifdef GATHER_STATISTICS
 
 /* Used to accumulate statistics about alloc_pool sizes.  */
 struct output_info
@@ -382,15 +377,16 @@ print_statistics (void **slot, void *b)
     }
   return 1;
 }
-#endif
 
 /* Output per-alloc_pool memory usage statistics.  */
 void
 dump_alloc_pool_statistics (void)
 {
-#ifdef GATHER_STATISTICS
   struct output_info info;
 
+  if (! GATHER_STATISTICS)
+    return;
+
   if (!alloc_pool_hash)
     return;
 
@@ -403,5 +399,4 @@ dump_alloc_pool_statistics (void)
   fprintf (stderr, "%-22s           %7lu %10lu\n",
 	   "Total", info.total_created, info.total_allocated);
   fprintf (stderr, "--------------------------------------------------------------------------------------------------------------\n");
-#endif
 }
Index: bitmap.c
===================================================================
--- bitmap.c	(revision 189784)
+++ bitmap.c	(working copy)
@@ -26,8 +26,6 @@ along with GCC; see the file COPYING3.  
 #include "bitmap.h"
 #include "hashtab.h"
 
-#ifdef GATHER_STATISTICS
-
 /* Store information about each particular bitmap.  */
 struct bitmap_descriptor
 {
@@ -99,7 +97,7 @@ bitmap_descriptor (const char *file, con
 void
 bitmap_register (bitmap b MEM_STAT_DECL)
 {
-  b->desc = bitmap_descriptor (_loc_name, _loc_function, _loc_line);
+  b->desc = bitmap_descriptor (ALONE_FINAL_PASS_MEM_STAT);
   b->desc->created++;
 }
 
@@ -114,7 +112,6 @@ register_overhead (bitmap b, int amount)
   if (b->desc->peak < b->desc->current)
     b->desc->peak = b->desc->current;
 }
-#endif
 
 /* Global data */
 bitmap_element bitmap_zero_bits;  /* An element of all zero bits.  */
@@ -180,9 +177,10 @@ bitmap_element_free (bitmap head, bitmap
       else
 	head->indx = 0;
     }
-#ifdef GATHER_STATISTICS
-  register_overhead (head, -((int)sizeof (bitmap_element)));
-#endif
+
+  if (GATHER_STATISTICS)
+    register_overhead (head, -((int)sizeof (bitmap_element)));
+
   bitmap_elem_to_freelist (head, elt);
 }
 
@@ -230,9 +228,9 @@ bitmap_element_allocate (bitmap head)
 	element = ggc_alloc_bitmap_element_def ();
     }
 
-#ifdef GATHER_STATISTICS
-  register_overhead (head, sizeof (bitmap_element));
-#endif
+  if (GATHER_STATISTICS)
+    register_overhead (head, sizeof (bitmap_element));
+
   memset (element->bits, 0, sizeof (element->bits));
 
   return element;
@@ -245,17 +243,16 @@ bitmap_elt_clear_from (bitmap head, bitm
 {
   bitmap_element *prev;
   bitmap_obstack *bit_obstack = head->obstack;
-#ifdef GATHER_STATISTICS
-  int n;
-#endif
 
   if (!elt) return;
-#ifdef GATHER_STATISTICS
-  n = 0;
-  for (prev = elt; prev; prev = prev->next)
-    n++;
-  register_overhead (head, -sizeof (bitmap_element) * n);
-#endif
+
+  if (GATHER_STATISTICS)
+    {
+      int n = 0;
+      for (prev = elt; prev; prev = prev->next)
+	n++;
+      register_overhead (head, -sizeof (bitmap_element) * n);
+    }
 
   prev = elt->prev;
   if (prev)
@@ -358,9 +355,9 @@ bitmap_obstack_alloc_stat (bitmap_obstac
   else
     map = XOBNEW (&bit_obstack->obstack, bitmap_head);
   bitmap_initialize_stat (map, bit_obstack PASS_MEM_STAT);
-#ifdef GATHER_STATISTICS
-  register_overhead (map, sizeof (bitmap_head));
-#endif
+
+  if (GATHER_STATISTICS)
+    register_overhead (map, sizeof (bitmap_head));
 
   return map;
 }
@@ -374,9 +371,9 @@ bitmap_gc_alloc_stat (ALONE_MEM_STAT_DEC
 
   map = ggc_alloc_bitmap_head_def ();
   bitmap_initialize_stat (map, NULL PASS_MEM_STAT);
-#ifdef GATHER_STATISTICS
-  register_overhead (map, sizeof (bitmap_head));
-#endif
+
+  if (GATHER_STATISTICS)
+    register_overhead (map, sizeof (bitmap_head));
 
   return map;
 }
@@ -390,9 +387,10 @@ bitmap_obstack_free (bitmap map)
     {
       bitmap_clear (map);
       map->first = (bitmap_element *) map->obstack->heads;
-#ifdef GATHER_STATISTICS
-      register_overhead (map, -((int)sizeof (bitmap_head)));
-#endif
+
+      if (GATHER_STATISTICS)
+	register_overhead (map, -((int)sizeof (bitmap_head)));
+
       map->obstack->heads = map;
     }
 }
@@ -557,9 +555,9 @@ bitmap_find_bit (bitmap head, unsigned i
   if (head->current == 0
       || head->indx == indx)
     return head->current;
-#ifdef GATHER_STATISTICS
-  head->desc->nsearches++;
-#endif
+
+  if (GATHER_STATISTICS)
+    head->desc->nsearches++;
 
   if (head->indx < indx)
     /* INDX is beyond head->indx.  Search from head->current
@@ -567,11 +565,10 @@ bitmap_find_bit (bitmap head, unsigned i
     for (element = head->current;
 	 element->next != 0 && element->indx < indx;
 	 element = element->next)
-#ifdef GATHER_STATISTICS
-      head->desc->search_iter++;
-#else
-      ;
-#endif
+      {
+	if (GATHER_STATISTICS)
+	  head->desc->search_iter++;
+      }
 
   else if (head->indx / 2 < indx)
     /* INDX is less than head->indx and closer to head->indx than to
@@ -579,11 +576,10 @@ bitmap_find_bit (bitmap head, unsigned i
     for (element = head->current;
 	 element->prev != 0 && element->indx > indx;
 	 element = element->prev)
-#ifdef GATHER_STATISTICS
-      head->desc->search_iter++;
-#else
-      ;
-#endif
+      {
+	if (GATHER_STATISTICS)
+	  head->desc->search_iter++;
+      }
 
   else
     /* INDX is less than head->indx and closer to 0 than to
@@ -591,11 +587,10 @@ bitmap_find_bit (bitmap head, unsigned i
     for (element = head->first;
 	 element->next != 0 && element->indx < indx;
 	 element = element->next)
-#ifdef GATHER_STATISTICS
-      head->desc->search_iter++;
-#else
-      ;
-#endif
+      if (GATHER_STATISTICS)
+	{
+	  head->desc->search_iter++;
+	}
 
   /* `element' is the nearest to the one we want.  If it's not the one we
      want, the one we want doesn't exist.  */
@@ -2032,6 +2027,24 @@ bitmap_ior_and_into (bitmap a, const_bit
     a->indx = a->current->indx;
   return changed;
 }
+
+/* Compute hash of bitmap (for purposes of hashing).  */
+hashval_t
+bitmap_hash (const_bitmap head)
+{
+  const bitmap_element *ptr;
+  BITMAP_WORD hash = 0;
+  int ix;
+
+  for (ptr = head->first; ptr; ptr = ptr->next)
+    {
+      hash ^= ptr->indx;
+      for (ix = 0; ix != BITMAP_ELEMENT_WORDS; ix++)
+	hash ^= ptr->bits[ix];
+    }
+  return (hashval_t)hash;
+}
+
 
 /* Debugging function to print out the contents of a bitmap.  */
 
@@ -2099,7 +2112,6 @@ bitmap_print (FILE *file, const_bitmap h
     }
   fputs (suffix, file);
 }
-#ifdef GATHER_STATISTICS
 
 
 /* Used to accumulate statistics about bitmap sizes.  */
@@ -2135,14 +2147,16 @@ print_statistics (void **slot, void *b)
     }
   return 1;
 }
-#endif
+
 /* Output per-bitmap memory usage statistics.  */
 void
 dump_bitmap_statistics (void)
 {
-#ifdef GATHER_STATISTICS
   struct output_info info;
 
+  if (! GATHER_STATISTICS)
+    return;
+
   if (!bitmap_desc_hash)
     return;
 
@@ -2157,24 +2171,6 @@ dump_bitmap_statistics (void)
   fprintf (stderr, "%-40s %9d %15"HOST_WIDEST_INT_PRINT"d\n",
 	   "Total", info.count, info.size);
   fprintf (stderr, "---------------------------------------------------------------------------------\n");
-#endif
-}
-
-/* Compute hash of bitmap (for purposes of hashing).  */
-hashval_t
-bitmap_hash (const_bitmap head)
-{
-  const bitmap_element *ptr;
-  BITMAP_WORD hash = 0;
-  int ix;
-
-  for (ptr = head->first; ptr; ptr = ptr->next)
-    {
-      hash ^= ptr->indx;
-      for (ix = 0; ix != BITMAP_ELEMENT_WORDS; ix++)
-	hash ^= ptr->bits[ix];
-    }
-  return (hashval_t)hash;
 }
 
 #include "gt-bitmap.h"
Index: gimple.c
===================================================================
--- gimple.c	(revision 189784)
+++ gimple.c	(working copy)
@@ -79,7 +79,6 @@ EXPORTED_CONST enum gimple_statement_str
 };
 #undef DEFGSCODE
 
-#ifdef GATHER_STATISTICS
 /* Gimple stats.  */
 
 int gimple_alloc_counts[(int) gimple_alloc_kind_all];
@@ -93,8 +92,6 @@ static const char * const gimple_alloc_k
     "everything else"
 };
 
-#endif /* GATHER_STATISTICS */
-
 /* Private API manipulation functions shared only with some
    other files.  */
 extern void gimple_set_stored_syms (gimple, bitmap, bitmap_obstack *);
@@ -134,13 +131,12 @@ gimple_alloc_stat (enum gimple_code code
   if (num_ops > 0)
     size += sizeof (tree) * (num_ops - 1);
 
-#ifdef GATHER_STATISTICS
-  {
-    enum gimple_alloc_kind kind = gimple_alloc_kind (code);
-    gimple_alloc_counts[(int) kind]++;
-    gimple_alloc_sizes[(int) kind] += size;
-  }
-#endif
+  if (GATHER_STATISTICS)
+    {
+      enum gimple_alloc_kind kind = gimple_alloc_kind (code);
+      gimple_alloc_counts[(int) kind]++;
+      gimple_alloc_sizes[(int) kind] += size;
+    }
 
   stmt = ggc_alloc_cleared_gimple_statement_d_stat (size PASS_MEM_STAT);
   gimple_set_code (stmt, code);
@@ -645,9 +641,8 @@ gimple_build_asm_1 (const char *string, 
   p->gimple_asm.nl = nlabels;
   p->gimple_asm.string = ggc_alloc_string (string, size);
 
-#ifdef GATHER_STATISTICS
-  gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
-#endif
+  if (GATHER_STATISTICS)
+    gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
 
   return p;
 }
@@ -2503,9 +2498,14 @@ gimple_assign_rhs_could_trap_p (gimple s
 void
 dump_gimple_statistics (void)
 {
-#ifdef GATHER_STATISTICS
   int i, total_tuples = 0, total_bytes = 0;
 
+  if (! GATHER_STATISTICS)
+    {
+      fprintf (stderr, "No gimple statistics\n");
+      return;
+    }
+
   fprintf (stderr, "\nGIMPLE statements\n");
   fprintf (stderr, "Kind                   Stmts      Bytes\n");
   fprintf (stderr, "---------------------------------------\n");
@@ -2519,9 +2519,6 @@ dump_gimple_statistics (void)
   fprintf (stderr, "---------------------------------------\n");
   fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
   fprintf (stderr, "---------------------------------------\n");
-#else
-  fprintf (stderr, "No gimple statistics\n");
-#endif
 }
 
 
Index: rtl.c
===================================================================
--- rtl.c	(revision 189784)
+++ rtl.c	(working copy)
@@ -135,12 +135,10 @@ const char * const reg_note_name[REG_NOT
 #undef DEF_REG_NOTE
 };
 
-#ifdef GATHER_STATISTICS
 static int rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE];
 static int rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE];
 static int rtvec_alloc_counts;
 static int rtvec_alloc_sizes;
-#endif
 
 
 /* Allocate an rtx vector of N elements.
@@ -157,10 +155,11 @@ rtvec_alloc (int n)
 
   PUT_NUM_ELEM (rt, n);
 
-#ifdef GATHER_STATISTICS
-  rtvec_alloc_counts++;
-  rtvec_alloc_sizes += n * sizeof (rtx);
-#endif
+  if (GATHER_STATISTICS)
+    {
+      rtvec_alloc_counts++;
+      rtvec_alloc_sizes += n * sizeof (rtx);
+    }
 
   return rt;
 }
@@ -205,10 +204,11 @@ rtx_alloc_stat (RTX_CODE code MEM_STAT_D
   memset (rt, 0, RTX_HDR_SIZE);
   PUT_CODE (rt, code);
 
-#ifdef GATHER_STATISTICS
-  rtx_alloc_counts[code]++;
-  rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
-#endif
+  if (GATHER_STATISTICS)
+    {
+      rtx_alloc_counts[code]++;
+      rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
+    }
 
   return rt;
 }
@@ -706,10 +706,16 @@ iterative_hash_rtx (const_rtx x, hashval
 void
 dump_rtx_statistics (void)
 {
-#ifdef GATHER_STATISTICS
   int i;
   int total_counts = 0;
   int total_sizes = 0;
+
+  if (! GATHER_STATISTICS)
+    {
+      fprintf (stderr, "No RTX statistics\n");
+      return;
+    }
+
   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
   fprintf (stderr, "---------------------------------------\n");
   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
@@ -731,7 +737,6 @@ dump_rtx_statistics (void)
   fprintf (stderr, "%-20s %7d %10d\n",
            "Total", total_counts, total_sizes);
   fprintf (stderr, "---------------------------------------\n");
-#endif
 }
 
 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
Index: tree.c
===================================================================
--- tree.c	(revision 189784)
+++ tree.c	(working copy)
@@ -121,7 +121,6 @@ const char *const tree_code_class_string
 /* obstack.[ch] explicitly declined to prototype this.  */
 extern int _obstack_allocated_p (struct obstack *h, void *obj);
 
-#ifdef GATHER_STATISTICS
 /* Statistics-gathering stuff.  */
 
 static int tree_code_counts[MAX_TREE_CODES];
@@ -147,7 +146,6 @@ static const char * const tree_node_kind
   "lang_type kinds",
   "omp clauses",
 };
-#endif /* GATHER_STATISTICS */
 
 /* Unique id for next decl created.  */
 static GTY(()) int next_decl_uid;
@@ -751,10 +749,12 @@ static void
 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED,
 				   size_t length ATTRIBUTE_UNUSED)
 {
-#ifdef GATHER_STATISTICS
   enum tree_code_class type = TREE_CODE_CLASS (code);
   tree_node_kind kind;
 
+  if (!GATHER_STATISTICS)
+    return;
+
   switch (type)
     {
     case tcc_declaration:  /* A decl node */
@@ -832,7 +832,6 @@ record_node_allocation_statistics (enum 
   tree_code_counts[(int) code]++;
   tree_node_counts[(int) kind]++;
   tree_node_sizes[(int) kind] += length;
-#endif
 }
 
 /* Allocate and return a new UID from the DECL_UID namespace.  */
@@ -6337,11 +6336,12 @@ type_hash_canon (unsigned int hashcode, 
   t1 = type_hash_lookup (hashcode, type);
   if (t1 != 0)
     {
-#ifdef GATHER_STATISTICS
-      tree_code_counts[(int) TREE_CODE (type)]--;
-      tree_node_counts[(int) t_kind]--;
-      tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type_non_common);
-#endif
+      if (GATHER_STATISTICS)
+	{
+	  tree_code_counts[(int) TREE_CODE (type)]--;
+	  tree_node_counts[(int) t_kind]--;
+	  tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type_non_common);
+	}
       return t1;
     }
   else
@@ -8709,36 +8709,34 @@ get_callee_fndecl (const_tree call)
 void
 dump_tree_statistics (void)
 {
-#ifdef GATHER_STATISTICS
-  int i;
-  int total_nodes, total_bytes;
-#endif
+  if (GATHER_STATISTICS)
+    {
+      int i;
+      int total_nodes, total_bytes;
+      fprintf (stderr, "Kind                   Nodes      Bytes\n");
+      fprintf (stderr, "---------------------------------------\n");
+      total_nodes = total_bytes = 0;
+      for (i = 0; i < (int) all_kinds; i++)
+	{
+	  fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
+		   tree_node_counts[i], tree_node_sizes[i]);
+	  total_nodes += tree_node_counts[i];
+	  total_bytes += tree_node_sizes[i];
+	}
+      fprintf (stderr, "---------------------------------------\n");
+      fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
+      fprintf (stderr, "---------------------------------------\n");
+      fprintf (stderr, "Code                   Nodes\n");
+      fprintf (stderr, "----------------------------\n");
+      for (i = 0; i < (int) MAX_TREE_CODES; i++)
+	fprintf (stderr, "%-20s %7d\n", tree_code_name[i], tree_code_counts[i]);
+      fprintf (stderr, "----------------------------\n");
+      ssanames_print_statistics ();
+      phinodes_print_statistics ();
+    }
+  else
+    fprintf (stderr, "(No per-node statistics)\n");
 
-  fprintf (stderr, "\n??? tree nodes created\n\n");
-#ifdef GATHER_STATISTICS
-  fprintf (stderr, "Kind                   Nodes      Bytes\n");
-  fprintf (stderr, "---------------------------------------\n");
-  total_nodes = total_bytes = 0;
-  for (i = 0; i < (int) all_kinds; i++)
-    {
-      fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
-	       tree_node_counts[i], tree_node_sizes[i]);
-      total_nodes += tree_node_counts[i];
-      total_bytes += tree_node_sizes[i];
-    }
-  fprintf (stderr, "---------------------------------------\n");
-  fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
-  fprintf (stderr, "---------------------------------------\n");
-  fprintf (stderr, "Code                   Nodes\n");
-  fprintf (stderr, "----------------------------\n");
-  for (i = 0; i < (int) MAX_TREE_CODES; i++)
-    fprintf (stderr, "%-20s %7d\n", tree_code_name[i], tree_code_counts[i]);
-  fprintf (stderr, "----------------------------\n");
-  ssanames_print_statistics ();
-  phinodes_print_statistics ();
-#else
-  fprintf (stderr, "(No per-node statistics)\n");
-#endif
   print_type_hash_statistics ();
   print_debug_expr_statistics ();
   print_value_expr_statistics ();
Index: tree-ssanames.c
===================================================================
--- tree-ssanames.c	(revision 189784)
+++ tree-ssanames.c	(working copy)
@@ -61,10 +61,8 @@ along with GCC; see the file COPYING3.  
    numbers after the special ones.  */
 #define UNUSED_NAME_VERSION 0
 
-#ifdef GATHER_STATISTICS
 unsigned int ssa_name_nodes_reused;
 unsigned int ssa_name_nodes_created;
-#endif
 
 /* Initialize management of SSA_NAMEs to default SIZE.  If SIZE is
    zero use default.  */
@@ -101,14 +99,12 @@ fini_ssanames (void)
 
 /* Dump some simple statistics regarding the re-use of SSA_NAME nodes.  */
 
-#ifdef GATHER_STATISTICS
 void
 ssanames_print_statistics (void)
 {
   fprintf (stderr, "SSA_NAME nodes allocated: %u\n", ssa_name_nodes_created);
   fprintf (stderr, "SSA_NAME nodes reused: %u\n", ssa_name_nodes_reused);
 }
-#endif
 
 /* Return an SSA_NAME node for variable VAR defined in statement STMT
    in function FN.  STMT may be an empty statement for artificial
@@ -127,9 +123,8 @@ make_ssa_name_fn (struct function *fn, t
   if (!VEC_empty (tree, FREE_SSANAMES (fn)))
     {
       t = VEC_pop (tree, FREE_SSANAMES (fn));
-#ifdef GATHER_STATISTICS
-      ssa_name_nodes_reused++;
-#endif
+      if (GATHER_STATISTICS)
+	ssa_name_nodes_reused++;
 
       /* The node was cleared out when we put it on the free list, so
 	 there is no need to do so again here.  */
@@ -141,9 +136,8 @@ make_ssa_name_fn (struct function *fn, t
       t = make_node (SSA_NAME);
       SSA_NAME_VERSION (t) = VEC_length (tree, SSANAMES (fn));
       VEC_safe_push (tree, gc, SSANAMES (fn), t);
-#ifdef GATHER_STATISTICS
-      ssa_name_nodes_created++;
-#endif
+      if (GATHER_STATISTICS)
+	ssa_name_nodes_created++;
     }
 
   TREE_TYPE (t) = TREE_TYPE (var);
Index: tree-phinodes.c
===================================================================
--- tree-phinodes.c	(revision 189784)
+++ tree-phinodes.c	(working copy)
@@ -77,21 +77,17 @@ static unsigned long free_phinode_count;
 
 static int ideal_phi_node_len (int);
 
-#ifdef GATHER_STATISTICS
 unsigned int phi_nodes_reused;
 unsigned int phi_nodes_created;
-#endif
 
 /* Dump some simple statistics regarding the re-use of PHI nodes.  */
 
-#ifdef GATHER_STATISTICS
 void
 phinodes_print_statistics (void)
 {
   fprintf (stderr, "PHI nodes allocated: %u\n", phi_nodes_created);
   fprintf (stderr, "PHI nodes reused: %u\n", phi_nodes_reused);
 }
-#endif
 
 /* Allocate a PHI node with at least LEN arguments.  If the free list
    happens to contain a PHI node with LEN arguments or more, return
@@ -119,21 +115,19 @@ allocate_phi_node (size_t len)
       phi = VEC_pop (gimple, free_phinodes[bucket]);
       if (VEC_empty (gimple, free_phinodes[bucket]))
 	VEC_free (gimple, gc, free_phinodes[bucket]);
-#ifdef GATHER_STATISTICS
-      phi_nodes_reused++;
-#endif
+      if (GATHER_STATISTICS)
+	phi_nodes_reused++;
     }
   else
     {
       phi = ggc_alloc_gimple_statement_d (size);
-#ifdef GATHER_STATISTICS
-      phi_nodes_created++;
+      if (GATHER_STATISTICS)
 	{
 	  enum gimple_alloc_kind kind = gimple_alloc_kind (GIMPLE_PHI);
-          gimple_alloc_counts[(int) kind]++;
-          gimple_alloc_sizes[(int) kind] += size;
+	  phi_nodes_created++;
+	  gimple_alloc_counts[(int) kind]++;
+	  gimple_alloc_sizes[(int) kind] += size;
 	}
-#endif
     }
 
   return phi;
Index: vec.c
===================================================================
--- vec.c	(revision 189784)
+++ vec.c	(working copy)
@@ -34,8 +34,6 @@ along with GCC; see the file COPYING3.  
 #include "diagnostic-core.h"
 #include "hashtab.h"
 
-#ifdef GATHER_STATISTICS
-
 /* Store information about each particular vector.  */
 struct vec_descriptor
 {
@@ -158,10 +156,10 @@ free_overhead (struct vec_prefix *ptr)
 void
 vec_heap_free (void *ptr)
 {
-  free_overhead ((struct vec_prefix *)ptr);
+  if (GATHER_STATISTICS)
+    free_overhead ((struct vec_prefix *)ptr);
   free (ptr);
 }
-#endif
 
 /* Calculate the new ALLOC value, making sure that RESERVE slots are
    free.  If EXACT grow exactly, otherwise grow exponentially.  */
@@ -316,20 +314,16 @@ vec_heap_o_reserve_1 (void *vec, int res
       return NULL;
     }
 
-#ifdef GATHER_STATISTICS
-  if (vec)
+  if (GATHER_STATISTICS && vec)
     free_overhead (pfx);
-#endif
 
   vec = xrealloc (vec, vec_offset + alloc * elt_size);
   ((struct vec_prefix *)vec)->alloc = alloc;
   if (!pfx)
     ((struct vec_prefix *)vec)->num = 0;
-#ifdef GATHER_STATISTICS
-  if (vec)
+  if (GATHER_STATISTICS && vec)
     register_overhead ((struct vec_prefix *)vec,
-    		       vec_offset + alloc * elt_size PASS_MEM_STAT);
-#endif
+    		       vec_offset + alloc * elt_size FINAL_PASS_MEM_STAT);
 
   return vec;
 }
@@ -529,7 +523,6 @@ vec_assert_fail (const char *op, const c
 }
 #endif
 
-#ifdef GATHER_STATISTICS
 /* Helper for qsort; sort descriptors by amount of memory consumed.  */
 static int
 cmp_statistic (const void *loc1, const void *loc2)
@@ -558,17 +551,19 @@ add_statistics (void **slot, void *b)
 }
 
 /* Dump per-site memory statistics.  */
-#endif
+
 void
 dump_vec_loc_statistics (void)
 {
-#ifdef GATHER_STATISTICS
   int nentries = 0;
   char s[4096];
   size_t allocated = 0;
   size_t times = 0;
   int i;
 
+  if (! GATHER_STATISTICS)
+    return;
+
   loc_array = XCNEWVEC (struct vec_descriptor *, vec_desc_hash->n_elements);
   fprintf (stderr, "Heap vectors:\n");
   fprintf (stderr, "\n%-48s %10s       %10s       %10s\n",
@@ -603,5 +598,4 @@ dump_vec_loc_statistics (void)
   fprintf (stderr, "\n%-48s %10s       %10s       %10s\n",
 	   "source location", "Leak", "Peak", "Times");
   fprintf (stderr, "-------------------------------------------------------\n");
-#endif
 }
Index: cp/class.c
===================================================================
--- cp/class.c	(revision 189784)
+++ cp/class.c	(working copy)
@@ -212,7 +212,6 @@ static tree get_vcall_index (tree, tree)
 
 /* Variables shared between class.c and call.c.  */
 
-#ifdef GATHER_STATISTICS
 int n_vtables = 0;
 int n_vtable_entries = 0;
 int n_vtable_searches = 0;
@@ -220,7 +219,6 @@ int n_vtable_elems = 0;
 int n_convert_harshness = 0;
 int n_compute_conversion_costs = 0;
 int n_inner_fields_searched = 0;
-#endif
 
 /* Convert to or from a base subobject.  EXPR is an expression of type
    `A' or `A*', an expression of type `B' or `B*' is returned.  To
@@ -836,10 +834,11 @@ build_primary_vtable (tree binfo, tree t
       virtuals = NULL_TREE;
     }
 
-#ifdef GATHER_STATISTICS
-  n_vtables += 1;
-  n_vtable_elems += list_length (virtuals);
-#endif
+  if (GATHER_STATISTICS)
+    {
+      n_vtables += 1;
+      n_vtable_elems += list_length (virtuals);
+    }
 
   /* Initialize the association list for this type, based
      on our first approximation.  */
@@ -7332,7 +7331,9 @@ get_vfield_name (tree type)
 void
 print_class_statistics (void)
 {
-#ifdef GATHER_STATISTICS
+  if (! GATHER_STATISTICS)
+    return;
+
   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
   if (n_vtables)
@@ -7342,7 +7343,6 @@ print_class_statistics (void)
       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
 	       n_vtable_entries, n_vtable_elems);
     }
-#endif
 }
 
 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
Index: cp/tree.c
===================================================================
--- cp/tree.c	(revision 189784)
+++ cp/tree.c	(working copy)
@@ -2044,9 +2044,7 @@ no_linkage_check (tree t, bool relaxed_p
     }
 }
 
-#ifdef GATHER_STATISTICS
 extern int depth_reached;
-#endif
 
 void
 cxx_print_statistics (void)
@@ -2054,10 +2052,9 @@ cxx_print_statistics (void)
   print_search_statistics ();
   print_class_statistics ();
   print_template_statistics ();
-#ifdef GATHER_STATISTICS
-  fprintf (stderr, "maximum template instantiation depth reached: %d\n",
-	   depth_reached);
-#endif
+  if (GATHER_STATISTICS)
+    fprintf (stderr, "maximum template instantiation depth reached: %d\n",
+	     depth_reached);
 }
 
 /* Return, as an INTEGER_CST node, the number of elements for TYPE
Index: cp/pt.c
===================================================================
--- cp/pt.c	(revision 189784)
+++ cp/pt.c	(working copy)
@@ -7754,9 +7754,8 @@ limit_bad_template_recursion (tree decl)
 
 static int tinst_depth;
 extern int max_tinst_depth;
-#ifdef GATHER_STATISTICS
 int depth_reached;
-#endif
+
 static GTY(()) struct tinst_level *last_error_tinst_level;
 
 /* We're starting to instantiate D; record the template instantiation context
@@ -7799,10 +7798,8 @@ push_tinst_level (tree d)
   current_tinst_level = new_level;
 
   ++tinst_depth;
-#ifdef GATHER_STATISTICS
-  if (tinst_depth > depth_reached)
+  if (GATHER_STATISTICS && (tinst_depth > depth_reached))
     depth_reached = tinst_depth;
-#endif
 
   return 1;
 }
Index: cp/search.c
===================================================================
--- cp/search.c	(revision 189784)
+++ cp/search.c	(working copy)
@@ -66,14 +66,12 @@ static tree dfs_get_pure_virtuals (tree,
 
 
 /* Variables for gathering statistics.  */
-#ifdef GATHER_STATISTICS
 static int n_fields_searched;
 static int n_calls_lookup_field, n_calls_lookup_field_1;
 static int n_calls_lookup_fnfields, n_calls_lookup_fnfields_1;
 static int n_calls_get_base_type;
 static int n_outer_fields_searched;
 static int n_contexts_saved;
-#endif /* GATHER_STATISTICS */
 
 
 /* Data for lookup_base and its workers.  */
@@ -407,9 +405,8 @@ lookup_field_1 (tree type, tree name, bo
 	{
 	  i = (lo + hi) / 2;
 
-#ifdef GATHER_STATISTICS
-	  n_fields_searched++;
-#endif /* GATHER_STATISTICS */
+	  if (GATHER_STATISTICS)
+	    n_fields_searched++;
 
 	  if (DECL_NAME (fields[i]) > name)
 	    hi = i;
@@ -454,16 +451,16 @@ lookup_field_1 (tree type, tree name, bo
 
   field = TYPE_FIELDS (type);
 
-#ifdef GATHER_STATISTICS
-  n_calls_lookup_field_1++;
-#endif /* GATHER_STATISTICS */
+  if (GATHER_STATISTICS)
+    n_calls_lookup_field_1++;
+
   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
     {
       tree decl = field;
 
-#ifdef GATHER_STATISTICS
-      n_fields_searched++;
-#endif /* GATHER_STATISTICS */
+      if (GATHER_STATISTICS)
+	n_fields_searched++;
+
       gcc_assert (DECL_P (field));
       if (DECL_NAME (field) == NULL_TREE
 	  && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
@@ -1203,9 +1200,8 @@ lookup_member (tree xbasetype, tree name
   if (!basetype_path)
     return NULL_TREE;
 
-#ifdef GATHER_STATISTICS
-  n_calls_lookup_field++;
-#endif /* GATHER_STATISTICS */
+  if (GATHER_STATISTICS)
+    n_calls_lookup_field++;
 
   memset (&lfi, 0, sizeof (lfi));
   lfi.type = type;
@@ -1370,9 +1366,8 @@ lookup_fnfields_idx_nolazy (tree type, t
   if (!method_vec)
     return -1;
 
-#ifdef GATHER_STATISTICS
-  n_calls_lookup_fnfields_1++;
-#endif /* GATHER_STATISTICS */
+  if (GATHER_STATISTICS)
+    n_calls_lookup_fnfields_1++;
 
   /* Constructors are first...  */
   if (name == ctor_identifier)
@@ -1408,9 +1403,8 @@ lookup_fnfields_idx_nolazy (tree type, t
 	{
 	  i = (lo + hi) / 2;
 
-#ifdef GATHER_STATISTICS
-	  n_outer_fields_searched++;
-#endif /* GATHER_STATISTICS */
+	  if (GATHER_STATISTICS)
+	    n_outer_fields_searched++;
 
 	  tmp = VEC_index (tree, method_vec, i);
 	  tmp = DECL_NAME (OVL_CURRENT (tmp));
@@ -1425,9 +1419,8 @@ lookup_fnfields_idx_nolazy (tree type, t
   else
     for (; VEC_iterate (tree, method_vec, i, fn); ++i)
       {
-#ifdef GATHER_STATISTICS
-	n_outer_fields_searched++;
-#endif /* GATHER_STATISTICS */
+	if (GATHER_STATISTICS)
+	  n_outer_fields_searched++;
 	if (DECL_NAME (OVL_CURRENT (fn)) == name)
 	  return i;
       }
@@ -2207,28 +2200,28 @@ note_debug_info_needed (tree type)
 void
 print_search_statistics (void)
 {
-#ifdef GATHER_STATISTICS
+  if (! GATHER_STATISTICS)
+    {
+      fprintf (stderr, "no search statistics\n");
+      return;
+    }
+
   fprintf (stderr, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
 	   n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1);
   fprintf (stderr, "%d fnfields searched in %d calls to lookup_fnfields\n",
 	   n_outer_fields_searched, n_calls_lookup_fnfields);
   fprintf (stderr, "%d calls to get_base_type\n", n_calls_get_base_type);
-#else /* GATHER_STATISTICS */
-  fprintf (stderr, "no search statistics\n");
-#endif /* GATHER_STATISTICS */
 }
 
 void
 reinit_search_statistics (void)
 {
-#ifdef GATHER_STATISTICS
   n_fields_searched = 0;
   n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0;
   n_calls_lookup_fnfields = 0, n_calls_lookup_fnfields_1 = 0;
   n_calls_get_base_type = 0;
   n_outer_fields_searched = 0;
   n_contexts_saved = 0;
-#endif /* GATHER_STATISTICS */
 }
 
 /* Helper for lookup_conversions_r.  TO_TYPE is the type converted to
Index: cp/lex.c
===================================================================
--- cp/lex.c	(revision 189784)
+++ cp/lex.c	(working copy)
@@ -571,10 +571,11 @@ retrofit_lang_decl (tree t)
   else
     gcc_unreachable ();
 
-#ifdef GATHER_STATISTICS
-  tree_node_counts[(int)lang_decl] += 1;
-  tree_node_sizes[(int)lang_decl] += size;
-#endif
+  if (GATHER_STATISTICS)
+    {
+      tree_node_counts[(int)lang_decl] += 1;
+      tree_node_sizes[(int)lang_decl] += size;
+    }
 }
 
 void
@@ -601,10 +602,11 @@ cxx_dup_lang_specific_decl (tree node)
   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
   DECL_LANG_SPECIFIC (node) = ld;
 
-#ifdef GATHER_STATISTICS
-  tree_node_counts[(int)lang_decl] += 1;
-  tree_node_sizes[(int)lang_decl] += size;
-#endif
+  if (GATHER_STATISTICS)
+    {
+      tree_node_counts[(int)lang_decl] += 1;
+      tree_node_sizes[(int)lang_decl] += size;
+    }
 }
 
 /* Copy DECL, including any language-specific parts.  */
@@ -638,10 +640,11 @@ copy_lang_type (tree node)
   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
   TYPE_LANG_SPECIFIC (node) = lt;
 
-#ifdef GATHER_STATISTICS
-  tree_node_counts[(int)lang_type] += 1;
-  tree_node_sizes[(int)lang_type] += size;
-#endif
+  if (GATHER_STATISTICS)
+    {
+      tree_node_counts[(int)lang_type] += 1;
+      tree_node_sizes[(int)lang_type] += size;
+    }
 }
 
 /* Copy TYPE, including any language-specific parts.  */
@@ -671,10 +674,11 @@ cxx_make_type (enum tree_code code)
       TYPE_LANG_SPECIFIC (t) = pi;
       pi->u.c.h.is_lang_type_class = 1;
 
-#ifdef GATHER_STATISTICS
-      tree_node_counts[(int)lang_type] += 1;
-      tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
-#endif
+      if (GATHER_STATISTICS)
+	{
+	  tree_node_counts[(int)lang_type] += 1;
+	  tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
+	}
     }
 
   /* Set up some flags that give proper default behavior.  */