From: hubicka Date: Mon, 19 Apr 2010 23:33:21 +0000 (+0000) Subject: * opts.c (decode_options): Disable whpr incompatible passes. X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=commitdiff_plain;h=0fb8e24521299608aee02c7a8d328ac81bda1360 * opts.c (decode_options): Disable whpr incompatible passes. * lto/lto.c (lto_1_to_1_map): Skip clones. (read_cgraph_and_symbols): Do not mark everything as needed. (do_whole_program_analysis): Do map only after optimizing; set proper cgraph_state; use passmanager. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@158533 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 5fc2dfcca46..bf3c1b115d7 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,11 @@ +2010-04-19 Jan Hubicka + + * opts.c (decode_options): Disable whpr incompatible passes. + * lto/lto.c (lto_1_to_1_map): Skip clones. + (read_cgraph_and_symbols): Do not mark everything as needed. + (do_whole_program_analysis): Do map only after optimizing; + set proper cgraph_state; use passmanager. + 2010-04-19 DJ Delorie * cfgexpand.c (expand_debug_expr): Check for mismatched modes in diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c index d1ccc5a9adf..dc6ccb50af8 100644 --- a/gcc/lto/lto.c +++ b/gcc/lto/lto.c @@ -84,6 +84,7 @@ lto_materialize_function (struct cgraph_node *node) struct lto_file_decl_data *file_data; const char *data, *name; size_t len; + tree step; /* Ignore clone nodes. Read the body only from the original one. We may find clone nodes during LTRANS after WPA has made inlining @@ -102,33 +103,46 @@ lto_materialize_function (struct cgraph_node *node) name, &len); if (data) { + struct function *fn; + gcc_assert (!DECL_IS_BUILTIN (decl)); /* This function has a definition. */ TREE_STATIC (decl) = 1; gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL); + allocate_struct_function (decl, false); /* Load the function body only if not operating in WPA mode. In WPA mode, the body of the function is not needed. */ if (!flag_wpa) { - allocate_struct_function (decl, false); - announce_function (node->decl); lto_input_function_body (file_data, decl, data); lto_stats.num_function_bodies++; } + fn = DECL_STRUCT_FUNCTION (decl); lto_free_section_data (file_data, LTO_section_function_body, name, data, len); - if (!flag_wpa) - ggc_collect (); + + /* Look for initializers of constant variables and private + statics. */ + for (step = fn->local_decls; step; step = TREE_CHAIN (step)) + { + tree decl = TREE_VALUE (step); + if (TREE_CODE (decl) == VAR_DECL + && (TREE_STATIC (decl) && !DECL_EXTERNAL (decl)) + && flag_unit_at_a_time) + varpool_finalize_decl (decl); + } } else DECL_EXTERNAL (decl) = 1; /* Let the middle end know about the function. */ rest_of_decl_compilation (decl, 1, 0); + if (cgraph_node (decl)->needed) + cgraph_mark_reachable_node (cgraph_node (decl)); } @@ -156,7 +170,7 @@ lto_read_in_decl_state (struct data_in *data_in, const uint32_t *data, for (i = 0; i < LTO_N_DECL_STREAMS; i++) { uint32_t size = *data++; - tree *decls = GGC_NEWVEC (tree, size); + tree *decls = (tree *) xcalloc (size, sizeof (tree)); for (j = 0; j < size; j++) { @@ -221,7 +235,7 @@ lto_read_decls (struct lto_file_decl_data *decl_data, const void *data, /* Read in per-function decl states and enter them in hash table. */ decl_data->function_decl_states = - htab_create_ggc (37, lto_hash_in_decl_state, lto_eq_in_decl_state, NULL); + htab_create (37, lto_hash_in_decl_state, lto_eq_in_decl_state, free); for (i = 1; i < num_decl_states; i++) { @@ -362,9 +376,9 @@ lto_file_read (lto_file *file, FILE *resolution_file) resolutions = lto_resolution_read (resolution_file, file); - file_data = GGC_NEW (struct lto_file_decl_data); + file_data = XCNEW (struct lto_file_decl_data); file_data->file_name = file->filename; - file_data->section_hash_table = lto_obj_build_section_table (file); + file_data->section_hash_table = lto_elf_build_section_table (file); file_data->renaming_hash_table = lto_create_renaming_table (); data = lto_get_section_data (file_data, LTO_section_decls, NULL, &len); @@ -509,7 +523,6 @@ free_section_data (struct lto_file_decl_data *file_data ATTRIBUTE_UNUSED, /* Vector of all cgraph node sets. */ static GTY (()) VEC(cgraph_node_set, gc) *lto_cgraph_node_sets; -static GTY (()) VEC(varpool_node_set, gc) *lto_varpool_node_sets; /* Group cgrah nodes by input files. This is used mainly for testing @@ -519,33 +532,37 @@ static void lto_1_to_1_map (void) { struct cgraph_node *node; - struct varpool_node *vnode; struct lto_file_decl_data *file_data; struct pointer_map_t *pmap; - struct pointer_map_t *vpmap; cgraph_node_set set; - varpool_node_set vset; void **slot; timevar_push (TV_WHOPR_WPA); lto_cgraph_node_sets = VEC_alloc (cgraph_node_set, gc, 1); - lto_varpool_node_sets = VEC_alloc (varpool_node_set, gc, 1); + + /* If the cgraph is empty, create one cgraph node set so that there is still + an output file for any variables that need to be exported in a DSO. */ + if (!cgraph_nodes) + { + set = cgraph_node_set_new (); + VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set); + goto finish; + } pmap = pointer_map_create (); - vpmap = pointer_map_create (); for (node = cgraph_nodes; node; node = node->next) { - /* We will get proper partition based on function they are inlined to. */ - if (node->global.inlined_to) - continue; - /* Nodes without a body do not need partitioning. */ - if (!node->analyzed) + /* We will get proper partition based on function they are inlined to or + cloned from. */ + if (node->global.inlined_to || node->clone_of) continue; - + /* We only need to partition the nodes that we read from the + gimple bytecode files. */ file_data = node->local.lto_file_data; - gcc_assert (!node->same_body_alias && file_data); + if (file_data == NULL) + continue; slot = pointer_map_contains (pmap, file_data); if (slot) @@ -556,50 +573,14 @@ lto_1_to_1_map (void) slot = pointer_map_insert (pmap, file_data); *slot = set; VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set); - vset = varpool_node_set_new (); - slot = pointer_map_insert (vpmap, file_data); - *slot = vset; - VEC_safe_push (varpool_node_set, gc, lto_varpool_node_sets, vset); } cgraph_node_set_add (set, node); } - for (vnode = varpool_nodes; vnode; vnode = vnode->next) - { - if (vnode->alias || !vnode->needed) - continue; - slot = pointer_map_contains (vpmap, file_data); - if (slot) - vset = (varpool_node_set) *slot; - else - { - set = cgraph_node_set_new (); - slot = pointer_map_insert (pmap, file_data); - *slot = set; - VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set); - vset = varpool_node_set_new (); - slot = pointer_map_insert (vpmap, file_data); - *slot = vset; - VEC_safe_push (varpool_node_set, gc, lto_varpool_node_sets, vset); - } - - varpool_node_set_add (vset, vnode); - } - - /* If the cgraph is empty, create one cgraph node set so that there is still - an output file for any variables that need to be exported in a DSO. */ - if (!lto_cgraph_node_sets) - { - set = cgraph_node_set_new (); - VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set); - vset = varpool_node_set_new (); - VEC_safe_push (varpool_node_set, gc, lto_varpool_node_sets, vset); - } - pointer_map_destroy (pmap); - pointer_map_destroy (vpmap); +finish: timevar_pop (TV_WHOPR_WPA); lto_stats.num_cgraph_partitions += VEC_length (cgraph_node_set, @@ -612,19 +593,22 @@ lto_1_to_1_map (void) static void lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node, - bitmap original_decls) + bitmap original_decls, bitmap inlined_decls) { struct cgraph_node *callee; struct cgraph_edge *edge; cgraph_node_set_add (set, node); + if (!bitmap_bit_p (original_decls, DECL_UID (node->decl))) + bitmap_set_bit (inlined_decls, DECL_UID (node->decl)); + /* Check to see if NODE has any inlined callee. */ for (edge = node->callees; edge != NULL; edge = edge->next_callee) { callee = edge->callee; if (callee->global.inlined_to != NULL) - lto_add_inline_clones (set, callee, original_decls); + lto_add_inline_clones (set, callee, original_decls, inlined_decls); } } @@ -632,13 +616,14 @@ lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node, information in the callgraph. Returns a bitmap of decls that have been inlined into SET indexed by UID. */ -static void +static bitmap lto_add_all_inlinees (cgraph_node_set set) { cgraph_node_set_iterator csi; struct cgraph_node *node; bitmap original_nodes = lto_bitmap_alloc (); bitmap original_decls = lto_bitmap_alloc (); + bitmap inlined_decls = lto_bitmap_alloc (); bool changed; /* We are going to iterate SET while adding to it, mark all original @@ -678,53 +663,186 @@ lto_add_all_inlinees (cgraph_node_set set) } while (changed); - /* Transitively add to SET all the inline clones for every node that - has been inlined. */ - for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) - { - node = csi_node (csi); - if (bitmap_bit_p (original_nodes, node->uid)) - lto_add_inline_clones (set, node, original_decls); - } + /* Transitively add to SET all the inline clones for every node that + has been inlined. */ + for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) + { + node = csi_node (csi); + if (bitmap_bit_p (original_nodes, node->uid)) + lto_add_inline_clones (set, node, original_decls, inlined_decls); + } lto_bitmap_free (original_nodes); lto_bitmap_free (original_decls); + + return inlined_decls; } -/* Promote variable VNODE to be static. */ +/* Owing to inlining, we may need to promote a file-scope variable + to a global variable. Consider this case: + + a.c: + static int var; + + void + foo (void) + { + var++; + } + + b.c: -static bool -promote_var (struct varpool_node *vnode) + extern void foo (void); + + void + bar (void) + { + foo (); + } + + If WPA inlines FOO inside BAR, then the static variable VAR needs to + be promoted to global because BAR and VAR may be in different LTRANS + files. */ + +/* This struct keeps track of states used in globalization. */ + +typedef struct { - if (TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl)) - return false; - gcc_assert (flag_wpa); - TREE_PUBLIC (vnode->decl) = 1; - DECL_VISIBILITY (vnode->decl) = VISIBILITY_HIDDEN; - return true; -} + /* Current cgraph node set. */ + cgraph_node_set set; + + /* Function DECLs of cgraph nodes seen. */ + bitmap seen_node_decls; + + /* Use in walk_tree to avoid multiple visits of a node. */ + struct pointer_set_t *visited; + + /* static vars in this set. */ + bitmap static_vars_in_set; -/* Promote function NODE to be static. */ + /* static vars in all previous set. */ + bitmap all_static_vars; -static bool -promote_fn (struct cgraph_node *node) + /* all vars in all previous set. */ + bitmap all_vars; +} globalize_context_t; + +/* Callback for walk_tree. Examine the tree pointer to by TP and see if + if its a file-scope static variable of function that need to be turned + into a global. */ + +static tree +globalize_cross_file_statics (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, + void *data) { - gcc_assert (flag_wpa); - if (TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl)) - return false; - TREE_PUBLIC (node->decl) = 1; - DECL_VISIBILITY (node->decl) = VISIBILITY_HIDDEN; - if (node->same_body) + globalize_context_t *context = (globalize_context_t *) data; + tree t = *tp; + + if (t == NULL_TREE) + return NULL; + + /* The logic for globalization of VAR_DECLs and FUNCTION_DECLs are + different. For functions, we can simply look at the cgraph node sets + to tell if there are references to static functions outside the set. + The cgraph node sets do not keep track of vars, we need to traverse + the trees to determine what vars need to be globalized. */ + if (TREE_CODE (t) == VAR_DECL) + { + if (!TREE_PUBLIC (t)) + { + /* This file-scope static variable is reachable from more + that one set. Make it global but with hidden visibility + so that we do not export it in dynamic linking. */ + if (bitmap_bit_p (context->all_static_vars, DECL_UID (t))) + { + TREE_PUBLIC (t) = 1; + DECL_VISIBILITY (t) = VISIBILITY_HIDDEN; + } + bitmap_set_bit (context->static_vars_in_set, DECL_UID (t)); + } + bitmap_set_bit (context->all_vars, DECL_UID (t)); + walk_tree (&DECL_INITIAL (t), globalize_cross_file_statics, context, + context->visited); + } + else if (TREE_CODE (t) == FUNCTION_DECL && !TREE_PUBLIC (t)) { - struct cgraph_node *alias; - for (alias = node->same_body; - alias; alias = alias->next) + if (!cgraph_node_in_set_p (cgraph_node (t), context->set)) { - TREE_PUBLIC (alias->decl) = 1; - DECL_VISIBILITY (alias->decl) = VISIBILITY_HIDDEN; + /* This file-scope static function is reachable from a set + which does not contain the function DECL. Make it global + but with hidden visibility. */ + TREE_PUBLIC (t) = 1; + DECL_VISIBILITY (t) = VISIBILITY_HIDDEN; } } - return true; + + return NULL; +} + +/* Helper of lto_scan_statics_in_cgraph_node below. Scan TABLE for + static decls that may be used in more than one LTRANS file. + CONTEXT is a globalize_context_t for storing scanning states. */ + +static void +lto_scan_statics_in_ref_table (struct lto_tree_ref_table *table, + globalize_context_t *context) +{ + unsigned i; + + for (i = 0; i < table->size; i++) + walk_tree (&table->trees[i], globalize_cross_file_statics, context, + context->visited); +} + +/* Promote file-scope decl reachable from NODE if necessary to global. + CONTEXT is a globalize_context_t storing scanning states. */ + +static void +lto_scan_statics_in_cgraph_node (struct cgraph_node *node, + globalize_context_t *context) +{ + struct lto_in_decl_state *state; + + /* Do nothing if NODE has no function body. */ + if (!node->analyzed) + return; + + /* Return if the DECL of nodes has been visited before. */ + if (bitmap_bit_p (context->seen_node_decls, DECL_UID (node->decl))) + return; + + bitmap_set_bit (context->seen_node_decls, DECL_UID (node->decl)); + + state = lto_get_function_in_decl_state (node->local.lto_file_data, + node->decl); + gcc_assert (state); + + lto_scan_statics_in_ref_table (&state->streams[LTO_DECL_STREAM_VAR_DECL], + context); + lto_scan_statics_in_ref_table (&state->streams[LTO_DECL_STREAM_FN_DECL], + context); +} + +/* Scan all global variables that we have not yet seen so far. CONTEXT + is a globalize_context_t storing scanning states. */ + +static void +lto_scan_statics_in_remaining_global_vars (globalize_context_t *context) +{ + tree var, var_context; + struct varpool_node *vnode; + + FOR_EACH_STATIC_VARIABLE (vnode) + { + var = vnode->decl; + var_context = DECL_CONTEXT (var); + if (TREE_STATIC (var) + && TREE_PUBLIC (var) + && (!var_context || TREE_CODE (var_context) != FUNCTION_DECL) + && !bitmap_bit_p (context->all_vars, DECL_UID (var))) + walk_tree (&var, globalize_cross_file_statics, context, + context->visited); + } } /* Find out all static decls that need to be promoted to global because @@ -734,111 +852,39 @@ promote_fn (struct cgraph_node *node) static void lto_promote_cross_file_statics (void) { - struct varpool_node *vnode; unsigned i, n_sets; cgraph_node_set set; - varpool_node_set vset; cgraph_node_set_iterator csi; - varpool_node_set_iterator vsi; - VEC(varpool_node_ptr, heap) *promoted_initializers = NULL; - struct pointer_set_t *inserted = pointer_set_create (); + globalize_context_t context; - gcc_assert (flag_wpa); + memset (&context, 0, sizeof (context)); + context.all_vars = lto_bitmap_alloc (); + context.all_static_vars = lto_bitmap_alloc (); n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets); for (i = 0; i < n_sets; i++) { set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i); - vset = VEC_index (varpool_node_set, lto_varpool_node_sets, i); + context.set = set; + context.visited = pointer_set_create (); + context.static_vars_in_set = lto_bitmap_alloc (); + context.seen_node_decls = lto_bitmap_alloc (); - /* If node has either address taken (and we have no clue from where) - or it is called from other partition, it needs to be globalized. */ for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) - { - struct cgraph_node *node = csi_node (csi); - if (node->local.externally_visible) - continue; - if (node->global.inlined_to) - continue; - if (!DECL_EXTERNAL (node->decl) - && (referenced_from_other_partition_p (&node->ref_list, set, vset) - || reachable_from_other_partition_p (node, set))) - promote_fn (node); - } - for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi)) - { - vnode = vsi_node (vsi); - /* Constant pool references use internal labels and thus can not - be made global. It is sensible to keep those ltrans local to - allow better optimization. */ - if (!DECL_IN_CONSTANT_POOL (vnode->decl) - && !vnode->externally_visible && vnode->analyzed - && referenced_from_other_partition_p (&vnode->ref_list, - set, vset)) - promote_var (vnode); - } + lto_scan_statics_in_cgraph_node (csi_node (csi), &context); - /* We export initializers of read-only var into each partition - referencing it. Folding might take declarations from the - initializers and use it; so everything referenced from the - initializers needs can be accessed from this partition after - folding. - - This means that we need to promote all variables and functions - referenced from all initializers from readonly vars referenced - from this partition that are not in this partition. - This needs to be done recursively. */ - for (vnode = varpool_nodes; vnode; vnode = vnode->next) - if ((TREE_READONLY (vnode->decl) || DECL_IN_CONSTANT_POOL (vnode->decl)) - && DECL_INITIAL (vnode->decl) - && !varpool_node_in_set_p (vnode, vset) - && referenced_from_this_partition_p (&vnode->ref_list, set, vset) - && !pointer_set_insert (inserted, vnode)) - VEC_safe_push (varpool_node_ptr, heap, promoted_initializers, vnode); - while (!VEC_empty (varpool_node_ptr, promoted_initializers)) - { - int i; - struct ipa_ref *ref; + if (i == n_sets - 1) + lto_scan_statics_in_remaining_global_vars (&context); - vnode = VEC_pop (varpool_node_ptr, promoted_initializers); - for (i = 0; ipa_ref_list_reference_iterate (&vnode->ref_list, i, ref); i++) - { - if (ref->refered_type == IPA_REF_CGRAPH) - { - struct cgraph_node *n = ipa_ref_node (ref); - gcc_assert (!n->global.inlined_to); - if (!n->local.externally_visible - && !cgraph_node_in_set_p (n, set)) - promote_fn (n); - } - else - { - struct varpool_node *v = ipa_ref_varpool_node (ref); - if (varpool_node_in_set_p (v, vset)) - continue; - /* Constant pool references use internal labels and thus can not - be made global. It is sensible to keep those ltrans local to - allow better optimization. */ - if (DECL_IN_CONSTANT_POOL (v->decl)) - { - if (!pointer_set_insert (inserted, vnode)) - VEC_safe_push (varpool_node_ptr, heap, - promoted_initializers, v); - } - else if (!DECL_IN_CONSTANT_POOL (v->decl) - && !v->externally_visible && v->analyzed) - { - if (promote_var (v) - && DECL_INITIAL (v->decl) && TREE_READONLY (v->decl) - && !pointer_set_insert (inserted, vnode)) - VEC_safe_push (varpool_node_ptr, heap, - promoted_initializers, v); - } - } - } - } + bitmap_ior_into (context.all_static_vars, context.static_vars_in_set); + + pointer_set_destroy (context.visited); + lto_bitmap_free (context.static_vars_in_set); + lto_bitmap_free (context.seen_node_decls); } - pointer_set_destroy (inserted); + + lto_bitmap_free (context.all_vars); + lto_bitmap_free (context.all_static_vars); } @@ -882,50 +928,57 @@ get_filename_for_set (cgraph_node_set set) char *fname = NULL; static const size_t max_fname_len = 100; - /* Create a new temporary file to store SET. To facilitate - debugging, use file names from SET as part of the new - temporary file name. */ - cgraph_node_set_iterator si; - struct pointer_set_t *pset = pointer_set_create (); - for (si = csi_start (set); !csi_end_p (si); csi_next (&si)) + if (cgraph_node_set_needs_ltrans_p (set)) { - struct cgraph_node *n = csi_node (si); - const char *node_fname; - char *f; + /* Create a new temporary file to store SET. To facilitate + debugging, use file names from SET as part of the new + temporary file name. */ + cgraph_node_set_iterator si; + struct pointer_set_t *pset = pointer_set_create (); + for (si = csi_start (set); !csi_end_p (si); csi_next (&si)) + { + struct cgraph_node *n = csi_node (si); + const char *node_fname; + char *f; - /* Don't use the same file name more than once. */ - if (pointer_set_insert (pset, n->local.lto_file_data)) - continue; + /* Don't use the same file name more than once. */ + if (pointer_set_insert (pset, n->local.lto_file_data)) + continue; - /* The first file name found in SET determines the output - directory. For the remaining files, we use their - base names. */ - node_fname = n->local.lto_file_data->file_name; - if (fname == NULL) - { - fname = strip_extension (node_fname); - continue; - } + /* The first file name found in SET determines the output + directory. For the remaining files, we use their + base names. */ + node_fname = n->local.lto_file_data->file_name; + if (fname == NULL) + { + fname = strip_extension (node_fname); + continue; + } - f = strip_extension (lbasename (node_fname)); + f = strip_extension (lbasename (node_fname)); - /* If the new name causes an excessively long file name, - make the last component "___" to indicate overflow. */ - if (strlen (fname) + strlen (f) > max_fname_len - 3) - { - fname = reconcat (fname, fname, "___", NULL); - break; - } - else - { - fname = reconcat (fname, fname, "_", f, NULL); - free (f); + /* If the new name causes an excessively long file name, + make the last component "___" to indicate overflow. */ + if (strlen (fname) + strlen (f) > max_fname_len - 3) + { + fname = reconcat (fname, fname, "___", NULL); + break; + } + else + { + fname = reconcat (fname, fname, "_", f, NULL); + free (f); + } } - } - pointer_set_destroy (pset); + pointer_set_destroy (pset); - if (!fname) + /* Add the extension .wpa.o to indicate that this file has been + produced by WPA. */ + fname = reconcat (fname, fname, ".wpa.o", NULL); + gcc_assert (fname); + } + else { /* Since SET does not need to be processed by LTRANS, use the original file name and mark it with a '*' prefix so that @@ -934,13 +987,6 @@ get_filename_for_set (cgraph_node_set set) struct cgraph_node *first = csi_node (si); fname = prefix_name_with_star (first->local.lto_file_data->file_name); } - else - { - /* Add the extension .wpa.o to indicate that this file has been - produced by WPA. */ - fname = reconcat (fname, fname, ".wpa.o", NULL); - gcc_assert (fname); - } return fname; } @@ -958,7 +1004,8 @@ lto_wpa_write_files (void) unsigned i, n_sets, last_out_file_ix, num_out_files; lto_file *file; cgraph_node_set set; - varpool_node_set vset; + bitmap decls; + VEC(bitmap,heap) *inlined_decls = NULL; timevar_push (TV_WHOPR_WPA); @@ -968,7 +1015,8 @@ lto_wpa_write_files (void) compiled by LTRANS. */ for (i = 0; VEC_iterate (cgraph_node_set, lto_cgraph_node_sets, i, set); i++) { - lto_add_all_inlinees (set); + decls = lto_add_all_inlinees (set); + VEC_safe_push (bitmap, heap, inlined_decls, decls); lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr, set->nodes); } @@ -994,26 +1042,27 @@ lto_wpa_write_files (void) char *temp_filename; set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i); - vset = VEC_index (varpool_node_set, lto_varpool_node_sets, i); temp_filename = get_filename_for_set (set); output_files[i] = temp_filename; - if (cgraph_node_set_nonempty_p (set) || varpool_node_set_nonempty_p (vset)) + if (cgraph_node_set_needs_ltrans_p (set)) { /* Write all the nodes in SET to TEMP_FILENAME. */ - file = lto_obj_file_open (temp_filename, true); + file = lto_elf_file_open (temp_filename, true); if (!file) - fatal_error ("lto_obj_file_open() failed"); - - if (!quiet_flag) - fprintf (stderr, " %s", temp_filename); + fatal_error ("lto_elf_file_open() failed"); lto_set_current_out_file (file); + lto_new_extern_inline_states (); + + decls = VEC_index (bitmap, inlined_decls, i); + lto_force_functions_extern_inline (decls); - ipa_write_optimization_summaries (set, vset); + ipa_write_summaries_of_cgraph_node_set (set); + lto_delete_extern_inline_states (); lto_set_current_out_file (NULL); - lto_obj_file_close (file); + lto_elf_file_close (file); } } @@ -1023,44 +1072,196 @@ lto_wpa_write_files (void) output_files[last_out_file_ix] = NULL; + for (i = 0; VEC_iterate (bitmap, inlined_decls, i, decls); i++) + lto_bitmap_free (decls); + VEC_free (bitmap, heap, inlined_decls); + timevar_pop (TV_WHOPR_WPA_IO); return output_files; } +/* Template of LTRANS dumpbase suffix. */ +#define DUMPBASE_SUFFIX ".ltrans18446744073709551615" + /* Perform local transformations (LTRANS) on the files in the NULL-terminated FILES array. These should have been written previously by lto_wpa_write_files (). Transformations are performed via executing COLLECT_GCC for reach file. */ static void -lto_write_ltrans_list (char *const *files) +lto_execute_ltrans (char *const *files) { + struct pex_obj *pex; + const char *collect_gcc_options, *collect_gcc; + struct obstack env_obstack; + const char **argv; + const char **argv_ptr; + const char *errmsg; + size_t i, j; + int err; + int status; FILE *ltrans_output_list_stream = NULL; - unsigned i; + bool seen_dumpbase = false; + char *dumpbase_suffix = NULL; + + timevar_push (TV_WHOPR_WPA_LTRANS_EXEC); + + /* Get the driver and options. */ + collect_gcc = getenv ("COLLECT_GCC"); + if (!collect_gcc) + fatal_error ("environment variable COLLECT_GCC must be set"); + + /* Set the CFLAGS environment variable. */ + collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS"); + if (!collect_gcc_options) + fatal_error ("environment variable COLLECT_GCC_OPTIONS must be set"); + + /* Count arguments. */ + i = 0; + for (j = 0; collect_gcc_options[j] != '\0'; ++j) + if (collect_gcc_options[j] == '\'') + ++i; + + if (i % 2 != 0) + fatal_error ("malformed COLLECT_GCC_OPTIONS"); + + /* Initalize the arguments for the LTRANS driver. */ + argv = XNEWVEC (const char *, 8 + i / 2); + argv_ptr = argv; + *argv_ptr++ = collect_gcc; + *argv_ptr++ = "-xlto"; + for (j = 0; collect_gcc_options[j] != '\0'; ++j) + if (collect_gcc_options[j] == '\'') + { + char *option; + + ++j; + i = j; + while (collect_gcc_options[j] != '\'') + ++j; + obstack_init (&env_obstack); + obstack_grow (&env_obstack, &collect_gcc_options[i], j - i); + if (seen_dumpbase) + obstack_grow (&env_obstack, DUMPBASE_SUFFIX, + sizeof (DUMPBASE_SUFFIX)); + else + obstack_1grow (&env_obstack, 0); + option = XOBFINISH (&env_obstack, char *); + if (seen_dumpbase) + { + dumpbase_suffix = option + 7 + j - i; + seen_dumpbase = false; + } + + /* LTRANS does not need -fwpa nor -fltrans-*. */ + if (strncmp (option, "-fwpa", 5) != 0 + && strncmp (option, "-fltrans-", 9) != 0) + { + if (strncmp (option, "-dumpbase", 9) == 0) + seen_dumpbase = true; + *argv_ptr++ = option; + } + } + *argv_ptr++ = "-fltrans"; /* Open the LTRANS output list. */ - if (!ltrans_output_list) - error ("no LTRANS output filename provided"); - - ltrans_output_list_stream = fopen (ltrans_output_list, "w"); - if (ltrans_output_list_stream == NULL) - error ("opening LTRANS output list %s: %m", ltrans_output_list); + if (ltrans_output_list) + { + ltrans_output_list_stream = fopen (ltrans_output_list, "w"); + if (ltrans_output_list_stream == NULL) + error ("opening LTRANS output list %s: %m", ltrans_output_list); + } for (i = 0; files[i]; ++i) { size_t len; - len = strlen (files[i]); - if (fwrite (files[i], 1, len, ltrans_output_list_stream) < len - || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1) - error ("writing to LTRANS output list %s: %m", - ltrans_output_list); + /* If the file is prefixed with a '*', it means that we do not + need to re-compile it with LTRANS because it has not been + modified by WPA. Skip it from the command line to + lto_execute_ltrans, but add it to ltrans_output_list_stream + so it is linked after we are done. */ + if (files[i][0] == '*') + { + size_t len = strlen (files[i]) - 1; + if (ltrans_output_list_stream) + if (fwrite (&files[i][1], 1, len, ltrans_output_list_stream) < len + || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1) + error ("writing to LTRANS output list %s: %m", + ltrans_output_list); + } + else + { + char *output_name; + + /* Otherwise, add FILES[I] to lto_execute_ltrans command line + and add the resulting file to LTRANS output list. */ + + /* Replace the .o suffix with a .ltrans.o suffix and write + the resulting name to the LTRANS output list. */ + obstack_init (&env_obstack); + obstack_grow (&env_obstack, files[i], strlen (files[i]) - 2); + obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o")); + output_name = XOBFINISH (&env_obstack, char *); + if (ltrans_output_list_stream) + { + len = strlen (output_name); + + if (fwrite (output_name, 1, len, ltrans_output_list_stream) < len + || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1) + error ("writing to LTRANS output list %s: %m", + ltrans_output_list); + } + + argv_ptr[0] = "-o"; + argv_ptr[1] = output_name; + argv_ptr[2] = files[i]; + argv_ptr[3] = NULL; + + /* Append a sequence number to -dumpbase for LTRANS. */ + if (dumpbase_suffix) + snprintf (dumpbase_suffix, sizeof (DUMPBASE_SUFFIX) - 7, + "%lu", (unsigned long) i); + + /* Execute the driver. */ + pex = pex_init (0, "lto1", NULL); + if (pex == NULL) + fatal_error ("pex_init failed: %s", xstrerror (errno)); + + errmsg = pex_run (pex, PEX_LAST | PEX_SEARCH, argv[0], + CONST_CAST (char **, argv), NULL, NULL, &err); + if (errmsg) + fatal_error ("%s: %s", errmsg, xstrerror (err)); + + if (!pex_get_status (pex, 1, &status)) + fatal_error ("can't get program status: %s", xstrerror (errno)); + + if (status) + { + if (WIFSIGNALED (status)) + { + int sig = WTERMSIG (status); + fatal_error ("%s terminated with signal %d [%s]%s", + argv[0], sig, strsignal (sig), + WCOREDUMP (status) ? ", core dumped" : ""); + } + else + fatal_error ("%s terminated with status %d", argv[0], status); + } + + pex_free (pex); + } } /* Close the LTRANS output list. */ - if (fclose (ltrans_output_list_stream)) + if (ltrans_output_list_stream && fclose (ltrans_output_list_stream)) error ("closing LTRANS output list %s: %m", ltrans_output_list); + + obstack_free (&env_obstack, NULL); + free (argv); + + timevar_pop (TV_WHOPR_WPA_LTRANS_EXEC); } @@ -1238,13 +1439,7 @@ lto_fixup_type (tree t, void *data) /* Accessor is for derived node types only. */ LTO_FIXUP_SUBTREE (t->type.binfo); - if (TYPE_CONTEXT (t)) - { - if (TYPE_P (TYPE_CONTEXT (t))) - LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CONTEXT (t)); - else - LTO_FIXUP_SUBTREE (TYPE_CONTEXT (t)); - } + LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CONTEXT (t)); LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CANONICAL (t)); /* The following re-creates proper variant lists while fixing up @@ -1374,7 +1569,7 @@ lto_fixup_tree (tree *tp, int *walk_subtrees, void *data) t = *tp; *walk_subtrees = 0; - if (!t || pointer_set_contains (fixup_data->seen, t)) + if (pointer_set_contains (fixup_data->seen, t)) return NULL; if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL) @@ -1383,6 +1578,28 @@ lto_fixup_tree (tree *tp, int *walk_subtrees, void *data) if (t != prevailing) { + if (TREE_CODE (t) == FUNCTION_DECL + && TREE_NOTHROW (prevailing) != TREE_NOTHROW (t)) + { + /* If the prevailing definition does not throw but the + declaration (T) was considered throwing, then we + simply add PREVAILING to the list of throwing + functions. However, if the opposite is true, then + the call to PREVAILING was generated assuming that + the function didn't throw, which means that CFG + cleanup may have removed surrounding try/catch + regions. + + Note that we currently accept these cases even when + they occur within a single file. It's certainly a + user error, but we silently allow the compiler to + remove surrounding try/catch regions. Perhaps we + could emit a warning here, instead of silently + accepting the conflicting declaration. */ + if (TREE_NOTHROW (prevailing)) + lto_mark_nothrow_fndecl (prevailing); + } + /* Also replace t with prevailing defintion. We don't want to insert the other defintion in the seen set as we want to replace all instances of it. */ @@ -1523,6 +1740,20 @@ lto_fixup_decls (struct lto_file_decl_data **files) pointer_set_destroy (seen); } +/* Unlink a temporary LTRANS file unless requested otherwise. */ + +static void +lto_maybe_unlink (const char *file) +{ + if (!getenv ("WPA_SAVE_LTRANS")) + { + if (unlink_if_ordinary (file)) + error ("deleting LTRANS input file %s: %m", file); + } + else + fprintf (stderr, "[Leaving LTRANS input file %s]\n", file); +} + /* Read the options saved from each file in the command line. Called from lang_hooks.post_options which is called by process_options right before all the options are used to initialize the compiler. @@ -1548,17 +1779,17 @@ lto_read_all_file_options (void) for (i = 0; i < num_in_fnames; i++) { struct lto_file_decl_data *file_data; - lto_file *file = lto_obj_file_open (in_fnames[i], false); + lto_file *file = lto_elf_file_open (in_fnames[i], false); if (!file) break; file_data = XCNEW (struct lto_file_decl_data); file_data->file_name = file->filename; - file_data->section_hash_table = lto_obj_build_section_table (file); + file_data->section_hash_table = lto_elf_build_section_table (file); lto_read_file_options (file_data); - lto_obj_file_close (file); + lto_elf_file_close (file); htab_delete (file_data->section_hash_table); free (file_data); } @@ -1567,7 +1798,6 @@ lto_read_all_file_options (void) lto_reissue_options (); } -static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data **all_file_decl_data; /* Read all the symbols from the input files FNAMES. NFILES is the number of files requested in the command line. Instantiate a @@ -1578,6 +1808,7 @@ static void read_cgraph_and_symbols (unsigned nfiles, const char **fnames) { unsigned int i, last_file_ix; + struct lto_file_decl_data **all_file_decl_data; FILE *resolution; struct cgraph_node *node; @@ -1586,7 +1817,7 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) timevar_push (TV_IPA_LTO_DECL_IO); /* Set the hooks so that all of the ipa passes can read in their data. */ - all_file_decl_data = GGC_CNEWVEC (struct lto_file_decl_data *, nfiles + 1); + all_file_decl_data = XNEWVEC (struct lto_file_decl_data *, nfiles + 1); lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data); /* Read the resolution file. */ @@ -1608,20 +1839,12 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) gcc_assert (num_objects == nfiles); } - if (!quiet_flag) - fprintf (stderr, "Reading object files:"); - /* Read all of the object files specified on the command line. */ for (i = 0, last_file_ix = 0; i < nfiles; ++i) { struct lto_file_decl_data *file_data = NULL; - if (!quiet_flag) - { - fprintf (stderr, " %s", fnames[i]); - fflush (stderr); - } - current_lto_file = lto_obj_file_open (fnames[i], false); + current_lto_file = lto_elf_file_open (fnames[i], false); if (!current_lto_file) break; @@ -1631,10 +1854,8 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) all_file_decl_data[last_file_ix++] = file_data; - lto_obj_file_close (current_lto_file); + lto_elf_file_close (current_lto_file); current_lto_file = NULL; - /* ??? We'd want but can't ggc_collect () here as the type merging - code in gimple.c uses hashtables that are not ggc aware. */ } if (resolution_file_name) @@ -1645,44 +1866,24 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) /* Set the hooks so that all of the ipa passes can read in their data. */ lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data); + /* Each pass will set the appropriate timer. */ timevar_pop (TV_IPA_LTO_DECL_IO); - if (!quiet_flag) - fprintf (stderr, "\nReading the callgraph\n"); - - timevar_push (TV_IPA_LTO_CGRAPH_IO); /* Read the callgraph. */ input_cgraph (); - timevar_pop (TV_IPA_LTO_CGRAPH_IO); - if (!quiet_flag) - fprintf (stderr, "Merging declarations\n"); - - timevar_push (TV_IPA_LTO_DECL_MERGE); /* Merge global decls. */ lto_symtab_merge_decls (); /* Fixup all decls and types and free the type hash tables. */ lto_fixup_decls (all_file_decl_data); free_gimple_type_tables (); - ggc_collect (); - - timevar_pop (TV_IPA_LTO_DECL_MERGE); - /* Each pass will set the appropriate timer. */ - - if (!quiet_flag) - fprintf (stderr, "Reading summaries\n"); /* Read the IPA summary data. */ - if (flag_ltrans) - ipa_read_optimization_summaries (); - else - ipa_read_summaries (); + ipa_read_summaries (); /* Finally merge the cgraph according to the decl merging decisions. */ - timevar_push (TV_IPA_LTO_CGRAPH_MERGE); lto_symtab_merge_cgraph_nodes (); - ggc_collect (); if (flag_ltrans) for (node = cgraph_nodes; node; node = node->next) @@ -1696,11 +1897,8 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) node->ipa_transforms_to_apply, (ipa_opt_pass)&pass_ipa_inline); } - lto_symtab_free (); - - timevar_pop (TV_IPA_LTO_CGRAPH_MERGE); - timevar_push (TV_IPA_LTO_DECL_INIT_IO); + timevar_push (TV_IPA_LTO_DECL_IO); /* FIXME lto. This loop needs to be changed to use the pass manager to call the ipa passes directly. */ @@ -1714,9 +1912,7 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) /* Indicate that the cgraph is built and ready. */ cgraph_function_flags_ready = true; - timevar_pop (TV_IPA_LTO_DECL_INIT_IO); - ggc_free (all_file_decl_data); - all_file_decl_data = NULL; + timevar_pop (TV_IPA_LTO_DECL_IO); } @@ -1730,11 +1926,6 @@ materialize_cgraph (void) unsigned i; timevar_id_t lto_timer; - if (!quiet_flag) - fprintf (stderr, - flag_wpa ? "Materializing decls:" : "Reading function bodies:"); - - /* Now that we have input the cgraph, we need to clear all of the aux nodes and read the functions if we are not running in WPA mode. */ timevar_push (TV_IPA_LTO_GIMPLE_IO); @@ -1774,8 +1965,8 @@ materialize_cgraph (void) for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++) rest_of_decl_compilation (decl, 1, 0); - if (!quiet_flag) - fprintf (stderr, "\n"); + /* Fix up any calls to DECLs that have become not exception throwing. */ + lto_fixup_nothrow_decls (); timevar_pop (lto_timer); } @@ -1788,6 +1979,7 @@ static void do_whole_program_analysis (void) { char **output_files; + size_t i; /* Note that since we are in WPA mode, materialize_cgraph will not actually read in all the function bodies. It only materializes @@ -1797,12 +1989,6 @@ do_whole_program_analysis (void) /* Reading in the cgraph uses different timers, start timing WPA now. */ timevar_push (TV_WHOPR_WPA); - if (pre_ipa_mem_report) - { - fprintf (stderr, "Memory consumption before IPA\n"); - dump_memory_report (false); - } - cgraph_function_flags_ready = true; bitmap_obstack_initialize (NULL); ipa_register_cgraph_hooks (); @@ -1818,27 +2004,21 @@ do_whole_program_analysis (void) lto_1_to_1_map (); - if (!quiet_flag) - { - fprintf (stderr, "\nStreaming out"); - fflush (stderr); - } output_files = lto_wpa_write_files (); - ggc_collect (); - if (!quiet_flag) - fprintf (stderr, "\n"); - - if (post_ipa_mem_report) - { - fprintf (stderr, "Memory consumption after IPA\n"); - dump_memory_report (false); - } /* Show the LTO report before launching LTRANS. */ if (flag_lto_report) print_lto_report (); - lto_write_ltrans_list (output_files); + lto_execute_ltrans (output_files); + + for (i = 0; output_files[i]; ++i) + { + if (output_files[i][0] != '*') + lto_maybe_unlink (output_files[i]); + + free (output_files[i]); + } XDELETEVEC (output_files); } diff --git a/gcc/opts.c b/gcc/opts.c index 19d56348e2e..0e86ab065d7 100644 --- a/gcc/opts.c +++ b/gcc/opts.c @@ -1120,6 +1120,16 @@ decode_options (unsigned int argc, const char **argv) if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH)) PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40; } + if (flag_wpa || flag_ltrans) + { + /* These passes are not WHOPR compatible yet. */ + flag_ipa_cp = 0; + flag_ipa_reference = 0; + flag_ipa_pure_const = 0; + flag_ipa_type_escape = 0; + flag_ipa_pta = 0; + flag_ipa_struct_reorg = 0; + } if (flag_lto || flag_whopr) {