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);
- 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));
}
if (node->global.inlined_to || node->clone_of)
continue;
/* Nodes without a body do not need partitioning. */
- if (!node->analyzed)
+ if (!node->analyzed || node->same_body_alias)
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)
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
{
- if (vnode->alias || !vnode->needed)
+ if (vnode->alias)
continue;
slot = pointer_map_contains (vpmap, file_data);
if (slot)
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;
gcc_assert (flag_wpa);
+ /* At moment we make no attempt to figure out who is refering the variables,
+ so all must become global.
+
+ 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. */
+ for (vnode = varpool_nodes; vnode; vnode = vnode->next)
+ if (!vnode->externally_visible && vnode->analyzed
+ && !DECL_IN_CONSTANT_POOL (vnode->decl))
+ {
+ TREE_PUBLIC (vnode->decl) = 1;
+ DECL_VISIBILITY (vnode->decl) = VISIBILITY_HIDDEN;
+ }
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);
/* 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);
+ bool globalize = node->address_taken || node->local.vtable_method;
+ struct cgraph_edge *e;
if (node->local.externally_visible)
continue;
- if (node->clone_of || 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)))
+ for (e = node->callers; e && !globalize; e = e->next_caller)
+ {
+ struct cgraph_node *caller = e->caller;
+ if (caller->global.inlined_to)
+ caller = caller->global.inlined_to;
+ if (!cgraph_node_in_set_p (caller, set))
+ globalize = true;
+ }
+ if (globalize)
{
- gcc_assert (flag_wpa);
TREE_PUBLIC (node->decl) = 1;
DECL_VISIBILITY (node->decl) = VISIBILITY_HIDDEN;
if (node->same_body)
}
}
}
- 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))
- {
- gcc_assert (flag_wpa);
- TREE_PUBLIC (vnode->decl) = 1;
- DECL_VISIBILITY (vnode->decl) = VISIBILITY_HIDDEN;
- }
- }
}
}
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
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;
}
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);
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);
}
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)
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.
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);
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++;
}
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
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);
}
OSDN Git Service
