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
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);
-
- /* 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);
- }
+ if (!flag_wpa)
+ ggc_collect ();
}
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));
}
for (i = 0; i < LTO_N_DECL_STREAMS; i++)
{
uint32_t size = *data++;
- tree *decls = (tree *) xcalloc (size, sizeof (tree));
+ tree *decls = GGC_NEWVEC (tree, size);
for (j = 0; j < size; j++)
{
/* Read in per-function decl states and enter them in hash table. */
decl_data->function_decl_states =
- htab_create (37, lto_hash_in_decl_state, lto_eq_in_decl_state, free);
+ htab_create_ggc (37, lto_hash_in_decl_state, lto_eq_in_decl_state, NULL);
for (i = 1; i < num_decl_states; i++)
{
resolutions = lto_resolution_read (resolution_file, file);
- file_data = XCNEW (struct lto_file_decl_data);
+ file_data = GGC_NEW (struct lto_file_decl_data);
file_data->file_name = file->filename;
- file_data->section_hash_table = lto_elf_build_section_table (file);
+ file_data->section_hash_table = lto_obj_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);
/* 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
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);
-
- /* 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;
- }
+ lto_varpool_node_sets = VEC_alloc (varpool_node_set, gc, 1);
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 or
- cloned from. */
- if (node->global.inlined_to || node->clone_of)
+ /* We will get proper partition based on function they are inlined to. */
+ if (node->global.inlined_to)
continue;
- /* We only need to partition the nodes that we read from the
- gimple bytecode files. */
- file_data = node->local.lto_file_data;
- if (file_data == NULL)
+ /* Nodes without a body do not need partitioning. */
+ if (!node->analyzed)
continue;
+ file_data = node->local.lto_file_data;
+ gcc_assert (!node->same_body_alias && file_data);
+
slot = pointer_map_contains (pmap, file_data);
if (slot)
set = (cgraph_node_set) *slot;
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,
lto_bitmap_free (original_decls);
}
-/* Owing to inlining, we may need to promote a file-scope variable
- to a global variable. Consider this case:
-
- a.c:
- static int var;
+/* Promote variable VNODE to be static. */
- void
- foo (void)
- {
- var++;
- }
-
- b.c:
-
- 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
+static bool
+promote_var (struct varpool_node *vnode)
{
- /* 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;
-
- /* static vars in all previous set. */
- bitmap all_static_vars;
-
- /* all vars in all previous set. */
- bitmap all_vars;
-} globalize_context_t;
+ 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;
+}
-/* 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. */
+/* Promote function NODE to be static. */
-static tree
-globalize_cross_file_statics (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
- void *data)
+static bool
+promote_fn (struct cgraph_node *node)
{
- 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))
+ 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)
{
- if (!cgraph_node_in_set_p (cgraph_node (t), context->set)
- || cgraph_node (t)->address_taken)
+ struct cgraph_node *alias;
+ for (alias = node->same_body;
+ alias; alias = alias->next)
{
- /* 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;
+ TREE_PUBLIC (alias->decl) = 1;
+ DECL_VISIBILITY (alias->decl) = VISIBILITY_HIDDEN;
}
}
-
- 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);
- }
+ return true;
}
/* Find out all static decls that need to be promoted to global because
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;
- globalize_context_t context;
+ varpool_node_set_iterator vsi;
+ VEC(varpool_node_ptr, heap) *promoted_initializers = NULL;
+ struct pointer_set_t *inserted = pointer_set_create ();
- memset (&context, 0, sizeof (context));
- context.all_vars = lto_bitmap_alloc ();
- context.all_static_vars = lto_bitmap_alloc ();
+ gcc_assert (flag_wpa);
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);
- context.set = set;
- context.visited = pointer_set_create ();
- context.static_vars_in_set = lto_bitmap_alloc ();
- context.seen_node_decls = lto_bitmap_alloc ();
+ vset = VEC_index (varpool_node_set, lto_varpool_node_sets, i);
+ /* 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))
- lto_scan_statics_in_cgraph_node (csi_node (csi), &context);
-
- if (i == n_sets - 1)
- lto_scan_statics_in_remaining_global_vars (&context);
+ {
+ 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);
+ }
- bitmap_ior_into (context.all_static_vars, context.static_vars_in_set);
+ /* 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;
- pointer_set_destroy (context.visited);
- lto_bitmap_free (context.static_vars_in_set);
- lto_bitmap_free (context.seen_node_decls);
+ 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);
+ }
+ }
+ }
+ }
}
-
- lto_bitmap_free (context.all_vars);
- lto_bitmap_free (context.all_static_vars);
+ pointer_set_destroy (inserted);
}
char *fname = NULL;
static const size_t max_fname_len = 100;
- if (cgraph_node_set_needs_ltrans_p (set))
+ /* 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))
{
- /* 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;
+ 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);
- /* 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
+ if (!fname)
{
/* Since SET does not need to be processed by LTRANS, use
the original file name and mark it with a '*' prefix so that
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;
}
unsigned i, n_sets, last_out_file_ix, num_out_files;
lto_file *file;
cgraph_node_set set;
+ varpool_node_set vset;
timevar_push (TV_WHOPR_WPA);
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_needs_ltrans_p (set))
+ if (cgraph_node_set_nonempty_p (set) || varpool_node_set_nonempty_p (vset))
{
/* Write all the nodes in SET to TEMP_FILENAME. */
- file = lto_elf_file_open (temp_filename, true);
+ file = lto_obj_file_open (temp_filename, true);
if (!file)
- fatal_error ("lto_elf_file_open() failed");
+ fatal_error ("lto_obj_file_open() failed");
+
+ if (!quiet_flag)
+ fprintf (stderr, " %s", temp_filename);
lto_set_current_out_file (file);
- ipa_write_optimization_summaries (set);
+ ipa_write_optimization_summaries (set, vset);
lto_set_current_out_file (NULL);
- lto_elf_file_close (file);
+ lto_obj_file_close (file);
}
}
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_execute_ltrans (char *const *files)
+lto_write_ltrans_list (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;
- 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";
+ unsigned i;
/* Open the 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);
- }
+ 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);
for (i = 0; files[i]; ++i)
{
size_t len;
- /* 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);
- }
+ 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);
}
/* Close the LTRANS output list. */
- if (ltrans_output_list_stream && fclose (ltrans_output_list_stream))
+ if (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);
}
/* Accessor is for derived node types only. */
LTO_FIXUP_SUBTREE (t->type.binfo);
- LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CONTEXT (t));
+ 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_CANONICAL (t));
/* The following re-creates proper variant lists while fixing up
t = *tp;
*walk_subtrees = 0;
- if (pointer_set_contains (fixup_data->seen, t))
+ if (!t || pointer_set_contains (fixup_data->seen, t))
return NULL;
if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
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. */
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.
for (i = 0; i < num_in_fnames; i++)
{
struct lto_file_decl_data *file_data;
- lto_file *file = lto_elf_file_open (in_fnames[i], false);
+ lto_file *file = lto_obj_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_elf_build_section_table (file);
+ file_data->section_hash_table = lto_obj_build_section_table (file);
lto_read_file_options (file_data);
- lto_elf_file_close (file);
+ lto_obj_file_close (file);
htab_delete (file_data->section_hash_table);
free (file_data);
}
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
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;
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 = XNEWVEC (struct lto_file_decl_data *, nfiles + 1);
+ all_file_decl_data = GGC_CNEWVEC (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. */
fflush (stderr);
}
- current_lto_file = lto_elf_file_open (fnames[i], false);
+ current_lto_file = lto_obj_file_open (fnames[i], false);
if (!current_lto_file)
break;
all_file_decl_data[last_file_ix++] = file_data;
- lto_elf_file_close (current_lto_file);
+ lto_obj_file_close (current_lto_file);
current_lto_file = NULL;
+ ggc_collect ();
}
if (resolution_file_name)
/* 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");
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)
node->ipa_transforms_to_apply,
(ipa_opt_pass)&pass_ipa_inline);
}
+ lto_symtab_free ();
- timevar_push (TV_IPA_LTO_DECL_IO);
+ timevar_pop (TV_IPA_LTO_CGRAPH_MERGE);
+
+ timevar_push (TV_IPA_LTO_DECL_INIT_IO);
/* FIXME lto. This loop needs to be changed to use the pass manager to
call the ipa passes directly. */
/* Indicate that the cgraph is built and ready. */
cgraph_function_flags_ready = true;
- timevar_pop (TV_IPA_LTO_DECL_IO);
+ timevar_pop (TV_IPA_LTO_DECL_INIT_IO);
+ ggc_free (all_file_decl_data);
+ all_file_decl_data = NULL;
}
if (node->local.lto_file_data
&& !DECL_IS_BUILTIN (node->decl))
{
- announce_function (node->decl);
lto_materialize_function (node);
lto_stats.num_input_cgraph_nodes++;
}
for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++)
rest_of_decl_compilation (decl, 1, 0);
- /* Fix up any calls to DECLs that have become not exception throwing. */
- lto_fixup_nothrow_decls ();
if (!quiet_flag)
fprintf (stderr, "\n");
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
/* 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 ();
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_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]);
- }
+ lto_write_ltrans_list (output_files);
XDELETEVEC (output_files);
}
OSDN Git Service
