/* Top-level LTO routines.
- Copyright 2009, 2010 Free Software Foundation, Inc.
+ Copyright 2009, 2010, 2011 Free Software Foundation, Inc.
Contributed by CodeSourcery, Inc.
This file is part of GCC.
#include "opts.h"
#include "toplev.h"
#include "tree.h"
-#include "diagnostic.h"
+#include "tree-flow.h"
+#include "diagnostic-core.h"
#include "tm.h"
-#include "libiberty.h"
#include "cgraph.h"
#include "ggc.h"
#include "tree-ssa-operands.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 "tree-streamer.h"
+#include "splay-tree.h"
+#include "params.h"
+#include "ipa-inline.h"
+#include "ipa-utils.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
- will not be declared. */
-#if HAVE_MMAP_FILE
-#include <sys/mman.h>
-#endif
+static GTY(()) tree first_personality_decl;
-/* Handle opening elf files on hosts, such as Windows, that may use
- text file handling that will break binary access. */
+/* Returns a hash code for P. */
-#ifndef O_BINARY
-# define O_BINARY 0
-#endif
+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);
+}
+
+/* Delete an allocated integer KEY in the splay tree. */
+
+static void
+lto_splay_tree_delete_id (splay_tree_key key)
+{
+ free ((void *) key);
+}
+
+/* Compare splay tree node ids A and B. */
+
+static int
+lto_splay_tree_compare_ids (splay_tree_key a, splay_tree_key b)
+{
+ unsigned HOST_WIDE_INT ai;
+ unsigned HOST_WIDE_INT bi;
+
+ ai = *(unsigned HOST_WIDE_INT *) a;
+ bi = *(unsigned HOST_WIDE_INT *) b;
+
+ if (ai < bi)
+ return -1;
+ else if (ai > bi)
+ return 1;
+ return 0;
+}
+
+/* Look up splay tree node by ID in splay tree T. */
+
+static splay_tree_node
+lto_splay_tree_lookup (splay_tree t, unsigned HOST_WIDE_INT id)
+{
+ return splay_tree_lookup (t, (splay_tree_key) &id);
+}
+
+/* Check if KEY has ID. */
+
+static bool
+lto_splay_tree_id_equal_p (splay_tree_key key, unsigned HOST_WIDE_INT id)
+{
+ return *(unsigned HOST_WIDE_INT *) key == id;
+}
+
+/* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
+ The ID is allocated separately because we need HOST_WIDE_INTs which may
+ be wider than a splay_tree_key. */
+static void
+lto_splay_tree_insert (splay_tree t, unsigned HOST_WIDE_INT id,
+ struct lto_file_decl_data *file_data)
+{
+ unsigned HOST_WIDE_INT *idp = XCNEW (unsigned HOST_WIDE_INT);
+ *idp = id;
+ splay_tree_insert (t, (splay_tree_key) idp, (splay_tree_value) file_data);
+}
-DEF_VEC_P(bitmap);
-DEF_VEC_ALLOC_P(bitmap,heap);
+/* Create a splay tree. */
+
+static splay_tree
+lto_splay_tree_new (void)
+{
+ return splay_tree_new (lto_splay_tree_compare_ids,
+ lto_splay_tree_delete_id,
+ NULL);
+}
/* Read the constructors and inits. */
data, len);
}
-/* Read the function body for the function associated with NODE if possible. */
+/* Return true when NODE has a clone that is analyzed (i.e. we need
+ to load its body even if the node itself is not needed). */
+
+static bool
+has_analyzed_clone_p (struct cgraph_node *node)
+{
+ struct cgraph_node *orig = node;
+ node = node->clones;
+ if (node)
+ while (node != orig)
+ {
+ if (node->analyzed)
+ return true;
+ if (node->clones)
+ node = node->clones;
+ else if (node->next_sibling_clone)
+ node = node->next_sibling_clone;
+ else
+ {
+ while (node != orig && !node->next_sibling_clone)
+ node = node->clone_of;
+ if (node != orig)
+ node = node->next_sibling_clone;
+ }
+ }
+ return false;
+}
+
+/* Read the function body for the function associated with NODE. */
static void
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
- decisions. */
- if (node->clone_of)
- return;
decl = node->decl;
- file_data = node->local.lto_file_data;
- name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
-
- /* We may have renamed the declaration, e.g., a static function. */
- name = lto_get_decl_name_mapping (file_data, name);
-
- data = lto_get_section_data (file_data, LTO_section_function_body,
- name, &len);
- if (data)
+ /* Read in functions with body (analyzed nodes)
+ and also functions that are needed to produce virtual clones. */
+ if (cgraph_function_with_gimple_body_p (node) || has_analyzed_clone_p (node))
{
- 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);
+ /* Clones and thunks don't need to be read. */
+ if (node->clone_of)
+ return;
/* 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)
{
- lto_input_function_body (file_data, decl, data);
- lto_stats.num_function_bodies++;
- }
+ file_data = node->local.lto_file_data;
+ name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
- fn = DECL_STRUCT_FUNCTION (decl);
- lto_free_section_data (file_data, LTO_section_function_body, name,
- data, len);
+ /* We may have renamed the declaration, e.g., a static function. */
+ name = lto_get_decl_name_mapping (file_data, name);
- /* 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);
+ data = lto_get_section_data (file_data, LTO_section_function_body,
+ name, &len);
+ if (!data)
+ fatal_error ("%s: section %s is missing",
+ file_data->file_name,
+ name);
+
+ gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL);
+
+ 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++;
+ lto_free_section_data (file_data, LTO_section_function_body, name,
+ data, len);
+ 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));
}
-/* Decode the content of memory pointed to by DATA in the the
- in decl state object STATE. DATA_IN points to a data_in structure for
- decoding. Return the address after the decoded object in the input. */
+/* Decode the content of memory pointed to by DATA in the in decl
+ state object STATE. DATA_IN points to a data_in structure for
+ decoding. Return the address after the decoded object in the
+ input. */
static const uint32_t *
lto_read_in_decl_state (struct data_in *data_in, const uint32_t *data,
uint32_t i, j;
ix = *data++;
- decl = lto_streamer_cache_get (data_in->reader_cache, (int) ix);
+ decl = streamer_tree_cache_get (data_in->reader_cache, ix);
if (TREE_CODE (decl) != FUNCTION_DECL)
{
gcc_assert (decl == void_type_node);
for (i = 0; i < LTO_N_DECL_STREAMS; i++)
{
uint32_t size = *data++;
- tree *decls = (tree *) xcalloc (size, sizeof (tree));
+ tree *decls = ggc_alloc_vec_tree (size);
for (j = 0; j < size; j++)
- {
- decls[j] = lto_streamer_cache_get (data_in->reader_cache, data[j]);
-
- /* Register every type in the global type table. If the
- type existed already, use the existing type. */
- if (TYPE_P (decls[j]))
- decls[j] = gimple_register_type (decls[j]);
- }
+ decls[j] = streamer_tree_cache_get (data_in->reader_cache, data[j]);
state->streams[i].size = size;
state->streams[i].trees = decls;
return data;
}
+/* A hashtable of trees that potentially refer to variables or functions
+ that must be replaced with their prevailing variant. */
+static GTY((if_marked ("ggc_marked_p"), param_is (union tree_node))) htab_t
+ tree_with_vars;
+
+/* Remember that T is a tree that (potentially) refers to a variable
+ or function decl that may be replaced with its prevailing variant. */
+static void
+remember_with_vars (tree t)
+{
+ *(tree *) htab_find_slot (tree_with_vars, t, INSERT) = t;
+}
+
+#define LTO_FIXUP_TREE(tt) \
+ do \
+ { \
+ if (tt) \
+ { \
+ if (TYPE_P (tt)) \
+ (tt) = gimple_register_type (tt); \
+ if (VAR_OR_FUNCTION_DECL_P (tt) && TREE_PUBLIC (tt)) \
+ remember_with_vars (t); \
+ } \
+ } while (0)
+
+static void lto_fixup_types (tree);
+
+/* Fix up fields of a tree_typed T. */
+
+static void
+lto_ft_typed (tree t)
+{
+ LTO_FIXUP_TREE (TREE_TYPE (t));
+}
+
+/* Fix up fields of a tree_common T. */
+
+static void
+lto_ft_common (tree t)
+{
+ lto_ft_typed (t);
+ LTO_FIXUP_TREE (TREE_CHAIN (t));
+}
+
+/* Fix up fields of a decl_minimal T. */
+
+static void
+lto_ft_decl_minimal (tree t)
+{
+ lto_ft_common (t);
+ LTO_FIXUP_TREE (DECL_NAME (t));
+ LTO_FIXUP_TREE (DECL_CONTEXT (t));
+}
+
+/* Fix up fields of a decl_common T. */
+
+static void
+lto_ft_decl_common (tree t)
+{
+ lto_ft_decl_minimal (t);
+ LTO_FIXUP_TREE (DECL_SIZE (t));
+ LTO_FIXUP_TREE (DECL_SIZE_UNIT (t));
+ LTO_FIXUP_TREE (DECL_INITIAL (t));
+ LTO_FIXUP_TREE (DECL_ATTRIBUTES (t));
+ LTO_FIXUP_TREE (DECL_ABSTRACT_ORIGIN (t));
+}
+
+/* Fix up fields of a decl_with_vis T. */
+
+static void
+lto_ft_decl_with_vis (tree t)
+{
+ lto_ft_decl_common (t);
+
+ /* Accessor macro has side-effects, use field-name here. */
+ LTO_FIXUP_TREE (t->decl_with_vis.assembler_name);
+ LTO_FIXUP_TREE (DECL_SECTION_NAME (t));
+}
+
+/* Fix up fields of a decl_non_common T. */
+
+static void
+lto_ft_decl_non_common (tree t)
+{
+ lto_ft_decl_with_vis (t);
+ LTO_FIXUP_TREE (DECL_ARGUMENT_FLD (t));
+ LTO_FIXUP_TREE (DECL_RESULT_FLD (t));
+ LTO_FIXUP_TREE (DECL_VINDEX (t));
+}
+
+/* Fix up fields of a decl_non_common T. */
+
+static void
+lto_ft_function (tree t)
+{
+ lto_ft_decl_non_common (t);
+ LTO_FIXUP_TREE (DECL_FUNCTION_PERSONALITY (t));
+}
+
+/* Fix up fields of a field_decl T. */
+
+static void
+lto_ft_field_decl (tree t)
+{
+ lto_ft_decl_common (t);
+ LTO_FIXUP_TREE (DECL_FIELD_OFFSET (t));
+ LTO_FIXUP_TREE (DECL_BIT_FIELD_TYPE (t));
+ LTO_FIXUP_TREE (DECL_QUALIFIER (t));
+ LTO_FIXUP_TREE (DECL_FIELD_BIT_OFFSET (t));
+ LTO_FIXUP_TREE (DECL_FCONTEXT (t));
+}
+
+/* Fix up fields of a type T. */
+
+static void
+lto_ft_type (tree t)
+{
+ lto_ft_common (t);
+ LTO_FIXUP_TREE (TYPE_CACHED_VALUES (t));
+ LTO_FIXUP_TREE (TYPE_SIZE (t));
+ LTO_FIXUP_TREE (TYPE_SIZE_UNIT (t));
+ LTO_FIXUP_TREE (TYPE_ATTRIBUTES (t));
+ LTO_FIXUP_TREE (TYPE_NAME (t));
+
+ /* Accessors are for derived node types only. */
+ if (!POINTER_TYPE_P (t))
+ LTO_FIXUP_TREE (TYPE_MINVAL (t));
+ LTO_FIXUP_TREE (TYPE_MAXVAL (t));
+
+ /* Accessor is for derived node types only. */
+ LTO_FIXUP_TREE (t->type_non_common.binfo);
+
+ LTO_FIXUP_TREE (TYPE_CONTEXT (t));
+}
+
+/* Fix up fields of a BINFO T. */
+
+static void
+lto_ft_binfo (tree t)
+{
+ unsigned HOST_WIDE_INT i, n;
+ tree base, saved_base;
+
+ lto_ft_common (t);
+ LTO_FIXUP_TREE (BINFO_VTABLE (t));
+ LTO_FIXUP_TREE (BINFO_OFFSET (t));
+ LTO_FIXUP_TREE (BINFO_VIRTUALS (t));
+ LTO_FIXUP_TREE (BINFO_VPTR_FIELD (t));
+ n = VEC_length (tree, BINFO_BASE_ACCESSES (t));
+ for (i = 0; i < n; i++)
+ {
+ saved_base = base = BINFO_BASE_ACCESS (t, i);
+ LTO_FIXUP_TREE (base);
+ if (base != saved_base)
+ VEC_replace (tree, BINFO_BASE_ACCESSES (t), i, base);
+ }
+ LTO_FIXUP_TREE (BINFO_INHERITANCE_CHAIN (t));
+ LTO_FIXUP_TREE (BINFO_SUBVTT_INDEX (t));
+ LTO_FIXUP_TREE (BINFO_VPTR_INDEX (t));
+ n = BINFO_N_BASE_BINFOS (t);
+ for (i = 0; i < n; i++)
+ {
+ saved_base = base = BINFO_BASE_BINFO (t, i);
+ LTO_FIXUP_TREE (base);
+ if (base != saved_base)
+ VEC_replace (tree, BINFO_BASE_BINFOS (t), i, base);
+ }
+}
+
+/* Fix up fields of a CONSTRUCTOR T. */
+
+static void
+lto_ft_constructor (tree t)
+{
+ unsigned HOST_WIDE_INT idx;
+ constructor_elt *ce;
+
+ lto_ft_typed (t);
+
+ for (idx = 0;
+ VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (t), idx, ce);
+ idx++)
+ {
+ LTO_FIXUP_TREE (ce->index);
+ LTO_FIXUP_TREE (ce->value);
+ }
+}
+
+/* Fix up fields of an expression tree T. */
+
+static void
+lto_ft_expr (tree t)
+{
+ int i;
+ lto_ft_typed (t);
+ for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
+ LTO_FIXUP_TREE (TREE_OPERAND (t, i));
+}
+
+/* Given a tree T fixup fields of T by replacing types with their merged
+ variant and other entities by an equal entity from an earlier compilation
+ unit, or an entity being canonical in a different way. This includes
+ for instance integer or string constants. */
+
+static void
+lto_fixup_types (tree t)
+{
+ switch (TREE_CODE (t))
+ {
+ case IDENTIFIER_NODE:
+ break;
+
+ case TREE_LIST:
+ LTO_FIXUP_TREE (TREE_VALUE (t));
+ LTO_FIXUP_TREE (TREE_PURPOSE (t));
+ LTO_FIXUP_TREE (TREE_CHAIN (t));
+ break;
+
+ case FIELD_DECL:
+ lto_ft_field_decl (t);
+ break;
+
+ case LABEL_DECL:
+ case CONST_DECL:
+ case PARM_DECL:
+ case RESULT_DECL:
+ case IMPORTED_DECL:
+ lto_ft_decl_common (t);
+ break;
+
+ case VAR_DECL:
+ lto_ft_decl_with_vis (t);
+ break;
+
+ case TYPE_DECL:
+ lto_ft_decl_non_common (t);
+ break;
+
+ case FUNCTION_DECL:
+ lto_ft_function (t);
+ break;
+
+ case TREE_BINFO:
+ lto_ft_binfo (t);
+ break;
+
+ case PLACEHOLDER_EXPR:
+ lto_ft_common (t);
+ break;
+
+ case BLOCK:
+ case TRANSLATION_UNIT_DECL:
+ case OPTIMIZATION_NODE:
+ case TARGET_OPTION_NODE:
+ break;
+
+ default:
+ if (TYPE_P (t))
+ lto_ft_type (t);
+ else if (TREE_CODE (t) == CONSTRUCTOR)
+ lto_ft_constructor (t);
+ else if (CONSTANT_CLASS_P (t))
+ LTO_FIXUP_TREE (TREE_TYPE (t));
+ else if (EXPR_P (t))
+ {
+ lto_ft_expr (t);
+ }
+ else
+ {
+ remember_with_vars (t);
+ }
+ }
+}
+
+
+/* Return the resolution for the decl with index INDEX from DATA_IN. */
+
+static enum ld_plugin_symbol_resolution
+get_resolution (struct data_in *data_in, unsigned index)
+{
+ if (data_in->globals_resolution)
+ {
+ ld_plugin_symbol_resolution_t ret;
+ /* We can have references to not emitted functions in
+ DECL_FUNCTION_PERSONALITY at least. So we can and have
+ to indeed return LDPR_UNKNOWN in some cases. */
+ if (VEC_length (ld_plugin_symbol_resolution_t,
+ data_in->globals_resolution) <= index)
+ return LDPR_UNKNOWN;
+ ret = VEC_index (ld_plugin_symbol_resolution_t,
+ data_in->globals_resolution,
+ index);
+ return ret;
+ }
+ else
+ /* Delay resolution finding until decl merging. */
+ return LDPR_UNKNOWN;
+}
+
+
+/* Register DECL with the global symbol table and change its
+ name if necessary to avoid name clashes for static globals across
+ different files. */
+
+static void
+lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
+{
+ tree context;
+
+ /* Variable has file scope, not local. Need to ensure static variables
+ between different files don't clash unexpectedly. */
+ if (!TREE_PUBLIC (decl)
+ && !((context = decl_function_context (decl))
+ && auto_var_in_fn_p (decl, context)))
+ {
+ /* ??? We normally pre-mangle names before we serialize them
+ out. Here, in lto1, we do not know the language, and
+ thus cannot do the mangling again. Instead, we just
+ append a suffix to the mangled name. The resulting name,
+ however, is not a properly-formed mangled name, and will
+ confuse any attempt to unmangle it. */
+ const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
+ char *label;
+
+ ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
+ rest_of_decl_compilation (decl, 1, 0);
+ VEC_safe_push (tree, gc, lto_global_var_decls, decl);
+ }
+
+ /* If this variable has already been declared, queue the
+ declaration for merging. */
+ if (TREE_PUBLIC (decl))
+ {
+ unsigned ix;
+ if (!streamer_tree_cache_lookup (data_in->reader_cache, decl, &ix))
+ gcc_unreachable ();
+ lto_symtab_register_decl (decl, get_resolution (data_in, ix),
+ data_in->file_data);
+ }
+}
+
+
+/* Register DECL with the global symbol table and change its
+ name if necessary to avoid name clashes for static globals across
+ different files. DATA_IN contains descriptors and tables for the
+ file being read. */
+
+static void
+lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
+{
+ /* Need to ensure static entities between different files
+ don't clash unexpectedly. */
+ if (!TREE_PUBLIC (decl))
+ {
+ /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
+ may set the assembler name where it was previously empty. */
+ tree old_assembler_name = decl->decl_with_vis.assembler_name;
+
+ /* FIXME lto: We normally pre-mangle names before we serialize
+ them out. Here, in lto1, we do not know the language, and
+ thus cannot do the mangling again. Instead, we just append a
+ suffix to the mangled name. The resulting name, however, is
+ not a properly-formed mangled name, and will confuse any
+ attempt to unmangle it. */
+ const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
+ char *label;
+
+ ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
+
+ /* We may arrive here with the old assembler name not set
+ if the function body is not needed, e.g., it has been
+ inlined away and does not appear in the cgraph. */
+ if (old_assembler_name)
+ {
+ tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
+
+ /* Make the original assembler name available for later use.
+ We may have used it to indicate the section within its
+ object file where the function body may be found.
+ FIXME lto: Find a better way to maintain the function decl
+ to body section mapping so we don't need this hack. */
+ lto_record_renamed_decl (data_in->file_data,
+ IDENTIFIER_POINTER (old_assembler_name),
+ IDENTIFIER_POINTER (new_assembler_name));
+
+ /* Also register the reverse mapping so that we can find the
+ new name given to an existing assembler name (used when
+ restoring alias pairs in input_constructors_or_inits. */
+ lto_record_renamed_decl (data_in->file_data,
+ IDENTIFIER_POINTER (new_assembler_name),
+ IDENTIFIER_POINTER (old_assembler_name));
+ }
+ }
+
+ /* If this variable has already been declared, queue the
+ declaration for merging. */
+ if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
+ {
+ unsigned ix;
+ if (!streamer_tree_cache_lookup (data_in->reader_cache, decl, &ix))
+ gcc_unreachable ();
+ lto_symtab_register_decl (decl, get_resolution (data_in, ix),
+ data_in->file_data);
+ }
+}
+
+
+/* Given a streamer cache structure DATA_IN (holding a sequence of trees
+ for one compilation unit) go over all trees starting at index FROM until the
+ end of the sequence and replace fields of those trees, and the trees
+ themself with their canonical variants as per gimple_register_type. */
+
+static void
+uniquify_nodes (struct data_in *data_in, unsigned from)
+{
+ struct streamer_tree_cache_d *cache = data_in->reader_cache;
+ unsigned len = VEC_length (tree, cache->nodes);
+ unsigned i;
+
+ /* Go backwards because children streamed for the first time come
+ as part of their parents, and hence are created after them. */
+
+ /* First register all the types in the cache. This makes sure to
+ have the original structure in the type cycles when registering
+ them and computing hashes. */
+ for (i = len; i-- > from;)
+ {
+ tree t = VEC_index (tree, cache->nodes, i);
+ if (t && TYPE_P (t))
+ gimple_register_type (t);
+ }
+
+ /* Second fixup all trees in the new cache entries. */
+ for (i = len; i-- > from;)
+ {
+ tree t = VEC_index (tree, cache->nodes, i);
+ tree oldt = t;
+ if (!t)
+ continue;
+
+ /* First fixup the fields of T. */
+ lto_fixup_types (t);
+
+ if (!TYPE_P (t))
+ continue;
+
+ /* Now try to find a canonical variant of T itself. */
+ t = gimple_register_type (t);
+
+ if (t == oldt)
+ {
+ /* The following re-creates proper variant lists while fixing up
+ the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
+ variant list state before fixup is broken. */
+ tree tem, mv;
+
+ /* Remove us from our main variant list if we are not the
+ variant leader. */
+ if (TYPE_MAIN_VARIANT (t) != t)
+ {
+ tem = TYPE_MAIN_VARIANT (t);
+ while (tem && TYPE_NEXT_VARIANT (tem) != t)
+ tem = TYPE_NEXT_VARIANT (tem);
+ if (tem)
+ TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
+ TYPE_NEXT_VARIANT (t) = NULL_TREE;
+ }
+
+ /* Query our new main variant. */
+ mv = gimple_register_type (TYPE_MAIN_VARIANT (t));
+
+ /* If we were the variant leader and we get replaced ourselves drop
+ all variants from our list. */
+ if (TYPE_MAIN_VARIANT (t) == t
+ && mv != t)
+ {
+ tem = t;
+ while (tem)
+ {
+ tree tem2 = TYPE_NEXT_VARIANT (tem);
+ TYPE_NEXT_VARIANT (tem) = NULL_TREE;
+ tem = tem2;
+ }
+ }
+
+ /* If we are not our own variant leader link us into our new leaders
+ variant list. */
+ if (mv != t)
+ {
+ TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
+ TYPE_NEXT_VARIANT (mv) = t;
+ if (RECORD_OR_UNION_TYPE_P (t))
+ TYPE_BINFO (t) = TYPE_BINFO (mv);
+ }
+
+ /* Finally adjust our main variant and fix it up. */
+ TYPE_MAIN_VARIANT (t) = mv;
+
+ /* The following reconstructs the pointer chains
+ of the new pointed-to type if we are a main variant. We do
+ not stream those so they are broken before fixup. */
+ if (TREE_CODE (t) == POINTER_TYPE
+ && TYPE_MAIN_VARIANT (t) == t)
+ {
+ TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (TREE_TYPE (t));
+ TYPE_POINTER_TO (TREE_TYPE (t)) = t;
+ }
+ else if (TREE_CODE (t) == REFERENCE_TYPE
+ && TYPE_MAIN_VARIANT (t) == t)
+ {
+ TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (TREE_TYPE (t));
+ TYPE_REFERENCE_TO (TREE_TYPE (t)) = t;
+ }
+ }
+
+ else
+ {
+ if (RECORD_OR_UNION_TYPE_P (t))
+ {
+ tree f1, f2;
+ if (TYPE_FIELDS (t) != TYPE_FIELDS (oldt))
+ for (f1 = TYPE_FIELDS (t), f2 = TYPE_FIELDS (oldt);
+ f1 && f2; f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
+ {
+ unsigned ix;
+ gcc_assert (f1 != f2 && DECL_NAME (f1) == DECL_NAME (f2));
+ if (!streamer_tree_cache_lookup (cache, f2, &ix))
+ gcc_unreachable ();
+ /* If we're going to replace an element which we'd
+ still visit in the next iterations, we wouldn't
+ handle it, so do it here. We do have to handle it
+ even though the field_decl itself will be removed,
+ as it could refer to e.g. integer_cst which we
+ wouldn't reach via any other way, hence they
+ (and their type) would stay uncollected. */
+ /* ??? We should rather make sure to replace all
+ references to f2 with f1. That means handling
+ COMPONENT_REFs and CONSTRUCTOR elements in
+ lto_fixup_types and special-case the field-decl
+ operand handling. */
+ if (ix < i)
+ lto_fixup_types (f2);
+ streamer_tree_cache_insert_at (cache, f1, ix);
+ }
+ }
+
+ /* If we found a tree that is equal to oldt replace it in the
+ cache, so that further users (in the various LTO sections)
+ make use of it. */
+ streamer_tree_cache_insert_at (cache, t, i);
+ }
+ }
+
+ /* Finally compute the canonical type of all TREE_TYPEs and register
+ VAR_DECL and FUNCTION_DECL nodes in the symbol table.
+ From this point there are no longer any types with
+ TYPE_STRUCTURAL_EQUALITY_P and its type-based alias problems.
+ This step requires the TYPE_POINTER_TO lists being present, so
+ make sure it is done last. */
+ for (i = len; i-- > from;)
+ {
+ tree t = VEC_index (tree, cache->nodes, i);
+ if (t == NULL_TREE)
+ continue;
+
+ if (TREE_CODE (t) == VAR_DECL)
+ lto_register_var_decl_in_symtab (data_in, t);
+ else if (TREE_CODE (t) == FUNCTION_DECL && !DECL_BUILT_IN (t))
+ lto_register_function_decl_in_symtab (data_in, t);
+ else if (TYPE_P (t) && !TYPE_CANONICAL (t))
+ TYPE_CANONICAL (t) = gimple_register_canonical_type (t);
+ }
+}
+
/* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
RESOLUTIONS is the set of symbols picked by the linker (read from the
/* Read the global declarations and types. */
while (ib_main.p < ib_main.len)
{
- tree t = lto_input_tree (&ib_main, data_in);
+ tree t;
+ unsigned from = VEC_length (tree, data_in->reader_cache->nodes);
+ t = stream_read_tree (&ib_main, data_in);
gcc_assert (t && ib_main.p <= ib_main.len);
+ uniquify_nodes (data_in, from);
}
/* Read in lto_in_decl_state objects. */
/* 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++)
{
}
/* 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);
fread (obj_name, sizeof (char), name_len, resolution);
obj_name[name_len] = '\0';
- if (strcmp (obj_name, file->filename) != 0)
+ if (filename_cmp (obj_name, file->filename) != 0)
internal_error ("unexpected file name %s in linker resolution file. "
"Expected %s", obj_name, file->filename);
if (file->offset != 0)
{
int t;
unsigned index;
+ unsigned HOST_WIDE_INT 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)
- internal_error ("Invalid line in the resolution file.");
+ t = fscanf (resolution, "%u " HOST_WIDE_INT_PRINT_HEX_PURE " %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.");
+ internal_error ("invalid resolution in the resolution file");
- VEC_safe_grow_cleared (ld_plugin_symbol_resolution_t, heap, ret,
+ if (!(nd && lto_splay_tree_id_equal_p (nd->key, id)))
+ {
+ nd = lto_splay_tree_lookup (file_ids, id);
+ if (nd == NULL)
+ internal_error ("resolution sub id " HOST_WIDE_INT_PRINT_HEX_PURE
+ " not in object file", id);
+ }
+
+ file_data = (struct lto_file_decl_data *)nd->value;
+ 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 HOST_WIDE_INT *id)
+{
+ const char *s;
+
+ if (strncmp (name, LTO_SECTION_NAME_PREFIX, strlen (LTO_SECTION_NAME_PREFIX)))
+ return 0;
+ s = strrchr (name, '.');
+ return s && sscanf (s, "." HOST_WIDE_INT_PRINT_HEX_PURE, 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 HOST_WIDE_INT 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 = lto_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 ();;
+ lto_splay_tree_insert (file_ids, id, 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);
+ if (data == NULL)
+ {
+ internal_error ("cannot read LTO decls from %s", file_data->file_name);
+ return;
+ }
+ 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 " HOST_WIDE_INT_PRINT_HEX "\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 = 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->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 = lto_splay_tree_new ();
+ 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;
}
or rather fix function body streaming to not stream them in
practically random order. */
if (fd != -1
- && strcmp (fd_name, file_data->file_name) != 0)
+ && filename_cmp (fd_name, file_data->file_name) != 0)
{
free (fd_name);
close (fd);
}
if (fd == -1)
{
- fd_name = xstrdup (file_data->file_name);
fd = open (file_data->file_name, O_RDONLY|O_BINARY);
if (fd == -1)
return NULL;
+ fd_name = xstrdup (file_data->file_name);
}
#if LTO_MMAP_IO
|| read (fd, result, len) != (ssize_t) len)
{
free (result);
- return NULL;
+ result = NULL;
}
-
+#ifdef __MINGW32__
+ /* Native windows doesn't supports delayed unlink on opened file. So
+ we close file here again. This produces higher I/O load, but at least
+ it prevents to have dangling file handles preventing unlink. */
+ free (fd_name);
+ fd_name = NULL;
+ close (fd);
+ fd = -1;
+#endif
return result;
#endif
}
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;
s_slot.name = section_name;
f_slot = (struct lto_section_slot *) htab_find (section_hash_table, &s_slot);
- if (f_slot)
- {
- data = lto_read_section_data (file_data, f_slot->start, f_slot->len);
- *len = f_slot->len;
- }
-
- free (CONST_CAST (char *, section_name));
- return data;
-}
-
-
-/* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
- starts at OFFSET and has LEN bytes. */
-
-static void
-free_section_data (struct lto_file_decl_data *file_data ATTRIBUTE_UNUSED,
- enum lto_section_type section_type ATTRIBUTE_UNUSED,
- const char *name ATTRIBUTE_UNUSED,
- const char *offset, size_t len ATTRIBUTE_UNUSED)
-{
-#if LTO_MMAP_IO
- intptr_t computed_len;
- intptr_t computed_offset;
- intptr_t diff;
-#endif
-
-#if LTO_MMAP_IO
- computed_offset = ((intptr_t) offset) & page_mask;
- diff = (intptr_t) offset - computed_offset;
- computed_len = len + diff;
-
- munmap ((caddr_t) computed_offset, computed_len);
-#else
- free (CONST_CAST(char *, offset));
-#endif
-}
-
-/* Vector of all cgraph node sets. */
-static GTY (()) VEC(cgraph_node_set, gc) *lto_cgraph_node_sets;
-
-
-/* Group cgrah nodes by input files. This is used mainly for testing
- right now. */
-
-static void
-lto_1_to_1_map (void)
-{
- struct cgraph_node *node;
- struct lto_file_decl_data *file_data;
- struct pointer_map_t *pmap;
- cgraph_node_set set;
- 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;
- }
-
- pmap = 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)
- 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)
- continue;
-
- slot = pointer_map_contains (pmap, file_data);
- if (slot)
- set = (cgraph_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);
- }
-
- cgraph_node_set_add (set, node);
+ if (f_slot)
+ {
+ data = lto_read_section_data (file_data, f_slot->start, f_slot->len);
+ *len = f_slot->len;
}
- pointer_map_destroy (pmap);
-
-finish:
- timevar_pop (TV_WHOPR_WPA);
-
- lto_stats.num_cgraph_partitions += VEC_length (cgraph_node_set,
- lto_cgraph_node_sets);
+ free (CONST_CAST (char *, section_name));
+ return data;
}
-/* Add inlined clone NODE and its master clone to SET, if NODE itself has
- inlined callees, recursively add the callees. */
+/* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
+ starts at OFFSET and has LEN bytes. */
static void
-lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node,
- bitmap original_decls)
+free_section_data (struct lto_file_decl_data *file_data ATTRIBUTE_UNUSED,
+ enum lto_section_type section_type ATTRIBUTE_UNUSED,
+ const char *name ATTRIBUTE_UNUSED,
+ const char *offset, size_t len ATTRIBUTE_UNUSED)
{
- struct cgraph_node *callee;
- struct cgraph_edge *edge;
+#if LTO_MMAP_IO
+ intptr_t computed_len;
+ intptr_t computed_offset;
+ intptr_t diff;
+#endif
- cgraph_node_set_add (set, node);
+#if LTO_MMAP_IO
+ computed_offset = ((intptr_t) offset) & page_mask;
+ diff = (intptr_t) offset - computed_offset;
+ computed_len = len + diff;
- /* 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);
- }
+ munmap ((caddr_t) computed_offset, computed_len);
+#else
+ free (CONST_CAST(char *, offset));
+#endif
}
-/* 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. */
+/* Structure describing ltrans partitions. */
-static void
-lto_add_all_inlinees (cgraph_node_set set)
+struct ltrans_partition_def
{
- cgraph_node_set_iterator csi;
- struct cgraph_node *node;
- bitmap original_nodes = lto_bitmap_alloc ();
- bitmap original_decls = lto_bitmap_alloc ();
- bool changed;
+ cgraph_node_set cgraph_set;
+ varpool_node_set varpool_set;
+ const char * name;
+ int insns;
+};
- /* 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);
+typedef struct ltrans_partition_def *ltrans_partition;
+DEF_VEC_P(ltrans_partition);
+DEF_VEC_ALLOC_P(ltrans_partition,heap);
- /* NODE was not inlined. We still need it. */
- if (!node->global.inlined_to)
- continue;
+static VEC(ltrans_partition, heap) *ltrans_partitions;
- inlined_to = node->global.inlined_to;
+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);
- /* NODE should have only one caller. */
- gcc_assert (!node->callers->next_caller);
+/* Create new partition with name NAME. */
+static ltrans_partition
+new_partition (const char *name)
+{
+ ltrans_partition part = XCNEW (struct 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, heap, ltrans_partitions, part);
+ return part;
+}
- if (!bitmap_bit_p (original_nodes, inlined_to->uid))
- {
- bitmap_clear_bit (original_nodes, node->uid);
- cgraph_node_set_remove (set, node);
- changed = true;
- }
- }
+/* Free memory used by ltrans datastructures. */
+static void
+free_ltrans_partitions (void)
+{
+ unsigned int idx;
+ ltrans_partition part;
+ for (idx = 0; VEC_iterate (ltrans_partition, ltrans_partitions, idx, part); idx++)
+ {
+ free_cgraph_node_set (part->cgraph_set);
+ free (part);
}
- 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);
+ VEC_free (ltrans_partition, heap, ltrans_partitions);
}
-/* 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:
-
- 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
+/* 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)
{
- /* 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;
+ 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 (cgraph_function_node (ipa_ref_node (ref), NULL)->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));
+ }
+}
-/* 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. */
+/* Worker for add_cgraph_node_to_partition. */
-static tree
-globalize_cross_file_statics (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
- void *data)
+static bool
+add_cgraph_node_to_partition_1 (struct cgraph_node *node, void *data)
{
- globalize_context_t *context = (globalize_context_t *) data;
- tree t = *tp;
+ ltrans_partition part = (ltrans_partition) data;
- 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)
+ /* non-COMDAT aliases of COMDAT functions needs to be output just once. */
+ if (!DECL_COMDAT (node->decl)
+ && !node->global.inlined_to
+ && node->aux)
{
- 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);
+ gcc_assert (node->thunk.thunk_p || node->alias);
+ return false;
}
- else if (TREE_CODE (t) == FUNCTION_DECL && !TREE_PUBLIC (t))
+
+ if (node->aux)
{
- if (!cgraph_node_in_set_p (cgraph_node (t), context->set))
- {
- /* 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;
- }
+ node->in_other_partition = 1;
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file, "Node %s/%i now used in multiple partitions\n",
+ cgraph_node_name (node), node->uid);
}
-
- return NULL;
+ node->aux = (void *)((size_t)node->aux + 1);
+ cgraph_node_set_add (part->cgraph_set, node);
+ return false;
}
-/* 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. */
+/* Add NODE to partition as well as the inline callees and referred comdats into partition PART. */
static void
-lto_scan_statics_in_ref_table (struct lto_tree_ref_table *table,
- globalize_context_t *context)
+add_cgraph_node_to_partition (ltrans_partition part, struct cgraph_node *node)
{
- unsigned i;
-
- for (i = 0; i < table->size; i++)
- walk_tree (&table->trees[i], globalize_cross_file_statics, context,
- context->visited);
-}
+ struct cgraph_edge *e;
+ cgraph_node_set_iterator csi;
+ struct cgraph_node *n;
-/* Promote file-scope decl reachable from NODE if necessary to global.
- CONTEXT is a globalize_context_t storing scanning states. */
+ /* We always decide on functions, not associated thunks and aliases. */
+ node = cgraph_function_node (node, NULL);
-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)))
+ /* If NODE is already there, we have nothing to do. */
+ csi = cgraph_node_set_find (part->cgraph_set, node);
+ if (!csi_end_p (csi))
return;
- bitmap_set_bit (context->seen_node_decls, DECL_UID (node->decl));
+ cgraph_for_node_thunks_and_aliases (node, add_cgraph_node_to_partition_1, part, true);
- state = lto_get_function_in_decl_state (node->local.lto_file_data,
- node->decl);
- gcc_assert (state);
+ part->insns += inline_summary (node)->self_size;
- 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. */
+ cgraph_node_set_add (part->cgraph_set, node);
-static void
-lto_scan_statics_in_remaining_global_vars (globalize_context_t *context)
-{
- tree var, var_context;
- struct varpool_node *vnode;
+ for (e = node->callees; e; e = e->next_callee)
+ if ((!e->inline_failed
+ || DECL_COMDAT (cgraph_function_node (e->callee, NULL)->decl))
+ && !cgraph_node_in_set_p (e->callee, part->cgraph_set))
+ add_cgraph_node_to_partition (part, e->callee);
- 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);
- }
+ add_references_to_partition (part, &node->ref_list);
+
+ if (node->same_comdat_group)
+ for (n = node->same_comdat_group; n != node; n = n->same_comdat_group)
+ add_cgraph_node_to_partition (part, n);
}
-/* Find out all static decls that need to be promoted to global because
- of cross file sharing. This function must be run in the WPA mode after
- all inlinees are added. */
+/* Add VNODE to partition as well as comdat references partition PART. */
static void
-lto_promote_cross_file_statics (void)
+add_varpool_node_to_partition (ltrans_partition part, struct varpool_node *vnode)
{
- unsigned i, n_sets;
- cgraph_node_set set;
- cgraph_node_set_iterator csi;
- globalize_context_t context;
+ varpool_node_set_iterator vsi;
- memset (&context, 0, sizeof (context));
- context.all_vars = lto_bitmap_alloc ();
- context.all_static_vars = lto_bitmap_alloc ();
+ /* If NODE is already there, we have nothing to do. */
+ vsi = varpool_node_set_find (part->varpool_set, vnode);
+ if (!vsi_end_p (vsi))
+ return;
- n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets);
- for (i = 0; i < n_sets; i++)
+ varpool_node_set_add (part->varpool_set, vnode);
+
+ if (vnode->aux)
{
- 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 ();
+ vnode->in_other_partition = 1;
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file, "Varpool node %s now used in multiple partitions\n",
+ varpool_node_name (vnode));
+ }
+ vnode->aux = (void *)((size_t)vnode->aux + 1);
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
- lto_scan_statics_in_cgraph_node (csi_node (csi), &context);
+ add_references_to_partition (part, &vnode->ref_list);
- if (i == n_sets - 1)
- lto_scan_statics_in_remaining_global_vars (&context);
+ 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);
+}
- bitmap_ior_into (context.all_static_vars, context.static_vars_in_set);
+/* Undo all additions until number of cgraph nodes in PARITION is N_CGRAPH_NODES
+ and number of varpool nodes is N_VARPOOL_NODES. */
- pointer_set_destroy (context.visited);
- lto_bitmap_free (context.static_vars_in_set);
- lto_bitmap_free (context.seen_node_decls);
+static void
+undo_partition (ltrans_partition partition, unsigned int n_cgraph_nodes,
+ unsigned int n_varpool_nodes)
+{
+ while (VEC_length (cgraph_node_ptr, partition->cgraph_set->nodes) >
+ n_cgraph_nodes)
+ {
+ struct cgraph_node *node = VEC_index (cgraph_node_ptr,
+ partition->cgraph_set->nodes,
+ n_cgraph_nodes);
+ partition->insns -= inline_summary (node)->self_size;
+ cgraph_node_set_remove (partition->cgraph_set, node);
+ node->aux = (void *)((size_t)node->aux - 1);
+ }
+ while (VEC_length (varpool_node_ptr, partition->varpool_set->nodes) >
+ n_varpool_nodes)
+ {
+ struct varpool_node *node = VEC_index (varpool_node_ptr,
+ partition->varpool_set->nodes,
+ n_varpool_nodes);
+ varpool_node_set_remove (partition->varpool_set, node);
+ node->aux = (void *)((size_t)node->aux - 1);
}
-
- lto_bitmap_free (context.all_vars);
- lto_bitmap_free (context.all_static_vars);
}
+/* Return true if NODE should be partitioned.
+ This means that partitioning algorithm should put NODE into one of partitions.
+ This apply to most functions with bodies. Functions that are not partitions
+ are put into every unit needing them. This is the case of i.e. COMDATs. */
-/* Given a file name FNAME, return a string with FNAME prefixed with '*'. */
-
-static char *
-prefix_name_with_star (const char *fname)
+static bool
+partition_cgraph_node_p (struct cgraph_node *node)
{
- 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;
+ /* We will get proper partition based on function they are inlined to. */
+ if (node->global.inlined_to)
+ return false;
+ /* Nodes without a body do not need partitioning. */
+ if (!node->analyzed)
+ return false;
+ /* Extern inlines and comdat are always only in partitions they are needed. */
+ if (DECL_EXTERNAL (node->decl)
+ || (DECL_COMDAT (node->decl)
+ && !cgraph_used_from_object_file_p (node)))
+ return false;
+ if (lookup_attribute ("weakref", DECL_ATTRIBUTES (node->decl)))
+ return false;
+ return true;
}
+/* Return true if VNODE should be partitioned.
+ This means that partitioning algorithm should put VNODE into one of partitions. */
-/* Return a copy of FNAME without the .o extension. */
-
-static char *
-strip_extension (const char *fname)
+static bool
+partition_varpool_node_p (struct varpool_node *vnode)
{
- char *s = XNEWVEC (char, strlen (fname) - 2 + 1);
- gcc_assert (strstr (fname, ".o"));
- snprintf (s, strlen (fname) - 2 + 1, "%s", fname);
-
- return s;
+ if (vnode->alias || !vnode->needed)
+ return false;
+ /* Constant pool and comdat are always only in partitions they are needed. */
+ if (DECL_IN_CONSTANT_POOL (vnode->decl)
+ || (DECL_COMDAT (vnode->decl)
+ && !vnode->force_output
+ && !varpool_used_from_object_file_p (vnode)))
+ return false;
+ if (lookup_attribute ("weakref", DECL_ATTRIBUTES (vnode->decl)))
+ return false;
+ return true;
}
+/* Group cgrah nodes by input files. This is used mainly for testing
+ right now. */
-/* 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. */
-
-static char *
-get_filename_for_set (cgraph_node_set set)
+static void
+lto_1_to_1_map (void)
{
- char *fname = NULL;
- static const size_t max_fname_len = 100;
+ struct cgraph_node *node;
+ struct varpool_node *vnode;
+ struct lto_file_decl_data *file_data;
+ struct pointer_map_t *pmap;
+ ltrans_partition partition;
+ void **slot;
+ int npartitions = 0;
- 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))
- {
- struct cgraph_node *n = csi_node (si);
- const char *node_fname;
- char *f;
+ timevar_push (TV_WHOPR_WPA);
- /* Don't use the same file name more than once. */
- if (pointer_set_insert (pset, n->local.lto_file_data))
- continue;
+ pmap = pointer_map_create ();
- /* 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;
- }
+ for (node = cgraph_nodes; node; node = node->next)
+ {
+ if (!partition_cgraph_node_p (node)
+ || node->aux)
+ continue;
- f = strip_extension (lbasename (node_fname));
+ file_data = node->local.lto_file_data;
- /* 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;
- }
+ if (file_data)
+ {
+ slot = pointer_map_contains (pmap, file_data);
+ if (slot)
+ partition = (ltrans_partition) *slot;
else
{
- fname = reconcat (fname, fname, "_", f, NULL);
- free (f);
+ partition = new_partition (file_data->file_name);
+ slot = pointer_map_insert (pmap, file_data);
+ *slot = partition;
+ npartitions++;
}
}
+ else if (!file_data
+ && VEC_length (ltrans_partition, ltrans_partitions))
+ partition = VEC_index (ltrans_partition, ltrans_partitions, 0);
+ else
+ {
+ partition = new_partition ("");
+ slot = pointer_map_insert (pmap, NULL);
+ *slot = partition;
+ npartitions++;
+ }
- 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
- {
- /* 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);
+ add_cgraph_node_to_partition (partition, node);
}
- return fname;
-}
-
-static lto_file *current_lto_file;
-
-
-/* Write all output files in WPA mode. Returns a NULL-terminated array of
- output file names. */
-
-static char **
-lto_wpa_write_files (void)
-{
- char **output_files;
- unsigned i, n_sets, last_out_file_ix, num_out_files;
- lto_file *file;
- cgraph_node_set set;
-
- timevar_push (TV_WHOPR_WPA);
-
- /* Include all inlined functions and determine what sets need to be
- 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++)
+ for (vnode = varpool_nodes; vnode; vnode = vnode->next)
{
- lto_add_all_inlinees (set);
- lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr,
- set->nodes);
- }
-
- /* After adding all inlinees, find out statics that need to be promoted
- to globals because of cross-file inlining. */
- lto_promote_cross_file_statics ();
-
- timevar_pop (TV_WHOPR_WPA);
+ if (!partition_varpool_node_p (vnode)
+ || vnode->aux)
+ continue;
+ file_data = vnode->lto_file_data;
+ slot = pointer_map_contains (pmap, file_data);
+ if (slot)
+ partition = (ltrans_partition) *slot;
+ else
+ {
+ partition = new_partition (file_data->file_name);
+ slot = pointer_map_insert (pmap, file_data);
+ *slot = partition;
+ npartitions++;
+ }
- timevar_push (TV_WHOPR_WPA_IO);
+ 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;
- /* 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);
+ /* 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 (!npartitions)
+ new_partition ("empty");
- n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets);
- for (i = 0; i < n_sets; i++)
- {
- char *temp_filename;
+ pointer_map_destroy (pmap);
- set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i);
- temp_filename = get_filename_for_set (set);
- output_files[i] = temp_filename;
+ timevar_pop (TV_WHOPR_WPA);
- if (cgraph_node_set_needs_ltrans_p (set))
- {
- /* Write all the nodes in SET to TEMP_FILENAME. */
- file = lto_elf_file_open (temp_filename, true);
- if (!file)
- fatal_error ("lto_elf_file_open() failed");
+ lto_stats.num_cgraph_partitions += VEC_length (ltrans_partition,
+ ltrans_partitions);
+}
- lto_set_current_out_file (file);
- ipa_write_summaries_of_cgraph_node_set (set);
+/* Group cgraph nodes into equally-sized partitions.
- lto_set_current_out_file (NULL);
- lto_elf_file_close (file);
- }
- }
+ The partitioning algorithm is simple: nodes are taken in predefined order.
+ The order corresponds to the order we want functions to have in the final
+ output. In the future this will be given by function reordering pass, but
+ at the moment we use the topological order, which is a good approximation.
- last_out_file_ix = n_sets;
+ The goal is to partition this linear order into intervals (partitions) so
+ that all the partitions have approximately the same size and the number of
+ callgraph or IPA reference edges crossing boundaries is minimal.
- lto_stats.num_output_files += n_sets;
+ This is a lot faster (O(n) in size of callgraph) than algorithms doing
+ priority-based graph clustering that are generally O(n^2) and, since
+ WHOPR is designed to make things go well across partitions, it leads
+ to good results.
- output_files[last_out_file_ix] = NULL;
+ We compute the expected size of a partition as:
- timevar_pop (TV_WHOPR_WPA_IO);
+ max (total_size / lto_partitions, min_partition_size)
- return output_files;
-}
+ We use dynamic expected size of partition so small programs are partitioned
+ into enough partitions to allow use of multiple CPUs, while large programs
+ are not partitioned too much. Creating too many partitions significantly
+ increases the streaming overhead.
-/* Template of LTRANS dumpbase suffix. */
-#define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
+ In the future, we would like to bound the maximal size of partitions so as
+ to prevent the LTRANS stage from consuming too much memory. At the moment,
+ however, the WPA stage is the most memory intensive for large benchmarks,
+ since too many types and declarations are read into memory.
-/* 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. */
+ The function implements a simple greedy algorithm. Nodes are being added
+ to the current partition until after 3/4 of the expected partition size is
+ reached. Past this threshold, we keep track of boundary size (number of
+ edges going to other partitions) and continue adding functions until after
+ the current partition has grown to twice the expected partition size. Then
+ the process is undone to the point where the minimal ratio of boundary size
+ and in-partition calls was reached. */
static void
-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;
- 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)
- {
- 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)
+lto_balanced_map (void)
+{
+ int n_nodes = 0;
+ struct cgraph_node **postorder =
+ XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
+ struct cgraph_node **order = XNEWVEC (struct cgraph_node *, cgraph_max_uid);
+ int i, postorder_len;
+ struct cgraph_node *node;
+ int total_size = 0, best_total_size = 0;
+ int partition_size;
+ ltrans_partition partition;
+ unsigned int last_visited_cgraph_node = 0, last_visited_varpool_node = 0;
+ struct varpool_node *vnode;
+ int cost = 0, internal = 0;
+ int best_n_nodes = 0, best_n_varpool_nodes = 0, best_i = 0, best_cost =
+ INT_MAX, best_internal = 0;
+ int npartitions;
+
+ for (vnode = varpool_nodes; vnode; vnode = vnode->next)
+ gcc_assert (!vnode->aux);
+ /* Until we have better ordering facility, use toplogical order.
+ Include only nodes we will partition and compute estimate of program
+ size. Note that since nodes that are not partitioned might be put into
+ multiple partitions, this is just an estimate of real size. This is why
+ we keep partition_size updated after every partition is finalized. */
+ postorder_len = ipa_reverse_postorder (postorder);
+ for (i = 0; i < postorder_len; 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] == '*')
+ node = postorder[i];
+ if (partition_cgraph_node_p (node))
{
- 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);
+ order[n_nodes++] = node;
+ total_size += inline_summary (node)->size;
}
- else
+ }
+ free (postorder);
+
+ /* Compute partition size and create the first partition. */
+ partition_size = total_size / PARAM_VALUE (PARAM_LTO_PARTITIONS);
+ if (partition_size < PARAM_VALUE (MIN_PARTITION_SIZE))
+ partition_size = PARAM_VALUE (MIN_PARTITION_SIZE);
+ npartitions = 1;
+ partition = new_partition ("");
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file, "Total unit size: %i, partition size: %i\n",
+ total_size, partition_size);
+
+ for (i = 0; i < n_nodes; i++)
+ {
+ if (order[i]->aux)
+ continue;
+ add_cgraph_node_to_partition (partition, order[i]);
+ total_size -= inline_summary (order[i])->size;
+
+ /* Once we added a new node to the partition, we also want to add
+ all referenced variables unless they was already added into some
+ earlier partition.
+ add_cgraph_node_to_partition adds possibly multiple nodes and
+ variables that are needed to satisfy needs of ORDER[i].
+ We remember last visited cgraph and varpool node from last iteration
+ of outer loop that allows us to process every new addition.
+
+ At the same time we compute size of the boundary into COST. Every
+ callgraph or IPA reference edge leaving the partition contributes into
+ COST. Every edge inside partition was earlier computed as one leaving
+ it and thus we need to subtract it from COST. */
+ while (last_visited_cgraph_node <
+ VEC_length (cgraph_node_ptr, partition->cgraph_set->nodes)
+ || last_visited_varpool_node < VEC_length (varpool_node_ptr,
+ partition->varpool_set->
+ nodes))
{
- 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;
+ struct ipa_ref_list *refs;
+ int j;
+ struct ipa_ref *ref;
+ bool cgraph_p = false;
- /* 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 (last_visited_cgraph_node <
+ VEC_length (cgraph_node_ptr, partition->cgraph_set->nodes))
{
- if (WIFSIGNALED (status))
+ struct cgraph_edge *edge;
+
+ cgraph_p = true;
+ node = VEC_index (cgraph_node_ptr, partition->cgraph_set->nodes,
+ last_visited_cgraph_node);
+ refs = &node->ref_list;
+
+ last_visited_cgraph_node++;
+
+ gcc_assert (node->analyzed);
+
+ /* Compute boundary cost of callgrpah edges. */
+ for (edge = node->callees; edge; edge = edge->next_callee)
+ if (edge->callee->analyzed)
+ {
+ int edge_cost = edge->frequency;
+ cgraph_node_set_iterator csi;
+
+ if (!edge_cost)
+ edge_cost = 1;
+ gcc_assert (edge_cost > 0);
+ csi = cgraph_node_set_find (partition->cgraph_set, edge->callee);
+ if (!csi_end_p (csi)
+ && csi.index < last_visited_cgraph_node - 1)
+ cost -= edge_cost, internal+= edge_cost;
+ else
+ cost += edge_cost;
+ }
+ for (edge = node->callers; edge; edge = edge->next_caller)
{
- int sig = WTERMSIG (status);
- fatal_error ("%s terminated with signal %d [%s]%s",
- argv[0], sig, strsignal (sig),
- WCOREDUMP (status) ? ", core dumped" : "");
+ int edge_cost = edge->frequency;
+ cgraph_node_set_iterator csi;
+
+ gcc_assert (edge->caller->analyzed);
+ if (!edge_cost)
+ edge_cost = 1;
+ gcc_assert (edge_cost > 0);
+ csi = cgraph_node_set_find (partition->cgraph_set, edge->caller);
+ if (!csi_end_p (csi)
+ && csi.index < last_visited_cgraph_node)
+ cost -= edge_cost;
+ else
+ cost += edge_cost;
}
- else
- fatal_error ("%s terminated with status %d", argv[0], status);
+ }
+ else
+ {
+ refs =
+ &VEC_index (varpool_node_ptr, partition->varpool_set->nodes,
+ last_visited_varpool_node)->ref_list;
+ last_visited_varpool_node++;
}
- pex_free (pex);
+ /* Compute boundary cost of IPA REF edges and at the same time look into
+ variables referenced from current partition and try to add them. */
+ for (j = 0; ipa_ref_list_reference_iterate (refs, j, ref); j++)
+ if (ref->refered_type == IPA_REF_VARPOOL)
+ {
+ varpool_node_set_iterator vsi;
+
+ vnode = ipa_ref_varpool_node (ref);
+ if (!vnode->finalized)
+ continue;
+ if (!vnode->aux && partition_varpool_node_p (vnode))
+ add_varpool_node_to_partition (partition, vnode);
+ vsi = varpool_node_set_find (partition->varpool_set, vnode);
+ if (!vsi_end_p (vsi)
+ && vsi.index < last_visited_varpool_node - !cgraph_p)
+ cost--, internal++;
+ else
+ cost++;
+ }
+ else
+ {
+ cgraph_node_set_iterator csi;
+
+ node = ipa_ref_node (ref);
+ if (!node->analyzed)
+ continue;
+ csi = cgraph_node_set_find (partition->cgraph_set, node);
+ if (!csi_end_p (csi)
+ && csi.index < last_visited_cgraph_node - cgraph_p)
+ cost--, internal++;
+ else
+ cost++;
+ }
+ for (j = 0; ipa_ref_list_refering_iterate (refs, j, ref); j++)
+ if (ref->refering_type == IPA_REF_VARPOOL)
+ {
+ varpool_node_set_iterator vsi;
+
+ vnode = ipa_ref_refering_varpool_node (ref);
+ gcc_assert (vnode->finalized);
+ if (!vnode->aux && partition_varpool_node_p (vnode))
+ add_varpool_node_to_partition (partition, vnode);
+ vsi = varpool_node_set_find (partition->varpool_set, vnode);
+ if (!vsi_end_p (vsi)
+ && vsi.index < last_visited_varpool_node)
+ cost--;
+ else
+ cost++;
+ }
+ else
+ {
+ cgraph_node_set_iterator csi;
+
+ node = ipa_ref_refering_node (ref);
+ gcc_assert (node->analyzed);
+ csi = cgraph_node_set_find (partition->cgraph_set, node);
+ if (!csi_end_p (csi)
+ && csi.index < last_visited_cgraph_node)
+ cost--;
+ else
+ cost++;
+ }
}
- }
-
- /* Close the LTRANS output list. */
- 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);
-}
-
-
-typedef struct {
- struct pointer_set_t *seen;
-} lto_fixup_data_t;
-
-#define LTO_FIXUP_SUBTREE(t) \
- do \
- walk_tree (&(t), lto_fixup_tree, data, NULL); \
- while (0)
-
-#define LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE(t) \
- do \
- { \
- if (t) \
- (t) = gimple_register_type (t); \
- walk_tree (&(t), lto_fixup_tree, data, NULL); \
- } \
- while (0)
-
-static tree lto_fixup_tree (tree *, int *, void *);
-
-/* Return true if T does not need to be fixed up recursively. */
-
-static inline bool
-no_fixup_p (tree t)
-{
- return (t == NULL
- || CONSTANT_CLASS_P (t)
- || TREE_CODE (t) == IDENTIFIER_NODE);
-}
-
-/* Fix up fields of a tree_common T. DATA points to fix-up states. */
-
-static void
-lto_fixup_common (tree t, void *data)
-{
- /* The following re-creates the TYPE_REFERENCE_TO and TYPE_POINTER_TO
- lists. We do not stream TYPE_REFERENCE_TO, TYPE_POINTER_TO or
- TYPE_NEXT_PTR_TO and TYPE_NEXT_REF_TO.
- First remove us from any pointer list we are on. */
- if (TREE_CODE (t) == POINTER_TYPE)
- {
- if (TYPE_POINTER_TO (TREE_TYPE (t)) == t)
- TYPE_POINTER_TO (TREE_TYPE (t)) = TYPE_NEXT_PTR_TO (t);
- else
+
+ /* If the partition is large enough, start looking for smallest boundary cost. */
+ if (partition->insns < partition_size * 3 / 4
+ || best_cost == INT_MAX
+ || ((!cost
+ || (best_internal * (HOST_WIDE_INT) cost
+ > (internal * (HOST_WIDE_INT)best_cost)))
+ && partition->insns < partition_size * 5 / 4))
{
- tree tem = TYPE_POINTER_TO (TREE_TYPE (t));
- while (tem && TYPE_NEXT_PTR_TO (tem) != t)
- tem = TYPE_NEXT_PTR_TO (tem);
- if (tem)
- TYPE_NEXT_PTR_TO (tem) = TYPE_NEXT_PTR_TO (t);
+ best_cost = cost;
+ best_internal = internal;
+ best_i = i;
+ best_n_nodes = VEC_length (cgraph_node_ptr,
+ partition->cgraph_set->nodes);
+ best_n_varpool_nodes = VEC_length (varpool_node_ptr,
+ partition->varpool_set->nodes);
+ best_total_size = total_size;
}
- TYPE_NEXT_PTR_TO (t) = NULL_TREE;
- }
- else if (TREE_CODE (t) == REFERENCE_TYPE)
- {
- if (TYPE_REFERENCE_TO (TREE_TYPE (t)) == t)
- TYPE_REFERENCE_TO (TREE_TYPE (t)) = TYPE_NEXT_REF_TO (t);
- else
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file, "Step %i: added %s/%i, size %i, cost %i/%i best %i/%i, step %i\n", i,
+ cgraph_node_name (order[i]), order[i]->uid, partition->insns, cost, internal,
+ best_cost, best_internal, best_i);
+ /* Partition is too large, unwind into step when best cost was reached and
+ start new partition. */
+ if (partition->insns > 2 * partition_size)
{
- tree tem = TYPE_REFERENCE_TO (TREE_TYPE (t));
- while (tem && TYPE_NEXT_REF_TO (tem) != t)
- tem = TYPE_NEXT_REF_TO (tem);
- if (tem)
- TYPE_NEXT_REF_TO (tem) = TYPE_NEXT_REF_TO (t);
+ if (best_i != i)
+ {
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file, "Unwinding %i insertions to step %i\n",
+ i - best_i, best_i);
+ undo_partition (partition, best_n_nodes, best_n_varpool_nodes);
+ }
+ i = best_i;
+ /* When we are finished, avoid creating empty partition. */
+ while (i < n_nodes - 1 && order[i + 1]->aux)
+ i++;
+ if (i == n_nodes - 1)
+ break;
+ partition = new_partition ("");
+ last_visited_cgraph_node = 0;
+ last_visited_varpool_node = 0;
+ total_size = best_total_size;
+ cost = 0;
+
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file, "New partition\n");
+ best_n_nodes = 0;
+ best_n_varpool_nodes = 0;
+ best_cost = INT_MAX;
+
+ /* Since the size of partitions is just approximate, update the size after
+ we finished current one. */
+ if (npartitions < PARAM_VALUE (PARAM_LTO_PARTITIONS))
+ partition_size = total_size
+ / (PARAM_VALUE (PARAM_LTO_PARTITIONS) - npartitions);
+ else
+ partition_size = INT_MAX;
+
+ if (partition_size < PARAM_VALUE (MIN_PARTITION_SIZE))
+ partition_size = PARAM_VALUE (MIN_PARTITION_SIZE);
+ npartitions ++;
}
- TYPE_NEXT_REF_TO (t) = NULL_TREE;
}
- /* Fixup our type. */
- LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
-
- /* Second put us on the list of pointers of the new pointed-to type
- if we are a main variant. This is done in lto_fixup_type after
- fixing up our main variant. */
-
- /* This is not very efficient because we cannot do tail-recursion with
- a long chain of trees. */
- LTO_FIXUP_SUBTREE (TREE_CHAIN (t));
+ /* Varables that are not reachable from the code go into last partition. */
+ for (vnode = varpool_nodes; vnode; vnode = vnode->next)
+ if (partition_varpool_node_p (vnode) && !vnode->aux)
+ add_varpool_node_to_partition (partition, vnode);
+ free (order);
}
-/* Fix up fields of a decl_minimal T. DATA points to fix-up states. */
+/* Promote variable VNODE to be static. */
-static void
-lto_fixup_decl_minimal (tree t, void *data)
+static bool
+promote_var (struct varpool_node *vnode)
{
- lto_fixup_common (t, data);
- LTO_FIXUP_SUBTREE (DECL_NAME (t));
- LTO_FIXUP_SUBTREE (DECL_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;
+ DECL_VISIBILITY_SPECIFIED (vnode->decl) = true;
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file,
+ "Promoting var as hidden: %s\n", varpool_node_name (vnode));
+ return true;
}
-/* Fix up fields of a decl_common T. DATA points to fix-up states. */
+/* Promote function NODE to be static. */
-static void
-lto_fixup_decl_common (tree t, void *data)
+static bool
+promote_fn (struct cgraph_node *node)
{
- lto_fixup_decl_minimal (t, data);
- LTO_FIXUP_SUBTREE (DECL_SIZE (t));
- LTO_FIXUP_SUBTREE (DECL_SIZE_UNIT (t));
- LTO_FIXUP_SUBTREE (DECL_INITIAL (t));
- LTO_FIXUP_SUBTREE (DECL_ATTRIBUTES (t));
- LTO_FIXUP_SUBTREE (DECL_ABSTRACT_ORIGIN (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;
+ DECL_VISIBILITY_SPECIFIED (node->decl) = true;
+ if (cgraph_dump_file)
+ fprintf (cgraph_dump_file,
+ "Promoting function as hidden: %s/%i\n",
+ cgraph_node_name (node), node->uid);
+ return true;
}
-/* Fix up fields of a decl_with_vis T. DATA points to fix-up states. */
+/* Find out all static decls that need to be promoted to global because
+ of cross file sharing. This function must be run in the WPA mode after
+ all inlinees are added. */
static void
-lto_fixup_decl_with_vis (tree t, void *data)
+lto_promote_cross_file_statics (void)
{
- lto_fixup_decl_common (t, data);
+ 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 ();
- /* Accessor macro has side-effects, use field-name here. */
- LTO_FIXUP_SUBTREE (t->decl_with_vis.assembler_name);
+ gcc_assert (flag_wpa);
- gcc_assert (no_fixup_p (DECL_SECTION_NAME (t)));
-}
+ n_sets = VEC_length (ltrans_partition, ltrans_partitions);
+ for (i = 0; i < n_sets; i++)
+ {
+ ltrans_partition part
+ = VEC_index (ltrans_partition, ltrans_partitions, i);
+ set = part->cgraph_set;
+ vset = part->varpool_set;
-/* Fix up fields of a decl_non_common T. DATA points to fix-up states. */
+ /* If node called or referred to 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) && !DECL_COMDAT (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) && !DECL_COMDAT (vnode->decl)
+ && !vnode->externally_visible && vnode->analyzed
+ && referenced_from_other_partition_p (&vnode->ref_list,
+ set, vset))
+ promote_var (vnode);
+ }
-static void
-lto_fixup_decl_non_common (tree t, void *data)
-{
- lto_fixup_decl_with_vis (t, data);
- LTO_FIXUP_SUBTREE (DECL_ARGUMENT_FLD (t));
- LTO_FIXUP_SUBTREE (DECL_RESULT_FLD (t));
- LTO_FIXUP_SUBTREE (DECL_VINDEX (t));
+ /* We export the initializer of a read-only var into each partition
+ referencing the var. Folding might take declarations from the
+ initializer and use them, so everything referenced from the
+ initializer can be accessed from this partition after folding.
+
+ This means that we need to promote all variables and functions
+ referenced from all initializers of read-only 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 (const_value_known_p (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;
- /* SAVED_TREE should not cleared by now. Also no accessor for base type. */
- gcc_assert (no_fixup_p (t->decl_non_common.saved_tree));
+ 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
+ cannot 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 (!v->externally_visible && v->analyzed)
+ {
+ if (promote_var (v)
+ && DECL_INITIAL (v->decl)
+ && const_value_known_p (v->decl)
+ && !pointer_set_insert (inserted, vnode))
+ VEC_safe_push (varpool_node_ptr, heap,
+ promoted_initializers, v);
+ }
+ }
+ }
+ }
+ }
+ pointer_set_destroy (inserted);
}
-/* Fix up fields of a decl_non_common T. DATA points to fix-up states. */
-
-static void
-lto_fixup_function (tree t, void *data)
-{
- lto_fixup_decl_non_common (t, data);
- LTO_FIXUP_SUBTREE (DECL_FUNCTION_PERSONALITY (t));
-}
+static lto_file *current_lto_file;
-/* Fix up fields of a field_decl T. DATA points to fix-up states. */
+/* 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 void
-lto_fixup_field_decl (tree t, void *data)
+static int
+cmp_partitions (const void *a, const void *b)
{
- lto_fixup_decl_common (t, data);
- LTO_FIXUP_SUBTREE (DECL_FIELD_OFFSET (t));
- LTO_FIXUP_SUBTREE (DECL_BIT_FIELD_TYPE (t));
- LTO_FIXUP_SUBTREE (DECL_QUALIFIER (t));
- gcc_assert (no_fixup_p (DECL_FIELD_BIT_OFFSET (t)));
- LTO_FIXUP_SUBTREE (DECL_FCONTEXT (t));
+ 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;
}
-/* Fix up fields of a type T. DATA points to fix-up states. */
+/* Write all output files in WPA mode and the file with the list of
+ LTRANS units. */
static void
-lto_fixup_type (tree t, void *data)
+lto_wpa_write_files (void)
{
- tree tem, mv;
+ 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;
- lto_fixup_common (t, data);
- LTO_FIXUP_SUBTREE (TYPE_CACHED_VALUES (t));
- LTO_FIXUP_SUBTREE (TYPE_SIZE (t));
- LTO_FIXUP_SUBTREE (TYPE_SIZE_UNIT (t));
- LTO_FIXUP_SUBTREE (TYPE_ATTRIBUTES (t));
- LTO_FIXUP_SUBTREE (TYPE_NAME (t));
+ /* 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);
- /* Accessors are for derived node types only. */
- if (!POINTER_TYPE_P (t))
- LTO_FIXUP_SUBTREE (t->type.minval);
- LTO_FIXUP_SUBTREE (t->type.maxval);
+ timevar_push (TV_WHOPR_WPA);
- /* Accessor is for derived node types only. */
- LTO_FIXUP_SUBTREE (t->type.binfo);
+ FOR_EACH_VEC_ELT (ltrans_partition, ltrans_partitions, i, part)
+ lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr,
+ part->cgraph_set->nodes);
+
+ /* Find out statics that need to be promoted
+ to globals with hidden visibility because they are accessed from multiple
+ partitions. */
+ lto_promote_cross_file_statics ();
- LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CONTEXT (t));
- LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CANONICAL (t));
+ timevar_pop (TV_WHOPR_WPA);
- /* The following re-creates proper variant lists while fixing up
- the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
- variant list state before fixup is broken. */
+ timevar_push (TV_WHOPR_WPA_IO);
- /* Remove us from our main variant list if we are not the variant leader. */
- if (TYPE_MAIN_VARIANT (t) != t)
+ /* 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);
+ VEC_qsort (ltrans_partition, ltrans_partitions, cmp_partitions);
+ for (i = 0; i < n_sets; i++)
{
- tem = TYPE_MAIN_VARIANT (t);
- while (tem && TYPE_NEXT_VARIANT (tem) != t)
- tem = TYPE_NEXT_VARIANT (tem);
- if (tem)
- TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
- TYPE_NEXT_VARIANT (t) = NULL_TREE;
- }
+ size_t len;
+ ltrans_partition part = VEC_index (ltrans_partition, ltrans_partitions, i);
- /* Query our new main variant. */
- mv = gimple_register_type (TYPE_MAIN_VARIANT (t));
+ set = part->cgraph_set;
+ vset = part->varpool_set;
- /* If we were the variant leader and we get replaced ourselves drop
- all variants from our list. */
- if (TYPE_MAIN_VARIANT (t) == t
- && mv != t)
- {
- tem = t;
- while (tem)
+ /* 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");
+
+ if (!quiet_flag)
+ fprintf (stderr, " %s (%s %i insns)", temp_filename, part->name, part->insns);
+ if (cgraph_dump_file)
{
- tree tem2 = TYPE_NEXT_VARIANT (tem);
- TYPE_NEXT_VARIANT (tem) = NULL_TREE;
- tem = tem2;
+ fprintf (cgraph_dump_file, "Writing 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);
}
- }
-
- /* If we are not our own variant leader link us into our new leaders
- variant list. */
- if (mv != t)
- {
- TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
- TYPE_NEXT_VARIANT (mv) = t;
- }
-
- /* Finally adjust our main variant and fix it up. */
- TYPE_MAIN_VARIANT (t) = mv;
- LTO_FIXUP_SUBTREE (TYPE_MAIN_VARIANT (t));
+ gcc_checking_assert (cgraph_node_set_nonempty_p (set)
+ || varpool_node_set_nonempty_p (vset) || !i);
- /* As the second step of reconstructing the pointer chains put us
- on the list of pointers of the new pointed-to type
- if we are a main variant. See lto_fixup_common for the first step. */
- if (TREE_CODE (t) == POINTER_TYPE
- && TYPE_MAIN_VARIANT (t) == t)
- {
- TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (TREE_TYPE (t));
- TYPE_POINTER_TO (TREE_TYPE (t)) = t;
- }
- else if (TREE_CODE (t) == REFERENCE_TYPE
- && TYPE_MAIN_VARIANT (t) == t)
- {
- TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (TREE_TYPE (t));
- TYPE_REFERENCE_TO (TREE_TYPE (t)) = t;
- }
-}
+ lto_set_current_out_file (file);
-/* Fix up fields of a BINFO T. DATA points to fix-up states. */
+ ipa_write_optimization_summaries (set, vset);
-static void
-lto_fixup_binfo (tree t, void *data)
-{
- unsigned HOST_WIDE_INT i, n;
- tree base, saved_base;
+ lto_set_current_out_file (NULL);
+ lto_obj_file_close (file);
- lto_fixup_common (t, data);
- gcc_assert (no_fixup_p (BINFO_OFFSET (t)));
- LTO_FIXUP_SUBTREE (BINFO_VTABLE (t));
- LTO_FIXUP_SUBTREE (BINFO_VIRTUALS (t));
- LTO_FIXUP_SUBTREE (BINFO_VPTR_FIELD (t));
- n = VEC_length (tree, BINFO_BASE_ACCESSES (t));
- for (i = 0; i < n; i++)
- {
- saved_base = base = BINFO_BASE_ACCESS (t, i);
- LTO_FIXUP_SUBTREE (base);
- if (base != saved_base)
- VEC_replace (tree, BINFO_BASE_ACCESSES (t), i, base);
- }
- LTO_FIXUP_SUBTREE (BINFO_INHERITANCE_CHAIN (t));
- LTO_FIXUP_SUBTREE (BINFO_SUBVTT_INDEX (t));
- LTO_FIXUP_SUBTREE (BINFO_VPTR_INDEX (t));
- n = BINFO_N_BASE_BINFOS (t);
- for (i = 0; i < n; i++)
- {
- saved_base = base = BINFO_BASE_BINFO (t, i);
- LTO_FIXUP_SUBTREE (base);
- if (base != saved_base)
- VEC_replace (tree, BINFO_BASE_BINFOS (t), i, base);
+ len = strlen (temp_filename);
+ if (fwrite (temp_filename, 1, len, ltrans_output_list_stream) < len
+ || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1)
+ fatal_error ("writing to LTRANS output list %s: %m",
+ ltrans_output_list);
}
-}
-/* Fix up fields of a CONSTRUCTOR T. DATA points to fix-up states. */
+ lto_stats.num_output_files += n_sets;
-static void
-lto_fixup_constructor (tree t, void *data)
-{
- unsigned HOST_WIDE_INT idx;
- constructor_elt *ce;
+ /* Close the LTRANS output list. */
+ if (fclose (ltrans_output_list_stream))
+ fatal_error ("closing LTRANS output list %s: %m", ltrans_output_list);
- LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
+ free_ltrans_partitions();
- for (idx = 0;
- VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (t), idx, ce);
- idx++)
- {
- LTO_FIXUP_SUBTREE (ce->index);
- LTO_FIXUP_SUBTREE (ce->value);
- }
+ timevar_pop (TV_WHOPR_WPA_IO);
}
-/* A walk_tree callback used by lto_fixup_state. TP is the pointer to the
- current tree. WALK_SUBTREES indicates if the subtrees will be walked.
- DATA is a pointer set to record visited nodes. */
-static tree
-lto_fixup_tree (tree *tp, int *walk_subtrees, void *data)
-{
- tree t;
- lto_fixup_data_t *fixup_data = (lto_fixup_data_t *) data;
- tree prevailing;
+/* If TT is a variable or function decl replace it with its
+ prevailing variant. */
+#define LTO_SET_PREVAIL(tt) \
+ do {\
+ if ((tt) && VAR_OR_FUNCTION_DECL_P (tt)) \
+ tt = lto_symtab_prevailing_decl (tt); \
+ } while (0)
- t = *tp;
- *walk_subtrees = 0;
- if (pointer_set_contains (fixup_data->seen, t))
- return NULL;
+/* Ensure that TT isn't a replacable var of function decl. */
+#define LTO_NO_PREVAIL(tt) \
+ gcc_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
- if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
+/* Given a tree T replace all fields referring to variables or functions
+ with their prevailing variant. */
+static void
+lto_fixup_prevailing_decls (tree t)
+{
+ enum tree_code code = TREE_CODE (t);
+ LTO_NO_PREVAIL (TREE_TYPE (t));
+ if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
+ LTO_NO_PREVAIL (TREE_CHAIN (t));
+ if (DECL_P (t))
{
- prevailing = lto_symtab_prevailing_decl (t);
-
- if (t != prevailing)
+ LTO_NO_PREVAIL (DECL_NAME (t));
+ LTO_SET_PREVAIL (DECL_CONTEXT (t));
+ if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
- 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. */
- *tp = prevailing;
- t = prevailing;
+ LTO_SET_PREVAIL (DECL_SIZE (t));
+ LTO_SET_PREVAIL (DECL_SIZE_UNIT (t));
+ LTO_SET_PREVAIL (DECL_INITIAL (t));
+ LTO_NO_PREVAIL (DECL_ATTRIBUTES (t));
+ LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t));
+ }
+ if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
+ {
+ LTO_NO_PREVAIL (t->decl_with_vis.assembler_name);
+ LTO_NO_PREVAIL (DECL_SECTION_NAME (t));
+ }
+ if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
+ {
+ LTO_NO_PREVAIL (DECL_ARGUMENT_FLD (t));
+ LTO_NO_PREVAIL (DECL_RESULT_FLD (t));
+ LTO_NO_PREVAIL (DECL_VINDEX (t));
+ }
+ if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
+ LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t));
+ if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
+ {
+ LTO_NO_PREVAIL (DECL_FIELD_OFFSET (t));
+ LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t));
+ LTO_NO_PREVAIL (DECL_QUALIFIER (t));
+ LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t));
+ LTO_NO_PREVAIL (DECL_FCONTEXT (t));
}
}
else if (TYPE_P (t))
{
- /* Replace t with the prevailing type. We don't want to insert the
- other type in the seen set as we want to replace all instances of it. */
- t = gimple_register_type (t);
- *tp = t;
- }
-
- if (pointer_set_insert (fixup_data->seen, t))
- return NULL;
-
- /* walk_tree does not visit all reachable nodes that need to be fixed up.
- Hence we do special processing here for those kind of nodes. */
- switch (TREE_CODE (t))
- {
- case FIELD_DECL:
- lto_fixup_field_decl (t, data);
- break;
-
- case LABEL_DECL:
- case CONST_DECL:
- case PARM_DECL:
- case RESULT_DECL:
- case IMPORTED_DECL:
- lto_fixup_decl_common (t, data);
- break;
-
- case VAR_DECL:
- lto_fixup_decl_with_vis (t, data);
- break;
-
- case TYPE_DECL:
- lto_fixup_decl_non_common (t, data);
- break;
+ LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t));
+ LTO_SET_PREVAIL (TYPE_SIZE (t));
+ LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t));
+ LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t));
+ LTO_NO_PREVAIL (TYPE_NAME (t));
- case FUNCTION_DECL:
- lto_fixup_function (t, data);
- break;
+ LTO_SET_PREVAIL (TYPE_MINVAL (t));
+ LTO_SET_PREVAIL (TYPE_MAXVAL (t));
+ LTO_SET_PREVAIL (t->type_non_common.binfo);
- case TREE_BINFO:
- lto_fixup_binfo (t, data);
- break;
+ LTO_SET_PREVAIL (TYPE_CONTEXT (t));
- default:
- if (TYPE_P (t))
- lto_fixup_type (t, data);
- else if (TREE_CODE (t) == CONSTRUCTOR)
- lto_fixup_constructor (t, data);
- else if (CONSTANT_CLASS_P (t))
- LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
- else if (EXPR_P (t))
- {
- /* walk_tree only handles TREE_OPERANDs. Do the rest here. */
- lto_fixup_common (t, data);
- LTO_FIXUP_SUBTREE (t->exp.block);
- *walk_subtrees = 1;
- }
- else
+ LTO_NO_PREVAIL (TYPE_CANONICAL (t));
+ LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t));
+ LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t));
+ }
+ else if (EXPR_P (t))
+ {
+ int i;
+ LTO_NO_PREVAIL (t->exp.block);
+ for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
+ LTO_SET_PREVAIL (TREE_OPERAND (t, i));
+ }
+ else
+ {
+ switch (code)
{
- /* Let walk_tree handle sub-trees. */
- *walk_subtrees = 1;
+ case TREE_LIST:
+ LTO_SET_PREVAIL (TREE_VALUE (t));
+ LTO_SET_PREVAIL (TREE_PURPOSE (t));
+ break;
+ default:
+ gcc_unreachable ();
}
}
-
- return NULL;
}
+#undef LTO_SET_PREVAIL
+#undef LTO_NO_PREVAIL
/* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
- replaces var and function decls with the corresponding prevailing def and
- records the old decl in the free-list in DATA. We also record visted nodes
- in the seen-set in DATA to avoid multiple visit for nodes that need not
- to be replaced. */
+ replaces var and function decls with the corresponding prevailing def. */
static void
-lto_fixup_state (struct lto_in_decl_state *state, lto_fixup_data_t *data)
+lto_fixup_state (struct lto_in_decl_state *state)
{
unsigned i, si;
struct lto_tree_ref_table *table;
{
table = &state->streams[si];
for (i = 0; i < table->size; i++)
- walk_tree (table->trees + i, lto_fixup_tree, data, NULL);
+ {
+ tree *tp = table->trees + i;
+ if (VAR_OR_FUNCTION_DECL_P (*tp))
+ *tp = lto_symtab_prevailing_decl (*tp);
+ }
}
}
-/* A callback of htab_traverse. Just extract a state from SLOT and the
- lto_fixup_data_t object from AUX and calls lto_fixup_state. */
+/* A callback of htab_traverse. Just extracts a state from SLOT
+ and calls lto_fixup_state. */
static int
-lto_fixup_state_aux (void **slot, void *aux)
+lto_fixup_state_aux (void **slot, void *aux ATTRIBUTE_UNUSED)
{
struct lto_in_decl_state *state = (struct lto_in_decl_state *) *slot;
- lto_fixup_state (state, (lto_fixup_data_t *) aux);
+ lto_fixup_state (state);
return 1;
}
lto_fixup_decls (struct lto_file_decl_data **files)
{
unsigned int i;
- tree decl;
- struct pointer_set_t *seen = pointer_set_create ();
- lto_fixup_data_t data;
+ htab_iterator hi;
+ tree t;
+
+ FOR_EACH_HTAB_ELEMENT (tree_with_vars, t, tree, hi)
+ lto_fixup_prevailing_decls (t);
- data.seen = seen;
for (i = 0; files[i]; i++)
{
struct lto_file_decl_data *file = files[i];
struct lto_in_decl_state *state = file->global_decl_state;
- lto_fixup_state (state, &data);
-
- htab_traverse (file->function_decl_states, lto_fixup_state_aux, &data);
- }
-
- for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++)
- {
- tree saved_decl = decl;
- walk_tree (&decl, lto_fixup_tree, &data, NULL);
- if (decl != saved_decl)
- VEC_replace (tree, lto_global_var_decls, i, decl);
- }
-
- pointer_set_destroy (seen);
-}
+ lto_fixup_state (state);
-/* 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);
+ htab_traverse (file->function_decl_states, lto_fixup_state_aux, NULL);
}
- else
- fprintf (stderr, "[Leaving LTRANS input file %s]\n", file);
}
/* Read the options saved from each file in the command line. Called
/* 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++)
{
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;
+ 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;
- 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);
}
+ if (!quiet_flag)
+ fprintf (stderr, "\n");
+
/* Apply globally the options read from all the files. */
lto_reissue_options ();
}
+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);
+}
+
+/* Input file data before flattening (i.e. splitting them to subfiles to support
+ incremental linking. */
+static int real_file_count;
+static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data **real_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;
+ 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 = XNEWVEC (struct lto_file_decl_data *, nfiles + 1);
- lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
+ real_file_decl_data
+ = decl_data = ggc_alloc_cleared_vec_lto_file_decl_data_ptr (nfiles + 1);
+ real_file_count = nfiles;
/* 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);
gcc_assert (num_objects == nfiles);
}
+ tree_with_vars = htab_create_ggc (101, htab_hash_pointer, htab_eq_pointer,
+ NULL);
+
+ 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_elf_file_open (fnames[i], false);
+ current_lto_file = lto_obj_file_open (fnames[i], false);
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;
+ {
+ lto_obj_file_close (current_lto_file);
+ current_lto_file = NULL;
+ break;
+ }
- all_file_decl_data[last_file_ix++] = file_data;
+ 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 ();
}
+ lto_flatten_files (decl_data, count, last_file_ix);
+ lto_stats.num_input_files = count;
+ ggc_free(decl_data);
+ real_file_decl_data = NULL;
+
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);
- /* Each pass will set the appropriate timer. */
- timevar_pop (TV_IPA_LTO_DECL_IO);
+ timevar_pop (TV_IPA_LTO_DECL_IN);
+
+ 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 ();
+ /* If there were errors during symbol merging bail out, we have no
+ good way to recover here. */
+ if (seen_error ())
+ fatal_error ("errors during merging of translation units");
+
/* Fixup all decls and types and free the type hash tables. */
lto_fixup_decls (all_file_decl_data);
+ htab_delete (tree_with_vars);
+ tree_with_vars = NULL;
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. */
- ipa_read_summaries ();
+ if (flag_ltrans)
+ ipa_read_optimization_summaries ();
+ else
+ ipa_read_summaries ();
/* 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 ();
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_pop (TV_IPA_LTO_CGRAPH_MERGE);
- timevar_push (TV_IPA_LTO_DECL_IO);
+ 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. */
- 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];
/* 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;
}
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);
+ timevar_push (TV_IPA_LTO_GIMPLE_IN);
for (node = cgraph_nodes; node; node = node->next)
{
- /* Some cgraph nodes get created on the fly, and they don't need
- to be materialized. For instance, nodes for nested functions
- where the parent function was not streamed out or builtin
- functions. Additionally, builtin functions should not be
- materialized and may, in fact, cause confusion because there
- may be a regular function in the file whose assembler name
- matches that of the function.
- See gcc.c-torture/execute/20030125-1.c and
- gcc.c-torture/execute/921215-1.c. */
- if (node->local.lto_file_data
- && !DECL_IS_BUILTIN (node->decl))
+ if (node->local.lto_file_data)
{
lto_materialize_function (node);
lto_stats.num_input_cgraph_nodes++;
}
}
- 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. */
set_cfun (NULL);
/* Inform the middle end about the global variables we have seen. */
- for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++)
+ FOR_EACH_VEC_ELT (tree, lto_global_var_decls, i, decl)
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");
timevar_pop (lto_timer);
}
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
the decls and cgraph nodes so that analysis can be performed. */
/* 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;
+
+ if (cgraph_dump_file)
+ {
+ dump_cgraph (cgraph_dump_file);
+ dump_varpool (cgraph_dump_file);
+ }
bitmap_obstack_initialize (NULL);
- ipa_register_cgraph_hooks ();
cgraph_state = CGRAPH_STATE_IPA_SSA;
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);
/* We are about to launch the final LTRANS phase, stop the WPA timer. */
timevar_pop (TV_WHOPR_WPA);
- lto_1_to_1_map ();
+ if (flag_lto_partition_1to1)
+ lto_1_to_1_map ();
+ else
+ lto_balanced_map ();
+
+ if (!quiet_flag)
+ {
+ fprintf (stderr, "\nStreaming out");
+ fflush (stderr);
+ }
+ lto_wpa_write_files ();
+ ggc_collect ();
+ if (!quiet_flag)
+ fprintf (stderr, "\n");
- output_files = lto_wpa_write_files ();
+ 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]);
+static GTY(()) tree lto_eh_personality_decl;
- free (output_files[i]);
+/* Return the LTO personality function decl. */
+
+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;
+}
+
+/* Set the process name based on the LTO mode. */
+
+static void
+lto_process_name (void)
+{
+ if (flag_lto)
+ setproctitle ("lto1-lto");
+ if (flag_wpa)
+ setproctitle ("lto1-wpa");
+ if (flag_ltrans)
+ setproctitle ("lto1-ltrans");
+}
+
+
+/* Initialize the LTO front end. */
+
+static void
+lto_init (void)
+{
+ lto_process_name ();
+ lto_streamer_hooks_init ();
+ lto_reader_init ();
+ memset (<o_stats, 0, sizeof (lto_stats));
+ bitmap_obstack_initialize (NULL);
+ gimple_register_cfg_hooks ();
}
simply applies them. */
void
-lto_main (int debug_p ATTRIBUTE_UNUSED)
+lto_main (void)
{
- lto_init_reader ();
+ /* Initialize the LTO front end. */
+ lto_init ();
/* Read all the symbols and call graph from all the files in the
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
OSDN Git Service
