From 10adac5108a971b2e4949508728251e587450595 Mon Sep 17 00:00:00 2001 From: Xinliang David Li Date: Fri, 29 Apr 2011 00:19:35 +0000 Subject: [PATCH] split checksum into cfg checksum and line checksum From-SVN: r173147 --- gcc/ChangeLog | 26 ++++ gcc/coverage.c | 128 ++++++++++++------ gcc/coverage.h | 12 +- gcc/gcov-dump.c | 3 +- gcc/gcov-io.h | 12 +- gcc/gcov.c | 22 ++- gcc/libgcov.c | 8 +- gcc/profile.c | 56 ++++---- gcc/testsuite/ChangeLog | 5 + gcc/testsuite/g++.dg/prof-robust-1.C | 24 ++++ .../gcc.dg/tree-prof/prof-robust-1.c | 25 ++++ gcc/tree.c | 24 +++- gcc/tree.h | 1 + 13 files changed, 264 insertions(+), 82 deletions(-) create mode 100644 gcc/testsuite/g++.dg/prof-robust-1.C create mode 100644 gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 794c496a796..fdbc4f1212e 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,29 @@ +2011-04-28 David Li + + * tree.c (crc32_string): Use crc32_byte. + (crc32_byte): New function. + * tree.h (crc32_byte): New function. + * gcov.c (read_graph_file): Handle new cfg_cksum. + (read_count_file): Ditto. + * profile.c (instrument_values): Ditto. + (get_exec_counts): Ditto. + (read_profile_edge_counts): Ditto. + (compute_branch_probabilities): Ditto. + (compute_value_histograms): Ditto. + (branch_prob): Ditto. + (end_branch_prob): Ditto. + * coverage.c (read_counts_file): Ditto. + (get_coverage_counts): Ditto. + (tree_coverage_counter_addr): Ditto. + (coverage_checksum_string): Ditto. + (coverage_begin_output): Ditto. + (coverage_end_function): Ditto. + (build_fn_info_type): Ditto. + (build_fn_info_value): Ditto. + * libgcov.c (gcov_exit): Ditto. + * gcov-dump.c (tag_function): Ditto. + (compute_checksum): Remove. + 2011-04-29 Alan Modra * config/rs6000/rs6000.c (rs6000_delegitimize_address): Handle diff --git a/gcc/coverage.c b/gcc/coverage.c index 58b7c69e893..1efd714c940 100644 --- a/gcc/coverage.c +++ b/gcc/coverage.c @@ -51,13 +51,15 @@ along with GCC; see the file COPYING3. If not see #include "intl.h" #include "filenames.h" +#include "gcov-io.h" #include "gcov-io.c" struct function_list { struct function_list *next; /* next function */ unsigned ident; /* function ident */ - unsigned checksum; /* function checksum */ + unsigned lineno_checksum; /* function lineno checksum */ + unsigned cfg_checksum; /* function cfg checksum */ unsigned n_ctrs[GCOV_COUNTERS];/* number of counters. */ }; @@ -69,7 +71,8 @@ typedef struct counts_entry unsigned ctr; /* Store */ - unsigned checksum; + unsigned lineno_checksum; + unsigned cfg_checksum; gcov_type *counts; struct gcov_ctr_summary summary; @@ -114,8 +117,6 @@ static hashval_t htab_counts_entry_hash (const void *); static int htab_counts_entry_eq (const void *, const void *); static void htab_counts_entry_del (void *); static void read_counts_file (void); -static unsigned compute_checksum (void); -static unsigned coverage_checksum_string (unsigned, const char *); static tree build_fn_info_type (unsigned); static tree build_fn_info_value (const struct function_list *, tree); static tree build_ctr_info_type (void); @@ -171,11 +172,12 @@ static void read_counts_file (void) { gcov_unsigned_t fn_ident = 0; - gcov_unsigned_t checksum = -1; counts_entry_t *summaried = NULL; unsigned seen_summary = 0; gcov_unsigned_t tag; int is_error = 0; + unsigned lineno_checksum = 0; + unsigned cfg_checksum = 0; if (!gcov_open (da_file_name, 1)) return; @@ -215,7 +217,8 @@ read_counts_file (void) if (tag == GCOV_TAG_FUNCTION) { fn_ident = gcov_read_unsigned (); - checksum = gcov_read_unsigned (); + lineno_checksum = gcov_read_unsigned (); + cfg_checksum = gcov_read_unsigned (); if (seen_summary) { /* We have already seen a summary, this means that this @@ -265,24 +268,26 @@ read_counts_file (void) if (!entry) { *slot = entry = XCNEW (counts_entry_t); - entry->ident = elt.ident; + entry->ident = fn_ident; entry->ctr = elt.ctr; - entry->checksum = checksum; + entry->lineno_checksum = lineno_checksum; + entry->cfg_checksum = cfg_checksum; entry->summary.num = n_counts; entry->counts = XCNEWVEC (gcov_type, n_counts); } - else if (entry->checksum != checksum) + else if (entry->lineno_checksum != lineno_checksum + || entry->cfg_checksum != cfg_checksum) { - error ("coverage mismatch for function %u while reading execution counters", - fn_ident); - error ("checksum is %x instead of %x", entry->checksum, checksum); + error ("Profile data for function %u is corrupted", fn_ident); + error ("checksum is (%x,%x) instead of (%x,%x)", + entry->lineno_checksum, entry->cfg_checksum, + lineno_checksum, cfg_checksum); htab_delete (counts_hash); break; } else if (entry->summary.num != n_counts) { - error ("coverage mismatch for function %u while reading execution counters", - fn_ident); + error ("Profile data for function %u is corrupted", fn_ident); error ("number of counters is %d instead of %d", entry->summary.num, n_counts); htab_delete (counts_hash); break; @@ -324,10 +329,10 @@ read_counts_file (void) gcov_type * get_coverage_counts (unsigned counter, unsigned expected, + unsigned cfg_checksum, unsigned lineno_checksum, const struct gcov_ctr_summary **summary) { counts_entry_t *entry, elt; - gcov_unsigned_t checksum = -1; /* No hash table, no counts. */ if (!counts_hash) @@ -352,26 +357,21 @@ get_coverage_counts (unsigned counter, unsigned expected, return NULL; } - checksum = compute_checksum (); - if (entry->checksum != checksum + if (entry->cfg_checksum != cfg_checksum || entry->summary.num != expected) { static int warned = 0; bool warning_printed = false; tree id = DECL_ASSEMBLER_NAME (current_function_decl); - warning_printed = - warning_at (input_location, OPT_Wcoverage_mismatch, - "coverage mismatch for function " - "%qE while reading counter %qs", id, ctr_names[counter]); + warning_printed = + warning_at (input_location, OPT_Wcoverage_mismatch, + "The control flow of function %qE does not match " + "its profile data (counter %qs)", id, ctr_names[counter]); if (warning_printed) { - if (entry->checksum != checksum) - inform (input_location, "checksum is %x instead of %x", - entry->checksum, checksum); - else - inform (input_location, "number of counters is %d instead of %d", - entry->summary.num, expected); + inform (input_location, "Use -Wno-error=coverage-mismatch to tolerate " + "the mismatch but performance may drop if the function is hot"); if (!seen_error () && !warned++) @@ -388,6 +388,12 @@ get_coverage_counts (unsigned counter, unsigned expected, return NULL; } + else if (entry->lineno_checksum != lineno_checksum) + { + warning (0, "Source location for function %qE have changed," + " the profile data may be out of date", + DECL_ASSEMBLER_NAME (current_function_decl)); + } if (summary) *summary = &entry->summary; @@ -467,6 +473,7 @@ tree_coverage_counter_addr (unsigned counter, unsigned no) NULL, NULL)); } + /* Generate a checksum for a string. CHKSUM is the current checksum. */ @@ -529,8 +536,8 @@ coverage_checksum_string (unsigned chksum, const char *string) /* Compute checksum for the current function. We generate a CRC32. */ -static unsigned -compute_checksum (void) +unsigned +coverage_compute_lineno_checksum (void) { expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (current_function_decl)); @@ -542,6 +549,36 @@ compute_checksum (void) return chksum; } + +/* Compute cfg checksum for the current function. + The checksum is calculated carefully so that + source code changes that doesn't affect the control flow graph + won't change the checksum. + This is to make the profile data useable across source code change. + The downside of this is that the compiler may use potentially + wrong profile data - that the source code change has non-trivial impact + on the validity of profile data (e.g. the reversed condition) + but the compiler won't detect the change and use the wrong profile data. */ + +unsigned +coverage_compute_cfg_checksum (void) +{ + basic_block bb; + unsigned chksum = n_basic_blocks; + + FOR_EACH_BB (bb) + { + edge e; + edge_iterator ei; + chksum = crc32_byte (chksum, bb->index); + FOR_EACH_EDGE (e, ei, bb->succs) + { + chksum = crc32_byte (chksum, e->dest->index); + } + } + + return chksum; +} /* Begin output to the graph file for the current function. Opens the output file, if not already done. Writes the @@ -549,7 +586,7 @@ compute_checksum (void) should be output. */ int -coverage_begin_output (void) +coverage_begin_output (unsigned lineno_checksum, unsigned cfg_checksum) { /* We don't need to output .gcno file unless we're under -ftest-coverage (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */ @@ -575,12 +612,14 @@ coverage_begin_output (void) bbg_file_opened = 1; } + /* Announce function */ offset = gcov_write_tag (GCOV_TAG_FUNCTION); gcov_write_unsigned (current_function_funcdef_no + 1); - gcov_write_unsigned (compute_checksum ()); + gcov_write_unsigned (lineno_checksum); + gcov_write_unsigned (cfg_checksum); gcov_write_string (IDENTIFIER_POINTER - (DECL_ASSEMBLER_NAME (current_function_decl))); + (DECL_ASSEMBLER_NAME (current_function_decl))); gcov_write_string (xloc.file); gcov_write_unsigned (xloc.line); gcov_write_length (offset); @@ -594,7 +633,7 @@ coverage_begin_output (void) error has occurred. Save function coverage counts. */ void -coverage_end_function (void) +coverage_end_function (unsigned lineno_checksum, unsigned cfg_checksum) { unsigned i; @@ -613,9 +652,11 @@ coverage_end_function (void) *functions_tail = item; functions_tail = &item->next; + item->next = 0; item->ident = current_function_funcdef_no + 1; - item->checksum = compute_checksum (); + item->lineno_checksum = lineno_checksum; + item->cfg_checksum = cfg_checksum; for (i = 0; i != GCOV_COUNTERS; i++) { item->n_ctrs[i] = fn_n_ctrs[i]; @@ -640,13 +681,18 @@ build_fn_info_type (unsigned int counters) /* ident */ fields = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ()); - - /* checksum */ + /* lineno_checksum */ field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ()); DECL_CHAIN (field) = fields; fields = field; + /* cfg checksum */ + field = build_decl (BUILTINS_LOCATION, + FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ()); + DECL_CHAIN (field) = fields; + fields = field; + array_type = build_int_cst (NULL_TREE, counters - 1); array_type = build_index_type (array_type); array_type = build_array_type (get_gcov_unsigned_t (), array_type); @@ -680,10 +726,16 @@ build_fn_info_value (const struct function_list *function, tree type) function->ident)); fields = DECL_CHAIN (fields); - /* checksum */ + /* lineno_checksum */ + CONSTRUCTOR_APPEND_ELT (v1, fields, + build_int_cstu (get_gcov_unsigned_t (), + function->lineno_checksum)); + fields = DECL_CHAIN (fields); + + /* cfg_checksum */ CONSTRUCTOR_APPEND_ELT (v1, fields, build_int_cstu (get_gcov_unsigned_t (), - function->checksum)); + function->cfg_checksum)); fields = DECL_CHAIN (fields); /* counters */ diff --git a/gcc/coverage.h b/gcc/coverage.h index cabf3c74841..6935c2d338b 100644 --- a/gcc/coverage.h +++ b/gcc/coverage.h @@ -28,11 +28,17 @@ extern void coverage_finish (void); /* Complete the coverage information for the current function. Once per function. */ -extern void coverage_end_function (void); +extern void coverage_end_function (unsigned, unsigned); /* Start outputting coverage information for the current function. Repeatable per function. */ -extern int coverage_begin_output (void); +extern int coverage_begin_output (unsigned, unsigned); + +/* Compute the control flow checksum for the current function. */ +extern unsigned coverage_compute_cfg_checksum (void); + +/* Compute the line number checksum for the current function. */ +extern unsigned coverage_compute_lineno_checksum (void); /* Allocate some counters. Repeatable per function. */ extern int coverage_counter_alloc (unsigned /*counter*/, unsigned/*num*/); @@ -44,6 +50,8 @@ extern tree tree_coverage_counter_addr (unsigned /*counter*/, unsigned/*num*/); /* Get all the counters for the current function. */ extern gcov_type *get_coverage_counts (unsigned /*counter*/, unsigned /*expected*/, + unsigned /*cfg_checksum*/, + unsigned /*lineno_checksum*/, const struct gcov_ctr_summary **); extern tree get_gcov_type (void); diff --git a/gcc/gcov-dump.c b/gcc/gcov-dump.c index 3706f9ecd4e..e9c384382d1 100644 --- a/gcc/gcov-dump.c +++ b/gcc/gcov-dump.c @@ -267,7 +267,8 @@ tag_function (const char *filename ATTRIBUTE_UNUSED, unsigned long pos = gcov_position (); printf (" ident=%u", gcov_read_unsigned ()); - printf (", checksum=0x%08x", gcov_read_unsigned ()); + printf (", lineno_checksum=0x%08x", gcov_read_unsigned ()); + printf (", cfg_checksum_checksum=0x%08x", gcov_read_unsigned ()); if (gcov_position () - pos < length) { diff --git a/gcc/gcov-io.h b/gcc/gcov-io.h index ffc62ca7f69..4f5013e1156 100644 --- a/gcc/gcov-io.h +++ b/gcc/gcov-io.h @@ -103,7 +103,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see note: unit function-graph* unit: header int32:checksum string:source function-graph: announce_function basic_blocks {arcs | lines}* - announce_function: header int32:ident int32:checksum + announce_function: header int32:ident + int32:lineno_checksum int32:cfg_checksum string:name string:source int32:lineno basic_block: header int32:flags* arcs: header int32:block_no arc* @@ -132,7 +133,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see data: {unit function-data* summary:object summary:program*}* unit: header int32:checksum function-data: announce_function arc_counts - announce_function: header int32:ident int32:checksum + announce_function: header int32:ident + int32:lineno_checksum int32:cfg_checksum arc_counts: header int64:count* summary: int32:checksum {count-summary}GCOV_COUNTERS count-summary: int32:num int32:runs int64:sum @@ -294,7 +296,7 @@ typedef HOST_WIDEST_INT gcov_type; file marker -- it is not required to be present. */ #define GCOV_TAG_FUNCTION ((gcov_unsigned_t)0x01000000) -#define GCOV_TAG_FUNCTION_LENGTH (2) +#define GCOV_TAG_FUNCTION_LENGTH (3) #define GCOV_TAG_BLOCKS ((gcov_unsigned_t)0x01410000) #define GCOV_TAG_BLOCKS_LENGTH(NUM) (NUM) #define GCOV_TAG_BLOCKS_NUM(LENGTH) (LENGTH) @@ -412,10 +414,12 @@ struct gcov_summary idiom. The number of counters is determined from the counter_mask in gcov_info. We hold an array of function info, so have to explicitly calculate the correct array stride. */ + struct gcov_fn_info { gcov_unsigned_t ident; /* unique ident of function */ - gcov_unsigned_t checksum; /* function checksum */ + gcov_unsigned_t lineno_checksum; /* function lineo_checksum */ + gcov_unsigned_t cfg_checksum; /* function cfg checksum */ unsigned n_ctrs[0]; /* instrumented counters */ }; diff --git a/gcc/gcov.c b/gcc/gcov.c index bb2791324a3..27ae036740a 100644 --- a/gcc/gcov.c +++ b/gcc/gcov.c @@ -54,6 +54,13 @@ along with Gcov; see the file COPYING3. If not see some places we make use of the knowledge of how profile.c works to select particular algorithms here. */ +/* The code validates that the profile information read in corresponds + to the code currently being compiled. Rather than checking for + identical files, the code below computes a checksum on the CFG + (based on the order of basic blocks and the arcs in the CFG). If + the CFG checksum in the gcda file match the CFG checksum for the + code currently being compiled, the profile data will be used. */ + /* This is the size of the buffer used to read in source file lines. */ #define STRING_SIZE 200 @@ -161,7 +168,8 @@ typedef struct function_info /* Name of function. */ char *name; unsigned ident; - unsigned checksum; + unsigned lineno_checksum; + unsigned cfg_checksum; /* Array of basic blocks. */ block_t *blocks; @@ -807,12 +815,14 @@ read_graph_file (void) if (tag == GCOV_TAG_FUNCTION) { char *function_name; - unsigned ident, checksum, lineno; + unsigned ident, lineno; + unsigned lineno_checksum, cfg_checksum; source_t *src; function_t *probe, *prev; ident = gcov_read_unsigned (); - checksum = gcov_read_unsigned (); + lineno_checksum = gcov_read_unsigned (); + cfg_checksum = gcov_read_unsigned (); function_name = xstrdup (gcov_read_string ()); src = find_source (gcov_read_string ()); lineno = gcov_read_unsigned (); @@ -820,7 +830,8 @@ read_graph_file (void) fn = XCNEW (function_t); fn->name = function_name; fn->ident = ident; - fn->checksum = checksum; + fn->lineno_checksum = lineno_checksum; + fn->cfg_checksum = cfg_checksum; fn->src = src; fn->line = lineno; @@ -1107,7 +1118,8 @@ read_count_file (void) if (!fn) ; - else if (gcov_read_unsigned () != fn->checksum) + else if (gcov_read_unsigned () != fn->lineno_checksum + || gcov_read_unsigned () != fn->cfg_checksum) { mismatch:; fnotice (stderr, "%s:profile mismatch for '%s'\n", diff --git a/gcc/libgcov.c b/gcc/libgcov.c index 6f32e85dc55..7d1f6d05290 100644 --- a/gcc/libgcov.c +++ b/gcc/libgcov.c @@ -372,9 +372,10 @@ gcov_exit (void) /* Check function. */ if (tag != GCOV_TAG_FUNCTION - || length != GCOV_TAG_FUNCTION_LENGTH + || length != GCOV_TAG_FUNCTION_LENGTH || gcov_read_unsigned () != fi_ptr->ident - || gcov_read_unsigned () != fi_ptr->checksum) + || gcov_read_unsigned () != fi_ptr->lineno_checksum + || gcov_read_unsigned () != fi_ptr->cfg_checksum) { read_mismatch:; fprintf (stderr, "profiling:%s:Merge mismatch for %s\n", @@ -517,7 +518,8 @@ gcov_exit (void) /* Announce function. */ gcov_write_tag_length (GCOV_TAG_FUNCTION, GCOV_TAG_FUNCTION_LENGTH); gcov_write_unsigned (fi_ptr->ident); - gcov_write_unsigned (fi_ptr->checksum); + gcov_write_unsigned (fi_ptr->lineno_checksum); + gcov_write_unsigned (fi_ptr->cfg_checksum); c_ix = 0; for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++) diff --git a/gcc/profile.c b/gcc/profile.c index e40bfecca90..e85702ed8dc 100644 --- a/gcc/profile.c +++ b/gcc/profile.c @@ -102,13 +102,6 @@ static int total_num_branches; /* Forward declarations. */ static void find_spanning_tree (struct edge_list *); -static unsigned instrument_edges (struct edge_list *); -static void instrument_values (histogram_values); -static void compute_branch_probabilities (void); -static void compute_value_histograms (histogram_values); -static gcov_type * get_exec_counts (void); -static basic_block find_group (basic_block); -static void union_groups (basic_block, basic_block); /* Add edge instrumentation code to the entire insn chain. @@ -233,10 +226,12 @@ instrument_values (histogram_values values) } -/* Computes hybrid profile for all matching entries in da_file. */ +/* Computes hybrid profile for all matching entries in da_file. + + CFG_CHECKSUM is the precomputed checksum for the CFG. */ static gcov_type * -get_exec_counts (void) +get_exec_counts (unsigned cfg_checksum, unsigned lineno_checksum) { unsigned num_edges = 0; basic_block bb; @@ -253,7 +248,8 @@ get_exec_counts (void) num_edges++; } - counts = get_coverage_counts (GCOV_COUNTER_ARCS, num_edges, &profile_info); + counts = get_coverage_counts (GCOV_COUNTER_ARCS, num_edges, cfg_checksum, + lineno_checksum, &profile_info); if (!counts) return NULL; @@ -442,10 +438,12 @@ read_profile_edge_counts (gcov_type *exec_counts) } /* Compute the branch probabilities for the various branches. - Annotate them accordingly. */ + Annotate them accordingly. + + CFG_CHECKSUM is the precomputed checksum for the CFG. */ static void -compute_branch_probabilities (void) +compute_branch_probabilities (unsigned cfg_checksum, unsigned lineno_checksum) { basic_block bb; int i; @@ -454,7 +452,7 @@ compute_branch_probabilities (void) int passes; int hist_br_prob[20]; int num_branches; - gcov_type *exec_counts = get_exec_counts (); + gcov_type *exec_counts = get_exec_counts (cfg_checksum, lineno_checksum); int inconsistent = 0; /* Very simple sanity checks so we catch bugs in our profiling code. */ @@ -772,10 +770,13 @@ compute_branch_probabilities (void) } /* Load value histograms values whose description is stored in VALUES array - from .gcda file. */ + from .gcda file. + + CFG_CHECKSUM is the precomputed checksum for the CFG. */ static void -compute_value_histograms (histogram_values values) +compute_value_histograms (histogram_values values, unsigned cfg_checksum, + unsigned lineno_checksum) { unsigned i, j, t, any; unsigned n_histogram_counters[GCOV_N_VALUE_COUNTERS]; @@ -803,7 +804,8 @@ compute_value_histograms (histogram_values values) histogram_counts[t] = get_coverage_counts (COUNTER_FOR_HIST_TYPE (t), - n_histogram_counters[t], NULL); + n_histogram_counters[t], cfg_checksum, + lineno_checksum, NULL); if (histogram_counts[t]) any = 1; act_count[t] = histogram_counts[t]; @@ -905,6 +907,7 @@ branch_prob (void) unsigned num_instrumented; struct edge_list *el; histogram_values values = NULL; + unsigned cfg_checksum, lineno_checksum; total_num_times_called++; @@ -1058,11 +1061,19 @@ branch_prob (void) if (dump_file) fprintf (dump_file, "%d ignored edges\n", ignored_edges); + + /* Compute two different checksums. Note that we want to compute + the checksum in only once place, since it depends on the shape + of the control flow which can change during + various transformations. */ + cfg_checksum = coverage_compute_cfg_checksum (); + lineno_checksum = coverage_compute_lineno_checksum (); + /* Write the data from which gcov can reconstruct the basic block graph. */ /* Basic block flags */ - if (coverage_begin_output ()) + if (coverage_begin_output (lineno_checksum, cfg_checksum)) { gcov_position_t offset; @@ -1079,7 +1090,7 @@ branch_prob (void) EXIT_BLOCK_PTR->index = last_basic_block; /* Arcs */ - if (coverage_begin_output ()) + if (coverage_begin_output (lineno_checksum, cfg_checksum)) { gcov_position_t offset; @@ -1120,7 +1131,7 @@ branch_prob (void) } /* Line numbers. */ - if (coverage_begin_output ()) + if (coverage_begin_output (lineno_checksum, cfg_checksum)) { /* Initialize the output. */ output_location (NULL, 0, NULL, NULL); @@ -1175,9 +1186,9 @@ branch_prob (void) if (flag_branch_probabilities) { - compute_branch_probabilities (); + compute_branch_probabilities (cfg_checksum, lineno_checksum); if (flag_profile_values) - compute_value_histograms (values); + compute_value_histograms (values, cfg_checksum, lineno_checksum); } remove_fake_edges (); @@ -1205,7 +1216,7 @@ branch_prob (void) VEC_free (histogram_value, heap, values); free_edge_list (el); - coverage_end_function (); + coverage_end_function (lineno_checksum, cfg_checksum); } /* Union find algorithm implementation for the basic blocks using @@ -1372,4 +1383,3 @@ end_branch_prob (void) } } } - diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index cc8797f88c2..16666cefd7c 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2011-04-28 Xinliang David Li + + * testsuite/gcc.dg/tree-prof/prof-robust-1.c: New test. + * testsuite/g++.dg/prof-robust-1.C: New test. + 2011-04-28 Ira Rosen PR tree-optimization/48765 diff --git a/gcc/testsuite/g++.dg/prof-robust-1.C b/gcc/testsuite/g++.dg/prof-robust-1.C new file mode 100644 index 00000000000..a5d8cb3c470 --- /dev/null +++ b/gcc/testsuite/g++.dg/prof-robust-1.C @@ -0,0 +1,24 @@ +/* { dg-options "-O2 -fno-weak" } */ + +#include + +namespace { + namespace { + + class MyClass { + public: + void foo() const; + ~MyClass() { foo(); } + }; + + void MyClass::foo() const { printf("Goodbye World\n"); } + + } + + static MyClass variable; + +} + +int main() { + return 0; +} diff --git a/gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c b/gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c new file mode 100644 index 00000000000..316cfc75734 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c @@ -0,0 +1,25 @@ +/* { dg-options "-O2 -w" } */ + +#include +#include + +#ifdef _PROFILE_USE +int foo(int x) { + return 3 * x; +} +#else +int foo(int x) { + return 3 * x; +} +#endif + +int x = 1000; + +int main(int argc, char *argv[]) { + int i; + int sum = 0; + for (i = 0; i < x; i++) + sum += i; + printf("%d\n", sum); + return 0; +} diff --git a/gcc/tree.c b/gcc/tree.c index b175221c779..ba90df8d318 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -8510,14 +8510,12 @@ dump_tree_statistics (void) #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s" -/* Generate a crc32 of a string. */ +/* Generate a crc32 of a byte. */ unsigned -crc32_string (unsigned chksum, const char *string) +crc32_byte (unsigned chksum, char byte) { - do - { - unsigned value = *string << 24; + unsigned value = (unsigned) byte << 24; unsigned ix; for (ix = 8; ix--; value <<= 1) @@ -8528,6 +8526,18 @@ crc32_string (unsigned chksum, const char *string) chksum <<= 1; chksum ^= feedback; } + return chksum; +} + + +/* Generate a crc32 of a string. */ + +unsigned +crc32_string (unsigned chksum, const char *string) +{ + do + { + chksum = crc32_byte (chksum, *string); } while (*string++); return chksum; @@ -8551,8 +8561,10 @@ clean_symbol_name (char *p) *p = '_'; } -/* Generate a name for a special-purpose function function. +/* Generate a name for a special-purpose function. The generated name may need to be unique across the whole link. + Changes to this function may also require corresponding changes to + xstrdup_mask_random. TYPE is some string to identify the purpose of this function to the linker or collect2; it must start with an uppercase letter, one of: diff --git a/gcc/tree.h b/gcc/tree.h index 8baaf7b7fd0..c20206fea8e 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -5001,6 +5001,7 @@ inlined_function_outer_scope_p (const_tree block) /* In tree.c */ extern unsigned crc32_string (unsigned, const char *); +extern unsigned crc32_byte (unsigned, char); extern void clean_symbol_name (char *); extern tree get_file_function_name (const char *); extern tree get_callee_fndecl (const_tree); -- 2.30.2