===================================================================
@@ -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. */
===================================================================
@@ -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"
===================================================================
@@ -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
===================================================================
@@ -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
===================================================================
@@ -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;
===================================================================
@@ -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 *);
===================================================================
@@ -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. */
===================================================================
@@ -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
}
===================================================================
@@ -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)
{
===================================================================
@@ -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
===================================================================
@@ -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)
===================================================================
@@ -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);
===================================================================
@@ -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);
===================================================================
@@ -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))))
===================================================================
@@ -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
}
===================================================================
@@ -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"
===================================================================
@@ -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
}
===================================================================
@@ -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)
===================================================================
@@ -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 ();
===================================================================
@@ -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);
===================================================================
@@ -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;
===================================================================
@@ -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
}
===================================================================
@@ -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,
===================================================================
@@ -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
===================================================================
@@ -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;
}
===================================================================
@@ -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
===================================================================
@@ -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. */