Mercurial > hg > CbC > CbC_gcc
diff gcc/ipa-reference.c @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Tue, 22 Mar 2011 17:18:12 +0900 |
parents | b7f97abdc517 |
children | 04ced10e8804 |
line wrap: on
line diff
--- a/gcc/ipa-reference.c Tue May 25 18:58:51 2010 +0900 +++ b/gcc/ipa-reference.c Tue Mar 22 17:18:12 2011 +0900 @@ -59,7 +59,6 @@ #include "diagnostic.h" #include "langhooks.h" #include "lto-streamer.h" -#include "toplev.h" static void remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED); @@ -74,14 +73,6 @@ { bitmap statics_read; bitmap statics_written; - - /* Set when this function calls another function external to the - compilation unit or if the function has a asm clobber of memory. - In general, such calls are modeled as reading and writing all - variables (both bits on) but sometime there are attributes on the - called function so we can do better. */ - bool calls_read_all; - bool calls_write_all; }; /* Statics that are read and written by some set of functions. The @@ -95,7 +86,7 @@ bitmap statics_written; }; -/* Information we save about every function after ipa-reference is completted. */ +/* Information we save about every function after ipa-reference is completed. */ struct ipa_reference_optimization_summary_d { @@ -160,7 +151,7 @@ { if (!ipa_reference_opt_sum_vector || (VEC_length (ipa_reference_optimization_summary_t, - ipa_reference_opt_sum_vector) + ipa_reference_opt_sum_vector) <= (unsigned int) node->uid)) return NULL; return VEC_index (ipa_reference_optimization_summary_t, ipa_reference_opt_sum_vector, @@ -208,6 +199,8 @@ info = get_reference_optimization_summary (fn); if (info) return info->statics_not_read; + else if (flags_from_decl_or_type (fn->decl) & ECF_LEAF) + return all_module_statics; else return NULL; } @@ -225,6 +218,8 @@ info = get_reference_optimization_summary (fn); if (info) return info->statics_not_written; + else if (flags_from_decl_or_type (fn->decl) & ECF_LEAF) + return all_module_statics; else return NULL; } @@ -239,13 +234,10 @@ { int uid = DECL_UID (var); gcc_assert (TREE_CODE (var) == VAR_DECL); - if (!bitmap_bit_p (all_module_statics, uid)) - { - if (dump_file) - splay_tree_insert (reference_vars_to_consider, - uid, (splay_tree_value)var); - bitmap_set_bit (all_module_statics, uid); - } + if (dump_file) + splay_tree_insert (reference_vars_to_consider, + uid, (splay_tree_value)var); + bitmap_set_bit (all_module_statics, uid); } /* Return true if the variable T is the right kind of static variable to @@ -257,6 +249,7 @@ /* We handle only variables whose address is never taken. */ if (TREE_ADDRESSABLE (t)) return false; + /* If the variable has the "used" attribute, treat it as if it had a been touched by the devil. */ if (DECL_PRESERVE_P (t)) @@ -267,6 +260,11 @@ if (TREE_THIS_VOLATILE (t)) return false; + /* We do not need to analyze readonly vars, we already know they do not + alias. */ + if (TREE_READONLY (t)) + return false; + /* We cannot touch decls where the type needs constructing. */ if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t))) return false; @@ -304,10 +302,15 @@ for (e = x->callees; e; e = e->next_callee) { struct cgraph_node *y = e->callee; + enum availability avail; + avail = cgraph_function_body_availability (e->callee); /* Only look into nodes we can propagate something. */ - if (cgraph_function_body_availability (e->callee) > AVAIL_OVERWRITABLE) + if (avail > AVAIL_OVERWRITABLE + || (avail == AVAIL_OVERWRITABLE + && (flags_from_decl_or_type (e->callee->decl) & ECF_LEAF))) { + int flags = flags_from_decl_or_type (e->callee->decl); if (get_reference_vars_info (y)) { ipa_reference_vars_info_t y_info @@ -318,6 +321,11 @@ if (!y_global->statics_read) continue; + /* If function is declared const, it reads no memory even if it + seems so to local analysis. */ + if (flags & ECF_CONST) + continue; + if (x_global->statics_read != all_module_statics) { @@ -336,6 +344,13 @@ y_global->statics_read); } + /* If function is declared pure, it has no stores even if it + seems so to local analysis; If we can not return from here, + we can safely ignore the call. */ + if ((flags & ECF_PURE) + || cgraph_edge_cannot_lead_to_return (e)) + continue; + if (x_global->statics_written != all_module_statics) { @@ -377,7 +392,7 @@ bitmap_obstack_initialize (&local_info_obstack); bitmap_obstack_initialize (&optimization_summary_obstack); - all_module_statics = BITMAP_ALLOC (&local_info_obstack); + all_module_statics = BITMAP_ALLOC (&optimization_summary_obstack); node_removal_hook_holder = cgraph_add_node_removal_hook (&remove_node_data, NULL); @@ -414,20 +429,8 @@ struct ipa_ref *ref; int i; tree var; - struct cgraph_edge *ie; local = init_function_info (fn); - /* Process indirect calls. All direct calles are handled at propagation - time. */ - for (ie = fn->indirect_calls; ie; ie = ie->next_callee) - if (!(ie->indirect_info->ecf_flags & ECF_CONST)) - { - local->calls_read_all = true; - if (!(ie->indirect_info->ecf_flags & ECF_PURE) - && ((ie->indirect_info->ecf_flags & (ECF_NOTHROW | ECF_NORETURN)) - != (ECF_NOTHROW | ECF_NORETURN))) - local->calls_write_all = true; - } for (i = 0; ipa_ref_list_reference_iterate (&fn->ref_list, i, ref); i++) { if (ref->refered_type != IPA_REF_VARPOOL) @@ -443,25 +446,18 @@ bitmap_set_bit (local->statics_read, DECL_UID (var)); break; case IPA_REF_STORE: + if (ipa_ref_cannot_lead_to_return (ref)) + break; bitmap_set_bit (local->statics_written, DECL_UID (var)); break; case IPA_REF_ADDR: + gcc_unreachable (); break; } } - if ((flags_from_decl_or_type (fn->decl) & (ECF_NOTHROW | ECF_NORETURN)) - == (ECF_NOTHROW | ECF_NORETURN)) - { - local->calls_write_all = false; - bitmap_clear (local->statics_written); - } - - /* Free bitmaps of direct references if we can not use them anyway. */ - if (local->calls_write_all) - BITMAP_FREE (local->statics_written); - if (local->calls_read_all) - BITMAP_FREE (local->statics_read); + if (cgraph_node_cannot_return (fn)) + bitmap_clear (local->statics_written); } static bitmap @@ -470,6 +466,8 @@ bitmap dst; if (!src) return NULL; + if (src == all_module_statics) + return all_module_statics; dst = BITMAP_ALLOC (&optimization_summary_obstack); bitmap_copy (dst, src); return dst; @@ -571,33 +569,39 @@ fprintf(dump_file, "%s ", get_static_name (index)); } - if (l->calls_read_all) - fprintf (dump_file, "\n calls read all: "); - if (l->calls_write_all) - fprintf (dump_file, "\n calls read all: "); } } -/* Set READ_ALL/WRITE_ALL based on DECL flags. */ +/* Set READ_ALL/WRITE_ALL based on decl flags of NODE. */ static void -read_write_all_from_decl (tree decl, bool * read_all, bool * write_all) +read_write_all_from_decl (struct cgraph_node *node, bool * read_all, + bool * write_all) { + tree decl = node->decl; int flags = flags_from_decl_or_type (decl); - if (flags & ECF_CONST) + if ((flags & ECF_LEAF) + && cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE) + ; + else if (flags & ECF_CONST) ; - else if (flags & ECF_PURE) - *read_all = true; + else if ((flags & ECF_PURE) + || cgraph_node_cannot_return (node)) + { + *read_all = true; + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, " %s/%i -> read all\n", + cgraph_node_name (node), node->uid); + } else { /* TODO: To be able to produce sane results, we should also handle common builtins, in particular throw. */ *read_all = true; - /* When function does not return, it is safe to ignore anythign it writes - to, because the effect will never happen. */ - if ((flags & (ECF_NOTHROW | ECF_NORETURN)) - != (ECF_NOTHROW | ECF_NORETURN)) - *write_all = true; + *write_all = true; + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, " %s/%i -> read all, write all\n", + cgraph_node_name (node), node->uid); } } @@ -633,7 +637,7 @@ ipa_reference_vars_info_t node_info; ipa_reference_global_vars_info_t node_g; ipa_reference_local_vars_info_t node_l; - struct cgraph_edge *e; + struct cgraph_edge *e, *ie; bool read_all; bool write_all; @@ -641,47 +645,74 @@ node = order[i]; node_info = get_reference_vars_info (node); - if (!node_info) - { - dump_cgraph_node (stderr, node); - dump_cgraph (stderr); - gcc_unreachable (); - } + gcc_assert (node_info); + + + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "Starting cycle with %s/%i\n", + cgraph_node_name (node), node->uid); node_l = &node_info->local; node_g = &node_info->global; - read_all = node_l->calls_read_all; - write_all = node_l->calls_write_all; + read_all = false; + write_all = false; - /* When function is overwrittable, we can not assume anything. */ + /* When function is overwritable, we can not assume anything. */ if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE) - read_write_all_from_decl (node->decl, &read_all, &write_all); + read_write_all_from_decl (node, &read_all, &write_all); for (e = node->callees; e; e = e->next_callee) if (cgraph_function_body_availability (e->callee) <= AVAIL_OVERWRITABLE) - read_write_all_from_decl (e->callee->decl, &read_all, &write_all); + read_write_all_from_decl (e->callee, &read_all, &write_all); + + for (ie = node->indirect_calls; ie; ie = ie->next_callee) + if (!(ie->indirect_info->ecf_flags & ECF_CONST)) + { + read_all = true; + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, " indirect call -> read all\n"); + if (!cgraph_edge_cannot_lead_to_return (ie) + && !(ie->indirect_info->ecf_flags & ECF_PURE)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, " indirect call -> write all\n"); + write_all = true; + } + } - /* If any node in a cycle is calls_read_all or calls_write_all + /* If any node in a cycle is read_all or write_all they all are. */ w_info = (struct ipa_dfs_info *) node->aux; w = w_info->next_cycle; - while (w) + while (w && (!read_all || !write_all)) { - ipa_reference_local_vars_info_t w_l = - &get_reference_vars_info (w)->local; - - /* When function is overwrittable, we can not assume anything. */ + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, " Visiting %s/%i\n", + cgraph_node_name (w), w->uid); + /* When function is overwritable, we can not assume anything. */ if (cgraph_function_body_availability (w) <= AVAIL_OVERWRITABLE) - read_write_all_from_decl (w->decl, &read_all, &write_all); + read_write_all_from_decl (w, &read_all, &write_all); for (e = w->callees; e; e = e->next_callee) if (cgraph_function_body_availability (e->callee) <= AVAIL_OVERWRITABLE) - read_write_all_from_decl (e->callee->decl, &read_all, &write_all); + read_write_all_from_decl (e->callee, &read_all, &write_all); - read_all |= w_l->calls_read_all; - write_all |= w_l->calls_write_all; + for (ie = w->indirect_calls; ie; ie = ie->next_callee) + if (!(ie->indirect_info->ecf_flags & ECF_CONST)) + { + read_all = true; + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, " indirect call -> read all\n"); + if (!cgraph_edge_cannot_lead_to_return (ie) + && !(ie->indirect_info->ecf_flags & ECF_PURE)) + { + write_all = true; + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, " indirect call -> write all\n"); + } + } w_info = (struct ipa_dfs_info *) w->aux; w = w_info->next_cycle; @@ -709,20 +740,23 @@ propagate_bits (node_g, node); w_info = (struct ipa_dfs_info *) node->aux; w = w_info->next_cycle; - while (w) + while (w && (!read_all || !write_all)) { ipa_reference_vars_info_t w_ri = get_reference_vars_info (w); ipa_reference_local_vars_info_t w_l = &w_ri->local; + int flags = flags_from_decl_or_type (w->decl); /* These global bitmaps are initialized from the local info of all of the nodes in the region. However there is no need to do any work if the bitmaps were set to all_module_statics. */ - if (!read_all) + if (!read_all && !(flags & ECF_CONST)) bitmap_ior_into (node_g->statics_read, w_l->statics_read); - if (!write_all) + if (!write_all + && !(flags & ECF_PURE) + && !cgraph_node_cannot_return (w)) bitmap_ior_into (node_g->statics_written, w_l->statics_written); propagate_bits (node_g, w); @@ -845,7 +879,8 @@ continue; node_info = get_reference_vars_info (node); - if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE) + if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE + || (flags_from_decl_or_type (node->decl) & ECF_LEAF)) { node_g = &node_info->global; @@ -853,19 +888,30 @@ set_reference_optimization_summary (node, opt); /* Create the complimentary sets. */ - opt->statics_not_read = BITMAP_ALLOC (&optimization_summary_obstack); - opt->statics_not_written = BITMAP_ALLOC (&optimization_summary_obstack); - if (node_g->statics_read != all_module_statics) - bitmap_and_compl (opt->statics_not_read, - all_module_statics, - node_g->statics_read); + if (bitmap_empty_p (node_g->statics_read)) + opt->statics_not_read = all_module_statics; + else + { + opt->statics_not_read + = BITMAP_ALLOC (&optimization_summary_obstack); + if (node_g->statics_read != all_module_statics) + bitmap_and_compl (opt->statics_not_read, + all_module_statics, + node_g->statics_read); + } - if (node_g->statics_written - != all_module_statics) - bitmap_and_compl (opt->statics_not_written, - all_module_statics, - node_g->statics_written); + if (bitmap_empty_p (node_g->statics_written)) + opt->statics_not_written = all_module_statics; + else + { + opt->statics_not_written + = BITMAP_ALLOC (&optimization_summary_obstack); + if (node_g->statics_written != all_module_statics) + bitmap_and_compl (opt->statics_not_written, + all_module_statics, + node_g->statics_written); + } } if (node_info) free (node_info); @@ -884,7 +930,6 @@ if (dump_file) splay_tree_delete (reference_vars_to_consider); reference_vars_to_consider = NULL; - all_module_statics = NULL; return 0; } @@ -923,18 +968,32 @@ return true; } -/* Stream out BITS<RANS_STATICS as list of decls to OB. */ +/* Stream out BITS<RANS_STATICS as list of decls to OB. + LTRANS_STATICS_BITCOUNT specify number of bits in LTRANS_STATICS + or -1. When it is positive, just output -1 when + BITS<RANS_STATICS == BITS<RANS_STATICS. */ static void stream_out_bitmap (struct lto_simple_output_block *ob, - bitmap bits, bitmap ltrans_statics) + bitmap bits, bitmap ltrans_statics, + int ltrans_statics_bitcount) { - unsigned int count = 0; + int count = 0; unsigned int index; bitmap_iterator bi; + if (bits == all_module_statics) + { + lto_output_sleb128_stream (ob->main_stream, -1); + return; + } EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi) count ++; - lto_output_uleb128_stream (ob->main_stream, count); + if (count == ltrans_statics_bitcount) + { + lto_output_sleb128_stream (ob->main_stream, -1); + return; + } + lto_output_sleb128_stream (ob->main_stream, count); if (!count) return; EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi) @@ -951,47 +1010,65 @@ varpool_node_set vset) { struct cgraph_node *node; - struct varpool_node *vnode; struct lto_simple_output_block *ob = lto_create_simple_output_block (LTO_section_ipa_reference); unsigned int count = 0; + int ltrans_statics_bitcount = 0; lto_cgraph_encoder_t encoder = ob->decl_state->cgraph_node_encoder; + lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder; bitmap ltrans_statics = BITMAP_ALLOC (NULL); + int i; reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0); /* See what variables we are interested in. */ - for (vnode = varpool_nodes; vnode; vnode = vnode->next) - if (referenced_from_this_partition_p (&vnode->ref_list, set, vset)) - { - tree decl = vnode->decl; - if (is_proper_for_analysis (decl)) - { - bitmap_set_bit (ltrans_statics, DECL_UID (decl)); - splay_tree_insert (reference_vars_to_consider, - DECL_UID (decl), (splay_tree_value)decl); - } - } + for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++) + { + struct varpool_node *vnode = lto_varpool_encoder_deref (varpool_encoder, i); + if (!vnode->externally_visible + && vnode->analyzed + && bitmap_bit_p (all_module_statics, DECL_UID (vnode->decl)) + && referenced_from_this_partition_p (&vnode->ref_list, set, vset)) + { + tree decl = vnode->decl; + bitmap_set_bit (ltrans_statics, DECL_UID (decl)); + splay_tree_insert (reference_vars_to_consider, + DECL_UID (decl), (splay_tree_value)decl); + ltrans_statics_bitcount ++; + } + } - for (node = cgraph_nodes; node; node = node->next) - if (write_node_summary_p (node, set, vset, ltrans_statics)) - count++; + + if (ltrans_statics_bitcount) + for (i = 0; i < lto_cgraph_encoder_size (encoder); i++) + if (write_node_summary_p (lto_cgraph_encoder_deref (encoder, i), + set, vset, ltrans_statics)) + count++; lto_output_uleb128_stream (ob->main_stream, count); + if (count) + stream_out_bitmap (ob, ltrans_statics, ltrans_statics, + -1); /* Process all of the functions. */ - for (node = cgraph_nodes; node; node = node->next) - if (write_node_summary_p (node, set, vset, ltrans_statics)) + if (ltrans_statics_bitcount) + for (i = 0; i < lto_cgraph_encoder_size (encoder); i++) { - ipa_reference_optimization_summary_t info; - int node_ref; + node = lto_cgraph_encoder_deref (encoder, i); + if (write_node_summary_p (node, set, vset, ltrans_statics)) + { + ipa_reference_optimization_summary_t info; + int node_ref; - info = get_reference_optimization_summary (node); - node_ref = lto_cgraph_encoder_encode (encoder, node); - lto_output_uleb128_stream (ob->main_stream, node_ref); + info = get_reference_optimization_summary (node); + node_ref = lto_cgraph_encoder_encode (encoder, node); + lto_output_uleb128_stream (ob->main_stream, node_ref); - stream_out_bitmap (ob, info->statics_not_read, ltrans_statics); - stream_out_bitmap (ob, info->statics_not_written, ltrans_statics); + stream_out_bitmap (ob, info->statics_not_read, ltrans_statics, + ltrans_statics_bitcount); + stream_out_bitmap (ob, info->statics_not_written, ltrans_statics, + ltrans_statics_bitcount); + } } BITMAP_FREE (ltrans_statics); lto_destroy_simple_output_block (ob); @@ -1013,6 +1090,7 @@ cgraph_add_node_removal_hook (&remove_node_data, NULL); node_duplication_hook_holder = cgraph_add_node_duplication_hook (&duplicate_node_data, NULL); + all_module_statics = BITMAP_ALLOC (&optimization_summary_obstack); while ((file_data = file_data_vec[j++])) { @@ -1026,6 +1104,22 @@ { unsigned int i; unsigned int f_count = lto_input_uleb128 (ib); + int b_count; + if (!f_count) + continue; + b_count = lto_input_sleb128 (ib); + if (dump_file) + fprintf (dump_file, "all module statics:"); + for (i = 0; i < (unsigned int)b_count; i++) + { + unsigned int var_index = lto_input_uleb128 (ib); + tree v_decl = lto_file_decl_data_get_var_decl (file_data, + var_index); + bitmap_set_bit (all_module_statics, DECL_UID (v_decl)); + if (dump_file) + fprintf (dump_file, " %s", + lang_hooks.decl_printable_name (v_decl, 2)); + } for (i = 0; i < f_count; i++) { @@ -1048,33 +1142,47 @@ cgraph_node_name (node), node->uid); /* Set the statics not read. */ - v_count = lto_input_uleb128 (ib); - for (j = 0; j < (unsigned int)v_count; j++) + v_count = lto_input_sleb128 (ib); + if (v_count == -1) { - unsigned int var_index = lto_input_uleb128 (ib); - tree v_decl = lto_file_decl_data_get_var_decl (file_data, - var_index); - bitmap_set_bit (info->statics_not_read, DECL_UID (v_decl)); + info->statics_not_read = all_module_statics; if (dump_file) - fprintf (dump_file, " %s", - lang_hooks.decl_printable_name (v_decl, 2)); + fprintf (dump_file, " all module statics"); } + else + for (j = 0; j < (unsigned int)v_count; j++) + { + unsigned int var_index = lto_input_uleb128 (ib); + tree v_decl = lto_file_decl_data_get_var_decl (file_data, + var_index); + bitmap_set_bit (info->statics_not_read, DECL_UID (v_decl)); + if (dump_file) + fprintf (dump_file, " %s", + lang_hooks.decl_printable_name (v_decl, 2)); + } if (dump_file) fprintf (dump_file, "\n static not written:"); /* Set the statics not written. */ - v_count = lto_input_uleb128 (ib); - for (j = 0; j < (unsigned int)v_count; j++) + v_count = lto_input_sleb128 (ib); + if (v_count == -1) { - unsigned int var_index = lto_input_uleb128 (ib); - tree v_decl = lto_file_decl_data_get_var_decl (file_data, - var_index); - bitmap_set_bit (info->statics_not_written, DECL_UID (v_decl)); + info->statics_not_written = all_module_statics; if (dump_file) - fprintf (dump_file, " %s", - lang_hooks.decl_printable_name (v_decl, 2)); + fprintf (dump_file, " all module statics"); } + else + for (j = 0; j < (unsigned int)v_count; j++) + { + unsigned int var_index = lto_input_uleb128 (ib); + tree v_decl = lto_file_decl_data_get_var_decl (file_data, + var_index); + bitmap_set_bit (info->statics_not_written, DECL_UID (v_decl)); + if (dump_file) + fprintf (dump_file, " %s", + lang_hooks.decl_printable_name (v_decl, 2)); + } if (dump_file) fprintf (dump_file, "\n"); } @@ -1096,7 +1204,7 @@ { return (flag_ipa_reference /* Don't bother doing anything if the program has errors. */ - && !(errorcount || sorrycount)); + && !seen_error ()); } struct ipa_opt_pass_d pass_ipa_reference =