#include "opts.h"
#include "toplev.h"
#include "tree.h"
-#include "diagnostic.h"
+#include "diagnostic-core.h"
#include "tm.h"
#include "libiberty.h"
#include "cgraph.h"
#include "pointer-set.h"
#include "ipa-prop.h"
#include "common.h"
+#include "debug.h"
#include "timevar.h"
#include "gimple.h"
#include "lto.h"
#include "lto-tree.h"
#include "lto-streamer.h"
+#include "splay-tree.h"
/* This needs to be included after config.h. Otherwise, _GNU_SOURCE will not
be defined in time to set __USE_GNU in the system headers, and strsignal
# define O_BINARY 0
#endif
+static GTY(()) tree first_personality_decl;
-DEF_VEC_P(bitmap);
-DEF_VEC_ALLOC_P(bitmap,heap);
+/* Returns a hash code for P. */
+
+static hashval_t
+hash_name (const void *p)
+{
+ const struct lto_section_slot *ds = (const struct lto_section_slot *) p;
+ return (hashval_t) htab_hash_string (ds->name);
+}
+
+
+/* Returns nonzero if P1 and P2 are equal. */
+
+static int
+eq_name (const void *p1, const void *p2)
+{
+ const struct lto_section_slot *s1 =
+ (const struct lto_section_slot *) p1;
+ const struct lto_section_slot *s2 =
+ (const struct lto_section_slot *) p2;
+
+ return strcmp (s1->name, s2->name) == 0;
+}
+
+/* Free lto_section_slot */
+
+static void
+free_with_string (void *arg)
+{
+ struct lto_section_slot *s = (struct lto_section_slot *)arg;
+
+ free (CONST_CAST (char *, s->name));
+ free (arg);
+}
+
+/* Create section hash table */
+
+htab_t
+lto_obj_create_section_hash_table (void)
+{
+ return htab_create (37, hash_name, eq_name, free_with_string);
+}
/* Read the constructors and inits. */
data, len);
}
-/* Read the function body for the function associated with NODE if possible. */
+/* Read the function body for the function associated with NODE. */
static void
lto_materialize_function (struct cgraph_node *node)
WPA mode, the body of the function is not needed. */
if (!flag_wpa)
{
- allocate_struct_function (decl, false);
- announce_function (node->decl);
+ allocate_struct_function (decl, false);
+ announce_function (decl);
lto_input_function_body (file_data, decl, data);
+ if (DECL_FUNCTION_PERSONALITY (decl) && !first_personality_decl)
+ first_personality_decl = DECL_FUNCTION_PERSONALITY (decl);
lto_stats.num_function_bodies++;
}
for (i = 0; i < LTO_N_DECL_STREAMS; i++)
{
uint32_t size = *data++;
- tree *decls = GGC_NEWVEC (tree, size);
+ tree *decls = ggc_alloc_vec_tree (size);
for (j = 0; j < size; j++)
{
}
/* Read resolution for file named FILE_NAME. The resolution is read from
- RESOLUTION. An array with the symbol resolution is returned. The array
- size is written to SIZE. */
+ RESOLUTION. */
-static VEC(ld_plugin_symbol_resolution_t,heap) *
-lto_resolution_read (FILE *resolution, lto_file *file)
+static void
+lto_resolution_read (splay_tree file_ids, FILE *resolution, lto_file *file)
{
/* We require that objects in the resolution file are in the same
order as the lto1 command line. */
char *obj_name;
unsigned int num_symbols;
unsigned int i;
- VEC(ld_plugin_symbol_resolution_t,heap) *ret = NULL;
+ struct lto_file_decl_data *file_data;
unsigned max_index = 0;
+ splay_tree_node nd = NULL;
if (!resolution)
- return NULL;
+ return;
name_len = strlen (file->filename);
obj_name = XNEWVEC (char, name_len + 1);
for (i = 0; i < num_symbols; i++)
{
int t;
- unsigned index;
+ unsigned index, id;
char r_str[27];
- enum ld_plugin_symbol_resolution r;
+ enum ld_plugin_symbol_resolution r = (enum ld_plugin_symbol_resolution) 0;
unsigned int j;
unsigned int lto_resolution_str_len =
sizeof (lto_resolution_str) / sizeof (char *);
- t = fscanf (resolution, "%u %26s %*[^\n]\n", &index, r_str);
- if (t != 2)
+ t = fscanf (resolution, "%u %x %26s %*[^\n]\n", &index, &id, r_str);
+ if (t != 3)
internal_error ("Invalid line in the resolution file.");
if (index > max_index)
max_index = index;
if (j == lto_resolution_str_len)
internal_error ("Invalid resolution in the resolution file.");
- VEC_safe_grow_cleared (ld_plugin_symbol_resolution_t, heap, ret,
+ if (!(nd && nd->key == id))
+ {
+ nd = splay_tree_lookup (file_ids, id);
+ if (nd == NULL)
+ internal_error ("Resolution sub id %x not in object file", id);
+ }
+
+ file_data = (struct lto_file_decl_data *)nd->value;
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file, "Adding resolution %u %u to id %x\n",
+ index, r, file_data->id);
+ VEC_safe_grow_cleared (ld_plugin_symbol_resolution_t, heap,
+ file_data->resolutions,
max_index + 1);
- VEC_replace (ld_plugin_symbol_resolution_t, ret, index, r);
+ VEC_replace (ld_plugin_symbol_resolution_t,
+ file_data->resolutions, index, r);
}
+}
- return ret;
+/* Is the name for a id'ed LTO section? */
+
+static int
+lto_section_with_id (const char *name, unsigned *id)
+{
+ char *s;
+
+ if (strncmp (name, LTO_SECTION_NAME_PREFIX, strlen (LTO_SECTION_NAME_PREFIX)))
+ return 0;
+ s = strrchr (name, '.');
+ return s && sscanf (s, ".%x", id) == 1;
+}
+
+/* Create file_data of each sub file id */
+
+static int
+create_subid_section_table (void **slot, void *data)
+{
+ struct lto_section_slot s_slot, *new_slot;
+ struct lto_section_slot *ls = *(struct lto_section_slot **)slot;
+ splay_tree file_ids = (splay_tree)data;
+ unsigned id;
+ splay_tree_node nd;
+ void **hash_slot;
+ char *new_name;
+ struct lto_file_decl_data *file_data;
+
+ if (!lto_section_with_id (ls->name, &id))
+ return 1;
+
+ /* Find hash table of sub module id */
+ nd = splay_tree_lookup (file_ids, id);
+ if (nd != NULL)
+ {
+ file_data = (struct lto_file_decl_data *)nd->value;
+ }
+ else
+ {
+ file_data = ggc_alloc_lto_file_decl_data ();
+ memset(file_data, 0, sizeof (struct lto_file_decl_data));
+ file_data->id = id;
+ file_data->section_hash_table = lto_obj_create_section_hash_table ();;
+ splay_tree_insert (file_ids, id, (splay_tree_value)file_data);
+ }
+
+ /* Copy section into sub module hash table */
+ new_name = XDUPVEC (char, ls->name, strlen (ls->name) + 1);
+ s_slot.name = new_name;
+ hash_slot = htab_find_slot (file_data->section_hash_table, &s_slot, INSERT);
+ gcc_assert (*hash_slot == NULL);
+
+ new_slot = XDUP (struct lto_section_slot, ls);
+ new_slot->name = new_name;
+ *hash_slot = new_slot;
+ return 1;
+}
+
+/* Read declarations and other initializations for a FILE_DATA. */
+
+static void
+lto_file_finalize (struct lto_file_decl_data *file_data, lto_file *file)
+{
+ const char *data;
+ size_t len;
+
+ file_data->renaming_hash_table = lto_create_renaming_table ();
+ file_data->file_name = file->filename;
+ data = lto_get_section_data (file_data, LTO_section_decls, NULL, &len);
+ gcc_assert (data != NULL);
+ lto_read_decls (file_data, data, file_data->resolutions);
+ lto_free_section_data (file_data, LTO_section_decls, NULL, data, len);
+}
+
+struct lwstate
+{
+ lto_file *file;
+ struct lto_file_decl_data **file_data;
+ int *count;
+};
+
+/* Traverse ids and create a list of file_datas out of it. */
+
+static int lto_create_files_from_ids (splay_tree_node node, void *data)
+{
+ struct lwstate *lw = (struct lwstate *)data;
+ struct lto_file_decl_data *file_data = (struct lto_file_decl_data *)node->value;
+
+ lto_file_finalize (file_data, lw->file);
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file, "Creating file %s with sub id %x\n",
+ file_data->file_name, file_data->id);
+ file_data->next = *lw->file_data;
+ *lw->file_data = file_data;
+ (*lw->count)++;
+ return 0;
}
/* Generate a TREE representation for all types and external decls
the .o file to load the functions and ipa information. */
static struct lto_file_decl_data *
-lto_file_read (lto_file *file, FILE *resolution_file)
+lto_file_read (lto_file *file, FILE *resolution_file, int *count)
{
- struct lto_file_decl_data *file_data;
- const char *data;
- size_t len;
- VEC(ld_plugin_symbol_resolution_t,heap) *resolutions;
+ struct lto_file_decl_data *file_data = NULL;
+ splay_tree file_ids;
+ htab_t section_hash_table;
+ struct lwstate state;
- resolutions = lto_resolution_read (resolution_file, file);
+ section_hash_table = lto_obj_build_section_table (file);
- file_data = GGC_NEW (struct lto_file_decl_data);
- file_data->file_name = file->filename;
- 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);
- lto_read_decls (file_data, data, resolutions);
- lto_free_section_data (file_data, LTO_section_decls, NULL, data, len);
+ /* Find all sub modules in the object and put their sections into new hash
+ tables in a splay tree. */
+ file_ids = splay_tree_new (splay_tree_compare_ints, NULL, NULL);
+ htab_traverse (section_hash_table, create_subid_section_table, file_ids);
+
+ /* Add resolutions to file ids */
+ lto_resolution_read (file_ids, resolution_file, file);
+
+ /* Finalize each lto file for each submodule in the merged object
+ and create list for returning. */
+ state.file = file;
+ state.file_data = &file_data;
+ state.count = count;
+ splay_tree_foreach (file_ids, lto_create_files_from_ids, &state);
+
+ splay_tree_delete (file_ids);
+ htab_delete (section_hash_table);
return file_data;
}
htab_t section_hash_table = file_data->section_hash_table;
struct lto_section_slot *f_slot;
struct lto_section_slot s_slot;
- const char *section_name = lto_get_section_name (section_type, name);
+ const char *section_name = lto_get_section_name (section_type, name, file_data);
char *data = NULL;
*len = 0;
#endif
}
-/* 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;
+/* Structure describing ltrans partitions. */
+
+struct GTY (()) ltrans_partition_def
+{
+ cgraph_node_set cgraph_set;
+ varpool_node_set varpool_set;
+ const char * GTY ((skip)) name;
+ int insns;
+};
+
+typedef struct ltrans_partition_def *ltrans_partition;
+DEF_VEC_P(ltrans_partition);
+DEF_VEC_ALLOC_P(ltrans_partition,gc);
+
+static GTY (()) VEC(ltrans_partition, gc) *ltrans_partitions;
+static void add_cgraph_node_to_partition (ltrans_partition part, struct cgraph_node *node);
+static void add_varpool_node_to_partition (ltrans_partition part, struct varpool_node *vnode);
+
+/* Create new partition with name NAME. */
+static ltrans_partition
+new_partition (const char *name)
+{
+ ltrans_partition part = ggc_alloc_ltrans_partition_def ();
+ part->cgraph_set = cgraph_node_set_new ();
+ part->varpool_set = varpool_node_set_new ();
+ part->name = name;
+ part->insns = 0;
+ VEC_safe_push (ltrans_partition, gc, ltrans_partitions, part);
+ return part;
+}
+
+/* See all references that go to comdat objects and bring them into partition too. */
+static void
+add_references_to_partition (ltrans_partition part, struct ipa_ref_list *refs)
+{
+ int i;
+ struct ipa_ref *ref;
+ for (i = 0; ipa_ref_list_reference_iterate (refs, i, ref); i++)
+ {
+ if (ref->refered_type == IPA_REF_CGRAPH
+ && DECL_COMDAT (ipa_ref_node (ref)->decl)
+ && !cgraph_node_in_set_p (ipa_ref_node (ref), part->cgraph_set))
+ add_cgraph_node_to_partition (part, ipa_ref_node (ref));
+ else
+ if (ref->refered_type == IPA_REF_VARPOOL
+ && DECL_COMDAT (ipa_ref_varpool_node (ref)->decl)
+ && !varpool_node_in_set_p (ipa_ref_varpool_node (ref), part->varpool_set))
+ add_varpool_node_to_partition (part, ipa_ref_varpool_node (ref));
+ }
+}
+
+/* Add NODE to partition as well as the inline callees and referred comdats into partition PART. */
+
+static void
+add_cgraph_node_to_partition (ltrans_partition part, struct cgraph_node *node)
+{
+ struct cgraph_edge *e;
+
+ part->insns += node->local.inline_summary.self_size;
+
+ if (node->aux)
+ {
+ gcc_assert (node->aux != part);
+ node->in_other_partition = 1;
+ }
+ else
+ node->aux = part;
+
+ cgraph_node_set_add (part->cgraph_set, node);
+
+ for (e = node->callees; e; e = e->next_callee)
+ if ((!e->inline_failed || DECL_COMDAT (e->callee->decl))
+ && !cgraph_node_in_set_p (e->callee, part->cgraph_set))
+ add_cgraph_node_to_partition (part, e->callee);
+
+ add_references_to_partition (part, &node->ref_list);
+
+ if (node->same_comdat_group
+ && !cgraph_node_in_set_p (node->same_comdat_group, part->cgraph_set))
+ add_cgraph_node_to_partition (part, node->same_comdat_group);
+}
+
+/* Add VNODE to partition as well as comdat references partition PART. */
+
+static void
+add_varpool_node_to_partition (ltrans_partition part, struct varpool_node *vnode)
+{
+ varpool_node_set_add (part->varpool_set, vnode);
+
+ if (vnode->aux)
+ {
+ gcc_assert (vnode->aux != part);
+ vnode->in_other_partition = 1;
+ }
+ else
+ vnode->aux = part;
+
+ add_references_to_partition (part, &vnode->ref_list);
+
+ if (vnode->same_comdat_group
+ && !varpool_node_in_set_p (vnode->same_comdat_group, part->varpool_set))
+ add_varpool_node_to_partition (part, vnode->same_comdat_group);
+}
/* Group cgrah nodes by input files. This is used mainly for testing
right now. */
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;
+ ltrans_partition partition;
void **slot;
+ int npartitions = 0;
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);
-
pmap = pointer_map_create ();
- vpmap = pointer_map_create ();
for (node = cgraph_nodes; node; node = node->next)
{
/* Nodes without a body do not need partitioning. */
if (!node->analyzed)
continue;
+ /* Extern inlines and comdat are always only in partitions they are needed. */
+ if (DECL_EXTERNAL (node->decl)
+ || DECL_COMDAT (node->decl))
+ 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;
+ partition = (ltrans_partition) *slot;
else
{
- set = cgraph_node_set_new ();
+ partition = new_partition (file_data->file_name);
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);
+ *slot = partition;
+ npartitions++;
}
- cgraph_node_set_add (set, node);
+ add_cgraph_node_to_partition (partition, node);
}
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
{
if (vnode->alias || !vnode->needed)
continue;
- slot = pointer_map_contains (vpmap, file_data);
+ /* Constant pool and comdat are always only in partitions they are needed. */
+ if (DECL_IN_CONSTANT_POOL (vnode->decl)
+ || DECL_COMDAT (vnode->decl))
+ continue;
+ file_data = vnode->lto_file_data;
+ slot = pointer_map_contains (pmap, file_data);
if (slot)
- vset = (varpool_node_set) *slot;
+ partition = (ltrans_partition) *slot;
else
{
- set = cgraph_node_set_new ();
+ partition = new_partition (file_data->file_name);
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);
+ *slot = partition;
+ npartitions++;
}
- varpool_node_set_add (vset, vnode);
+ add_varpool_node_to_partition (partition, vnode);
}
+ for (node = cgraph_nodes; node; node = node->next)
+ node->aux = NULL;
+ for (vnode = varpool_nodes; vnode; vnode = vnode->next)
+ vnode->aux = NULL;
/* 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);
- }
+ if (!npartitions)
+ new_partition ("empty");
pointer_map_destroy (pmap);
- pointer_map_destroy (vpmap);
timevar_pop (TV_WHOPR_WPA);
- lto_stats.num_cgraph_partitions += VEC_length (cgraph_node_set,
- lto_cgraph_node_sets);
-}
-
-
-/* Add inlined clone NODE and its master clone to SET, if NODE itself has
- inlined callees, recursively add the callees. */
-
-static void
-lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node,
- bitmap original_decls)
-{
- struct cgraph_node *callee;
- struct cgraph_edge *edge;
-
- cgraph_node_set_add (set, node);
-
- /* 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);
- }
-}
-
-/* Compute the transitive closure of inlining of SET based on the
- information in the callgraph. Returns a bitmap of decls that have
- been inlined into SET indexed by UID. */
-
-static void
-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 ();
- bool changed;
-
- /* We are going to iterate SET while adding to it, mark all original
- nodes so that we only add node inlined to original nodes. */
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
- {
- bitmap_set_bit (original_nodes, csi_node (csi)->uid);
- bitmap_set_bit (original_decls, DECL_UID (csi_node (csi)->decl));
- }
-
- /* Some of the original nodes might not be needed anymore.
- Remove them. */
- do
- {
- changed = false;
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
- {
- struct cgraph_node *inlined_to;
- node = csi_node (csi);
-
- /* NODE was not inlined. We still need it. */
- if (!node->global.inlined_to)
- continue;
-
- inlined_to = node->global.inlined_to;
-
- /* NODE should have only one caller. */
- gcc_assert (!node->callers->next_caller);
-
- if (!bitmap_bit_p (original_nodes, inlined_to->uid))
- {
- bitmap_clear_bit (original_nodes, node->uid);
- cgraph_node_set_remove (set, node);
- changed = true;
- }
- }
- }
- 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);
- }
-
- lto_bitmap_free (original_nodes);
- lto_bitmap_free (original_decls);
+ lto_stats.num_cgraph_partitions += VEC_length (ltrans_partition,
+ ltrans_partitions);
}
/* Promote variable VNODE to be static. */
gcc_assert (flag_wpa);
TREE_PUBLIC (vnode->decl) = 1;
DECL_VISIBILITY (vnode->decl) = VISIBILITY_HIDDEN;
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file,
+ "Promoting var as hidden: %s\n", varpool_node_name (vnode));
return true;
}
DECL_VISIBILITY (alias->decl) = VISIBILITY_HIDDEN;
}
}
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file,
+ "Promoting function as hidden: %s/%i\n",
+ cgraph_node_name (node), node->uid);
return true;
}
gcc_assert (flag_wpa);
- n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets);
+ n_sets = VEC_length (ltrans_partition, ltrans_partitions);
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);
+ ltrans_partition part = VEC_index (ltrans_partition, ltrans_partitions, i);
+ set = part->cgraph_set;
+ vset = part->varpool_set;
/* 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. */
continue;
if (node->global.inlined_to)
continue;
- if (!DECL_EXTERNAL (node->decl)
+ if ((!DECL_EXTERNAL (node->decl) && !DECL_COMDAT (node->decl))
&& (referenced_from_other_partition_p (&node->ref_list, set, vset)
|| reachable_from_other_partition_p (node, set)))
promote_fn (node);
/* 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))
+ if (!DECL_IN_CONSTANT_POOL (vnode->decl) && !DECL_COMDAT (vnode->decl)
+ && !vnode->externally_visible && vnode->analyzed
+ && referenced_from_other_partition_p (&vnode->ref_list,
+ set, vset))
promote_var (vnode);
}
pointer_set_destroy (inserted);
}
+static lto_file *current_lto_file;
-/* Given a file name FNAME, return a string with FNAME prefixed with '*'. */
-
-static char *
-prefix_name_with_star (const char *fname)
-{
- char *star_fname;
- size_t len;
-
- len = strlen (fname) + 1 + 1;
- star_fname = XNEWVEC (char, len);
- snprintf (star_fname, len, "*%s", fname);
-
- return star_fname;
-}
-
-
-/* Return a copy of FNAME without the .o extension. */
-
-static char *
-strip_extension (const char *fname)
-{
- char *s = XNEWVEC (char, strlen (fname) - 2 + 1);
- gcc_assert (strstr (fname, ".o"));
- snprintf (s, strlen (fname) - 2 + 1, "%s", fname);
-
- return s;
-}
-
-
-/* Return a file name associated with cgraph node set SET. This may
- be a new temporary file name if SET needs to be processed by
- LTRANS, or the original file name if all the nodes in SET belong to
- the same input file. */
+/* Helper for qsort; compare partitions and return one with smaller size.
+ We sort from greatest to smallest so parallel build doesn't stale on the
+ longest compilation being executed too late. */
-static char *
-get_filename_for_set (cgraph_node_set set)
+static int
+cmp_partitions (const void *a, const void *b)
{
- 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))
- {
- 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;
-
- /* 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));
-
- /* 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);
-
- 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
- lto_execute_ltrans knows not to process it. */
- cgraph_node_set_iterator si = csi_start (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;
+ const struct ltrans_partition_def *pa
+ = *(struct ltrans_partition_def *const *)a;
+ const struct ltrans_partition_def *pb
+ = *(struct ltrans_partition_def *const *)b;
+ return pb->insns - pa->insns;
}
-static lto_file *current_lto_file;
-
-
-/* Write all output files in WPA mode. Returns a NULL-terminated array of
- output file names. */
+/* Write all output files in WPA mode and the file with the list of
+ LTRANS units. */
-static char **
+static void
lto_wpa_write_files (void)
{
- char **output_files;
- unsigned i, n_sets, last_out_file_ix, num_out_files;
+ unsigned i, n_sets;
lto_file *file;
cgraph_node_set set;
varpool_node_set vset;
+ ltrans_partition part;
+ FILE *ltrans_output_list_stream;
+ char *temp_filename;
+ size_t blen;
+
+ /* Open the LTRANS output list. */
+ if (!ltrans_output_list)
+ fatal_error ("no LTRANS output list filename provided");
+ ltrans_output_list_stream = fopen (ltrans_output_list, "w");
+ if (ltrans_output_list_stream == NULL)
+ fatal_error ("opening LTRANS output list %s: %m", ltrans_output_list);
timevar_push (TV_WHOPR_WPA);
compiled by LTRANS. After this loop, only those sets that
contain callgraph nodes from more than one file will need to be
compiled by LTRANS. */
- for (i = 0; VEC_iterate (cgraph_node_set, lto_cgraph_node_sets, i, set); i++)
- {
- lto_add_all_inlinees (set);
- lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr,
- set->nodes);
- }
+ for (i = 0; VEC_iterate (ltrans_partition, ltrans_partitions, i, part); i++)
+ lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr,
+ part->cgraph_set->nodes);
/* After adding all inlinees, find out statics that need to be promoted
to globals because of cross-file inlining. */
timevar_push (TV_WHOPR_WPA_IO);
- /* The number of output files depends on the number of input files
- and how many callgraph node sets we create. Reserve enough space
- for the maximum of these two. */
- num_out_files = MAX (VEC_length (cgraph_node_set, lto_cgraph_node_sets),
- num_in_fnames);
- output_files = XNEWVEC (char *, num_out_files + 1);
-
- n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets);
+ /* Generate a prefix for the LTRANS unit files. */
+ blen = strlen (ltrans_output_list);
+ temp_filename = (char *) xmalloc (blen + sizeof ("2147483648.o"));
+ strcpy (temp_filename, ltrans_output_list);
+ if (blen > sizeof (".out")
+ && strcmp (temp_filename + blen - sizeof (".out") + 1,
+ ".out") == 0)
+ temp_filename[blen - sizeof (".out") + 1] = '\0';
+ blen = strlen (temp_filename);
+
+ n_sets = VEC_length (ltrans_partition, ltrans_partitions);
+ qsort (VEC_address (ltrans_partition, ltrans_partitions), n_sets,
+ sizeof (ltrans_partition), cmp_partitions);
for (i = 0; i < n_sets; i++)
{
- 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))
- {
- /* Write all the nodes in SET to TEMP_FILENAME. */
- file = lto_obj_file_open (temp_filename, true);
- if (!file)
- fatal_error ("lto_obj_file_open() failed");
-
- if (!quiet_flag)
- fprintf (stderr, " %s", temp_filename);
+ size_t len;
+ ltrans_partition part = VEC_index (ltrans_partition, ltrans_partitions, i);
- lto_set_current_out_file (file);
+ set = part->cgraph_set;
+ vset = part->varpool_set;
- ipa_write_optimization_summaries (set, vset);
+ /* Write all the nodes in SET. */
+ sprintf (temp_filename + blen, "%u.o", i);
+ file = lto_obj_file_open (temp_filename, true);
+ if (!file)
+ fatal_error ("lto_obj_file_open() failed");
- lto_set_current_out_file (NULL);
- lto_obj_file_close (file);
+ if (!quiet_flag)
+ fprintf (stderr, " %s (%s %i insns)", temp_filename, part->name, part->insns);
+ if (cgraph_dump_file)
+ {
+ fprintf (cgraph_dump_file, "Writting partition %s to file %s, %i insns\n",
+ part->name, temp_filename, part->insns);
+ fprintf (cgraph_dump_file, "cgraph nodes:");
+ dump_cgraph_node_set (cgraph_dump_file, set);
+ fprintf (cgraph_dump_file, "varpool nodes:");
+ dump_varpool_node_set (cgraph_dump_file, vset);
}
- }
-
- last_out_file_ix = n_sets;
-
- lto_stats.num_output_files += n_sets;
-
- output_files[last_out_file_ix] = NULL;
+ gcc_assert (cgraph_node_set_nonempty_p (set)
+ || varpool_node_set_nonempty_p (vset) || !i);
- timevar_pop (TV_WHOPR_WPA_IO);
-
- return output_files;
-}
+ lto_set_current_out_file (file);
-/* 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)
-{
- FILE *ltrans_output_list_stream = NULL;
- unsigned i;
+ ipa_write_optimization_summaries (set, vset);
- /* 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);
-
- for (i = 0; files[i]; ++i)
- {
- size_t len;
+ lto_set_current_out_file (NULL);
+ lto_obj_file_close (file);
- len = strlen (files[i]);
- if (fwrite (files[i], 1, len, ltrans_output_list_stream) < len
+ len = strlen (temp_filename);
+ if (fwrite (temp_filename, 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);
+ fatal_error ("writing to LTRANS output list %s: %m",
+ ltrans_output_list);
}
+ lto_stats.num_output_files += n_sets;
+
/* Close the LTRANS output list. */
if (fclose (ltrans_output_list_stream))
- error ("closing LTRANS output list %s: %m", ltrans_output_list);
+ fatal_error ("closing LTRANS output list %s: %m", ltrans_output_list);
+
+ timevar_pop (TV_WHOPR_WPA_IO);
}
else
LTO_FIXUP_SUBTREE (TYPE_CONTEXT (t));
}
- LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CANONICAL (t));
+
+ /* TYPE_CANONICAL does not need to be fixed up, instead it should
+ always point to ourselves at this time as we never fixup
+ non-canonical ones. */
+ gcc_assert (TYPE_CANONICAL (t) == t);
/* The following re-creates proper variant lists while fixing up
the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
/* Set the hooks to read ELF sections. */
lto_set_in_hooks (NULL, get_section_data, free_section_data);
+ if (!quiet_flag)
+ fprintf (stderr, "Reading command line options:");
for (i = 0; i < num_in_fnames; i++)
{
lto_file *file = lto_obj_file_open (in_fnames[i], false);
if (!file)
break;
+ if (!quiet_flag)
+ {
+ fprintf (stderr, " %s", in_fnames[i]);
+ fflush (stderr);
+ }
file_data = XCNEW (struct lto_file_decl_data);
file_data->file_name = file->filename;
static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data **all_file_decl_data;
+/* Turn file datas for sub files into a single array, so that they look
+ like separate files for further passes. */
+
+static void
+lto_flatten_files (struct lto_file_decl_data **orig, int count, int last_file_ix)
+{
+ struct lto_file_decl_data *n, *next;
+ int i, k;
+
+ lto_stats.num_input_files = count;
+ all_file_decl_data
+ = ggc_alloc_cleared_vec_lto_file_decl_data_ptr (count + 1);
+ /* 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);
+ for (i = 0, k = 0; i < last_file_ix; i++)
+ {
+ for (n = orig[i]; n != NULL; n = next)
+ {
+ all_file_decl_data[k++] = n;
+ next = n->next;
+ n->next = NULL;
+ }
+ }
+ all_file_decl_data[k] = NULL;
+ gcc_assert (k == count);
+}
+
/* Read all the symbols from the input files FNAMES. NFILES is the
number of files requested in the command line. Instantiate a
global call graph by aggregating all the sub-graphs found in each
unsigned int i, last_file_ix;
FILE *resolution;
struct cgraph_node *node;
+ int count = 0;
+ struct lto_file_decl_data **decl_data;
- lto_stats.num_input_files = nfiles;
+ init_cgraph ();
- timevar_push (TV_IPA_LTO_DECL_IO);
+ timevar_push (TV_IPA_LTO_DECL_IN);
- /* 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);
- lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
+ decl_data = (struct lto_file_decl_data **)xmalloc (sizeof(*decl_data) * (nfiles+1));
/* Read the resolution file. */
resolution = NULL;
resolution = fopen (resolution_file_name, "r");
if (resolution == NULL)
- fatal_error ("could not open symbol resolution file: %s",
- xstrerror (errno));
+ fatal_error ("could not open symbol resolution file: %m");
t = fscanf (resolution, "%u", &num_objects);
gcc_assert (t == 1);
if (!current_lto_file)
break;
- file_data = lto_file_read (current_lto_file, resolution);
+ file_data = lto_file_read (current_lto_file, resolution, &count);
if (!file_data)
break;
- all_file_decl_data[last_file_ix++] = file_data;
+ decl_data[last_file_ix++] = file_data;
lto_obj_file_close (current_lto_file);
current_lto_file = NULL;
- ggc_collect ();
+ /* ??? We'd want but can't ggc_collect () here as the type merging
+ code in gimple.c uses hashtables that are not ggc aware. */
}
+ lto_flatten_files (decl_data, count, last_file_ix);
+ lto_stats.num_input_files = count;
+ free(decl_data);
+
if (resolution_file_name)
fclose (resolution);
- all_file_decl_data[last_file_ix] = NULL;
-
/* 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);
- timevar_pop (TV_IPA_LTO_DECL_IO);
+ timevar_pop (TV_IPA_LTO_DECL_IN);
if (!quiet_flag)
fprintf (stderr, "\nReading the callgraph\n");
/* Finally merge the cgraph according to the decl merging decisions. */
timevar_push (TV_IPA_LTO_CGRAPH_MERGE);
+ if (cgraph_dump_file)
+ {
+ fprintf (cgraph_dump_file, "Before merging:\n");
+ dump_cgraph (cgraph_dump_file);
+ dump_varpool (cgraph_dump_file);
+ }
lto_symtab_merge_cgraph_nodes ();
ggc_collect ();
/* FIXME lto. This loop needs to be changed to use the pass manager to
call the ipa passes directly. */
- if (!errorcount)
+ if (!seen_error ())
for (i = 0; i < last_file_ix; i++)
{
struct lto_file_decl_data *file_data = all_file_decl_data [i];
/* 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);
+ timevar_push (TV_IPA_LTO_GIMPLE_IN);
for (node = cgraph_nodes; node; node = node->next)
{
}
}
- timevar_pop (TV_IPA_LTO_GIMPLE_IO);
+ timevar_pop (TV_IPA_LTO_GIMPLE_IN);
/* Start the appropriate timer depending on the mode that we are
operating in. */
static void
do_whole_program_analysis (void)
{
- char **output_files;
-
/* Note that since we are in WPA mode, materialize_cgraph will not
actually read in all the function bodies. It only materializes
the decls and cgraph nodes so that analysis can be performed. */
dump_memory_report (false);
}
+ if (cgraph_dump_file)
+ {
+ dump_cgraph (cgraph_dump_file);
+ dump_varpool (cgraph_dump_file);
+ }
+
cgraph_function_flags_ready = true;
bitmap_obstack_initialize (NULL);
ipa_register_cgraph_hooks ();
execute_ipa_pass_list (all_regular_ipa_passes);
+ if (cgraph_dump_file)
+ {
+ fprintf (cgraph_dump_file, "Optimized ");
+ dump_cgraph (cgraph_dump_file);
+ dump_varpool (cgraph_dump_file);
+ }
verify_cgraph ();
bitmap_obstack_release (NULL);
fprintf (stderr, "\nStreaming out");
fflush (stderr);
}
- output_files = lto_wpa_write_files ();
+ lto_wpa_write_files ();
ggc_collect ();
if (!quiet_flag)
fprintf (stderr, "\n");
/* Show the LTO report before launching LTRANS. */
if (flag_lto_report)
print_lto_report ();
+}
+
+
+static GTY(()) tree lto_eh_personality_decl;
+
+/* Return the LTO personality function decl. */
- lto_write_ltrans_list (output_files);
+tree
+lto_eh_personality (void)
+{
+ if (!lto_eh_personality_decl)
+ {
+ /* Use the first personality DECL for our personality if we don't
+ support multiple ones. This ensures that we don't artificially
+ create the need for them in a single-language program. */
+ if (first_personality_decl && !dwarf2out_do_cfi_asm ())
+ lto_eh_personality_decl = first_personality_decl;
+ else
+ lto_eh_personality_decl = lhd_gcc_personality ();
+ }
- XDELETEVEC (output_files);
+ return lto_eh_personality_decl;
}
command line. */
read_cgraph_and_symbols (num_in_fnames, in_fnames);
- if (!errorcount)
+ if (!seen_error ())
{
/* If WPA is enabled analyze the whole call graph and create an
optimization plan. Otherwise, read in all the function
projects / thirdparty / gcc.git / blobdiff