OSDN Git Service

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