/* Basic IPA optimizations and utilities.
- Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009 Free Software Foundation,
- Inc.
+ Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
+ Free Software Foundation, Inc.
This file is part of GCC.
#include "tm.h"
#include "cgraph.h"
#include "tree-pass.h"
-#include "timevar.h"
#include "gimple.h"
#include "ggc.h"
-
-/* Fill array order with all nodes with output flag set in the reverse
- topological order. */
-
-int
-cgraph_postorder (struct cgraph_node **order)
-{
- struct cgraph_node *node, *node2;
- int stack_size = 0;
- int order_pos = 0;
- struct cgraph_edge *edge, last;
- int pass;
-
- struct cgraph_node **stack =
- XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
-
- /* We have to deal with cycles nicely, so use a depth first traversal
- output algorithm. Ignore the fact that some functions won't need
- to be output and put them into order as well, so we get dependencies
- right through inline functions. */
- for (node = cgraph_nodes; node; node = node->next)
- node->aux = NULL;
- for (pass = 0; pass < 2; pass++)
- for (node = cgraph_nodes; node; node = node->next)
- if (!node->aux
- && (pass
- || (!cgraph_only_called_directly_p (node)
- && !node->address_taken)))
- {
- node2 = node;
- if (!node->callers)
- node->aux = &last;
- else
- node->aux = node->callers;
- while (node2)
- {
- while (node2->aux != &last)
- {
- edge = (struct cgraph_edge *) node2->aux;
- if (edge->next_caller)
- node2->aux = edge->next_caller;
- else
- node2->aux = &last;
- if (!edge->caller->aux)
- {
- if (!edge->caller->callers)
- edge->caller->aux = &last;
- else
- edge->caller->aux = edge->caller->callers;
- stack[stack_size++] = node2;
- node2 = edge->caller;
- break;
- }
- }
- if (node2->aux == &last)
- {
- order[order_pos++] = node2;
- if (stack_size)
- node2 = stack[--stack_size];
- else
- node2 = NULL;
- }
- }
- }
- free (stack);
- for (node = cgraph_nodes; node; node = node->next)
- node->aux = NULL;
- return order_pos;
-}
+#include "flags.h"
+#include "pointer-set.h"
+#include "target.h"
+#include "tree-iterator.h"
+#include "ipa-utils.h"
+#include "pointer-set.h"
+#include "ipa-inline.h"
/* Look for all functions inlined to NODE and update their inlined_to pointers
to INLINED_TO. */
}
}
+/* Add symtab NODE to queue starting at FIRST.
+
+ The queue is linked via AUX pointers and terminated by pointer to 1.
+ We enqueue nodes at two occasions: when we find them reachable or when we find
+ their bodies needed for further clonning. In the second case we mark them
+ by pointer to 2 after processing so they are re-queue when they become
+ reachable. */
+
+static void
+enqueue_node (symtab_node node, symtab_node *first,
+ struct pointer_set_t *reachable)
+{
+ /* Node is still in queue; do nothing. */
+ if (node->symbol.aux && node->symbol.aux != (void *) 2)
+ return;
+ /* Node was already processed as unreachable, re-enqueue
+ only if it became reachable now. */
+ if (node->symbol.aux == (void *)2 && !pointer_set_contains (reachable, node))
+ return;
+ node->symbol.aux = *first;
+ *first = node;
+}
+
+/* Process references. */
+
+static void
+process_references (struct ipa_ref_list *list,
+ symtab_node *first,
+ bool before_inlining_p,
+ struct pointer_set_t *reachable)
+{
+ int i;
+ struct ipa_ref *ref;
+ for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
+ {
+ if (symtab_function_p (ref->referred))
+ {
+ struct cgraph_node *node = ipa_ref_node (ref);
+
+ if (node->analyzed
+ && (!DECL_EXTERNAL (node->symbol.decl)
+ || node->alias
+ || before_inlining_p))
+ pointer_set_insert (reachable, node);
+ enqueue_node ((symtab_node) node, first, reachable);
+ }
+ else
+ {
+ struct varpool_node *node = ipa_ref_varpool_node (ref);
+
+ if (node->analyzed
+ && (!DECL_EXTERNAL (node->symbol.decl)
+ || node->alias
+ || before_inlining_p))
+ pointer_set_insert (reachable, node);
+ enqueue_node ((symtab_node) node, first, reachable);
+ }
+ }
+}
+
+
+/* Return true when NODE can not be local. Worker for cgraph_local_node_p. */
+
+static bool
+cgraph_non_local_node_p_1 (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
+{
+ /* FIXME: Aliases can be local, but i386 gets thunks wrong then. */
+ return !(cgraph_only_called_directly_or_aliased_p (node)
+ && !ipa_ref_has_aliases_p (&node->symbol.ref_list)
+ && node->analyzed
+ && !DECL_EXTERNAL (node->symbol.decl)
+ && !node->symbol.externally_visible
+ && !node->symbol.used_from_other_partition
+ && !node->symbol.in_other_partition);
+}
+
+/* Return true when function can be marked local. */
+
+static bool
+cgraph_local_node_p (struct cgraph_node *node)
+{
+ struct cgraph_node *n = cgraph_function_or_thunk_node (node, NULL);
+
+ /* FIXME: thunks can be considered local, but we need prevent i386
+ from attempting to change calling convention of them. */
+ if (n->thunk.thunk_p)
+ return false;
+ return !cgraph_for_node_and_aliases (n,
+ cgraph_non_local_node_p_1, NULL, true);
+
+}
+
+/* Return true when NODE has ADDR reference. */
+
+static bool
+has_addr_references_p (struct cgraph_node *node,
+ void *data ATTRIBUTE_UNUSED)
+{
+ int i;
+ struct ipa_ref *ref;
+
+ for (i = 0; ipa_ref_list_referring_iterate (&node->symbol.ref_list,
+ i, ref); i++)
+ if (ref->use == IPA_REF_ADDR)
+ return true;
+ return false;
+}
+
/* Perform reachability analysis and reclaim all unreachable nodes.
- If BEFORE_INLINING_P is true this function is called before inlining
- decisions has been made. If BEFORE_INLINING_P is false this function also
- removes unneeded bodies of extern inline functions. */
+
+ The algorithm is basically mark&sweep but with some extra refinements:
+
+ - reachable extern inline functions needs special handling; the bodies needs
+ to stay in memory until inlining in hope that they will be inlined.
+ After inlining we release their bodies and turn them into unanalyzed
+ nodes even when they are reachable.
+
+ BEFORE_INLINING_P specify whether we are before or after inlining.
+
+ - virtual functions are kept in callgraph even if they seem unreachable in
+ hope calls to them will be devirtualized.
+
+ Again we remove them after inlining. In late optimization some
+ devirtualization may happen, but it is not importnat since we won't inline
+ the call. In theory early opts and IPA should work out all important cases.
+
+ - virtual clones needs bodies of their origins for later materialization;
+ this means that we want to keep the body even if the origin is unreachable
+ otherwise. To avoid origin from sitting in the callgraph and being
+ walked by IPA passes, we turn them into unanalyzed nodes with body
+ defined.
+
+ We maintain set of function declaration where body needs to stay in
+ body_needed_for_clonning
+
+ Inline clones represent special case: their declaration match the
+ declaration of origin and cgraph_remove_node already knows how to
+ reshape callgraph and preserve body when offline copy of function or
+ inline clone is being removed.
+
+ - C++ virtual tables keyed to other unit are represented as DECL_EXTERNAL
+ variables with DECL_INITIAL set. We finalize these and keep reachable
+ ones around for constant folding purposes. After inlining we however
+ stop walking their references to let everything static referneced by them
+ to be removed when it is otherwise unreachable.
+
+ We maintain queue of both reachable symbols (i.e. defined symbols that needs
+ to stay) and symbols that are in boundary (i.e. external symbols referenced
+ by reachable symbols or origins of clones). The queue is represented
+ as linked list by AUX pointer terminated by 1.
+
+ A the end we keep all reachable symbols. For symbols in boundary we always
+ turn definition into a declaration, but we may keep function body around
+ based on body_needed_for_clonning
+
+ All symbols that enter the queue have AUX pointer non-zero and are in the
+ boundary. Pointer set REACHABLE is used to track reachable symbols.
+
+ Every symbol can be visited twice - once as part of boundary and once
+ as real reachable symbol. enqueue_node needs to decide whether the
+ node needs to be re-queued for second processing. For this purpose
+ we set AUX pointer of processed symbols in the boundary to constant 2. */
bool
-cgraph_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
+symtab_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
{
- struct cgraph_node *first = (struct cgraph_node *) (void *) 1;
- struct cgraph_node *processed = (struct cgraph_node *) (void *) 2;
+ symtab_node first = (symtab_node) (void *) 1;
struct cgraph_node *node, *next;
+ struct varpool_node *vnode, *vnext;
bool changed = false;
+ struct pointer_set_t *reachable = pointer_set_create ();
+ struct pointer_set_t *body_needed_for_clonning = pointer_set_create ();
#ifdef ENABLE_CHECKING
- verify_cgraph ();
+ verify_symtab ();
#endif
if (file)
fprintf (file, "\nReclaiming functions:");
#ifdef ENABLE_CHECKING
- for (node = cgraph_nodes; node; node = node->next)
- gcc_assert (!node->aux);
+ FOR_EACH_FUNCTION (node)
+ gcc_assert (!node->symbol.aux);
+ FOR_EACH_VARIABLE (vnode)
+ gcc_assert (!vnode->symbol.aux);
#endif
- for (node = cgraph_nodes; node; node = node->next)
- if (!cgraph_can_remove_if_no_direct_calls_p (node)
- && ((!DECL_EXTERNAL (node->decl))
- || !node->analyzed
- || before_inlining_p))
+ /* Mark functions whose bodies are obviously needed.
+ This is mostly when they can be referenced externally. Inline clones
+ are special since their declarations are shared with master clone and thus
+ cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them. */
+ FOR_EACH_DEFINED_FUNCTION (node)
+ if (!node->global.inlined_to
+ && (!cgraph_can_remove_if_no_direct_calls_and_refs_p (node)
+ /* Keep around virtual functions for possible devirtualization. */
+ || (before_inlining_p
+ && DECL_VIRTUAL_P (node->symbol.decl)
+ && (DECL_COMDAT (node->symbol.decl) || DECL_EXTERNAL (node->symbol.decl)))))
{
gcc_assert (!node->global.inlined_to);
- node->aux = first;
- first = node;
- node->reachable = true;
+ pointer_set_insert (reachable, node);
+ enqueue_node ((symtab_node)node, &first, reachable);
}
else
+ gcc_assert (!node->symbol.aux);
+
+ /* Mark variables that are obviously needed. */
+ FOR_EACH_DEFINED_VARIABLE (vnode)
+ if (!varpool_can_remove_if_no_refs (vnode))
{
- gcc_assert (!node->aux);
- node->reachable = false;
+ pointer_set_insert (reachable, vnode);
+ enqueue_node ((symtab_node)vnode, &first, reachable);
}
- /* Perform reachability analysis. As a special case do not consider
- extern inline functions not inlined as live because we won't output
- them at all. */
- while (first != (void *) 1)
+ /* Perform reachability analysis. */
+ while (first != (symtab_node) (void *) 1)
{
- struct cgraph_edge *e;
- node = first;
- first = (struct cgraph_node *) first->aux;
- node->aux = processed;
-
- if (node->reachable)
- for (e = node->callees; e; e = e->next_callee)
- if (!e->callee->reachable
- && node->analyzed
- && (!e->inline_failed || !e->callee->analyzed
- || (!DECL_EXTERNAL (e->callee->decl))
- || before_inlining_p))
+ bool in_boundary_p = !pointer_set_contains (reachable, first);
+ symtab_node node = first;
+
+ first = (symtab_node)first->symbol.aux;
+
+ /* If we are processing symbol in boundary, mark its AUX pointer for
+ possible later re-processing in enqueue_node. */
+ if (in_boundary_p)
+ node->symbol.aux = (void *)2;
+ else
+ {
+ /* If any symbol in a comdat group is reachable, force
+ all other in the same comdat group to be also reachable. */
+ if (node->symbol.same_comdat_group)
{
- bool prev_reachable = e->callee->reachable;
- e->callee->reachable |= node->reachable;
- if (!e->callee->aux
- || (e->callee->aux == processed
- && prev_reachable != e->callee->reachable))
- {
- e->callee->aux = first;
- first = e->callee;
- }
+ symtab_node next;
+ for (next = node->symbol.same_comdat_group;
+ next != node;
+ next = next->symbol.same_comdat_group)
+ if (!pointer_set_insert (reachable, next))
+ enqueue_node ((symtab_node) next, &first, reachable);
}
+ /* Mark references as reachable. */
+ process_references (&node->symbol.ref_list, &first,
+ before_inlining_p, reachable);
+ }
- /* If any function in a comdat group is reachable, force
- all other functions in the same comdat group to be
- also reachable. */
- if (node->same_comdat_group
- && node->reachable
- && !node->global.inlined_to)
+ if (symtab_function_p (node))
{
- for (next = node->same_comdat_group;
- next != node;
- next = next->same_comdat_group)
- if (!next->reachable)
- {
- next->aux = first;
- first = next;
- next->reachable = true;
- }
- }
+ struct cgraph_node *cnode = cgraph (node);
- /* We can freely remove inline clones even if they are cloned, however if
- function is clone of real clone, we must keep it around in order to
- make materialize_clones produce function body with the changes
- applied. */
- while (node->clone_of && !node->clone_of->aux && !gimple_has_body_p (node->decl))
- {
- bool noninline = node->clone_of->decl != node->decl;
- node = node->clone_of;
- if (noninline)
+ /* Mark the callees reachable unless they are direct calls to extern
+ inline functions we decided to not inline. */
+ if (!in_boundary_p)
{
- node->aux = first;
- first = node;
- break;
+ struct cgraph_edge *e;
+ for (e = cnode->callees; e; e = e->next_callee)
+ {
+ if (e->callee->analyzed
+ && (!e->inline_failed
+ || !DECL_EXTERNAL (e->callee->symbol.decl)
+ || cnode->alias
+ || before_inlining_p))
+ pointer_set_insert (reachable, e->callee);
+ enqueue_node ((symtab_node) e->callee, &first, reachable);
+ }
+
+ /* When inline clone exists, mark body to be preserved so when removing
+ offline copy of the function we don't kill it. */
+ if (!cnode->alias && cnode->global.inlined_to)
+ pointer_set_insert (body_needed_for_clonning, cnode->symbol.decl);
+ }
+
+ /* For non-inline clones, force their origins to the boundary and ensure
+ that body is not removed. */
+ while (cnode->clone_of
+ && !gimple_has_body_p (cnode->symbol.decl))
+ {
+ bool noninline = cnode->clone_of->symbol.decl != cnode->symbol.decl;
+ cnode = cnode->clone_of;
+ if (noninline)
+ {
+ pointer_set_insert (body_needed_for_clonning, cnode->symbol.decl);
+ enqueue_node ((symtab_node)cnode, &first, reachable);
+ break;
+ }
}
}
+ /* When we see constructor of external variable, keep referred nodes in the
+ boundary. This will also hold initializers of the external vars NODE
+ reffers to. */
+ if (symtab_variable_p (node)
+ && DECL_EXTERNAL (node->symbol.decl)
+ && !varpool (node)->alias
+ && in_boundary_p)
+ {
+ int i;
+ struct ipa_ref *ref;
+ for (i = 0; ipa_ref_list_reference_iterate (&node->symbol.ref_list, i, ref); i++)
+ enqueue_node (ref->referred, &first, reachable);
+ }
}
- /* Remove unreachable nodes. Extern inline functions need special care;
- Unreachable extern inline functions shall be removed.
- Reachable extern inline functions we never inlined shall get their bodies
- eliminated.
- Reachable extern inline functions we sometimes inlined will be turned into
- unanalyzed nodes so they look like for true extern functions to the rest
- of code. Body of such functions is released via remove_node once the
- inline clones are eliminated. */
- for (node = cgraph_nodes; node; node = next)
+ /* Remove unreachable functions. */
+ for (node = cgraph_first_function (); node; node = next)
{
- next = node->next;
- if (node->aux && !node->reachable)
- {
- cgraph_node_remove_callees (node);
- node->analyzed = false;
- node->local.inlinable = false;
- }
- if (!node->aux)
+ next = cgraph_next_function (node);
+ if (!node->symbol.aux)
{
- node->global.inlined_to = NULL;
if (file)
fprintf (file, " %s", cgraph_node_name (node));
- if (!node->analyzed || !DECL_EXTERNAL (node->decl) || before_inlining_p)
- cgraph_remove_node (node);
- else
+ cgraph_remove_node (node);
+ changed = true;
+ }
+ else if (!pointer_set_contains (reachable, node))
+ {
+ if (node->analyzed)
{
- struct cgraph_edge *e;
-
- /* See if there is reachable caller. */
- for (e = node->callers; e; e = e->next_caller)
- if (e->caller->aux)
- break;
-
- /* If so, we need to keep node in the callgraph. */
- if (e || node->needed)
- {
- struct cgraph_node *clone;
-
- /* If there are still clones, we must keep body around.
- Otherwise we can just remove the body but keep the clone. */
- for (clone = node->clones; clone;
- clone = clone->next_sibling_clone)
- if (clone->aux)
- break;
- if (!clone)
- {
- cgraph_release_function_body (node);
- node->analyzed = false;
- node->local.inlinable = false;
- }
- cgraph_node_remove_callees (node);
- if (node->prev_sibling_clone)
- node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
- else if (node->clone_of)
- node->clone_of->clones = node->next_sibling_clone;
- if (node->next_sibling_clone)
- node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
- node->clone_of = NULL;
- node->next_sibling_clone = NULL;
- node->prev_sibling_clone = NULL;
- }
- else
- cgraph_remove_node (node);
+ if (file)
+ fprintf (file, " %s", cgraph_node_name (node));
+ cgraph_node_remove_callees (node);
+ ipa_remove_all_references (&node->symbol.ref_list);
+ changed = true;
}
- changed = true;
+ if (!pointer_set_contains (body_needed_for_clonning, node->symbol.decl)
+ && (node->local.finalized || !DECL_ARTIFICIAL (node->symbol.decl)))
+ cgraph_release_function_body (node);
+ node->analyzed = false;
}
}
- for (node = cgraph_nodes; node; node = node->next)
+
+ /* Inline clones might be kept around so their materializing allows further
+ cloning. If the function the clone is inlined into is removed, we need
+ to turn it into normal cone. */
+ FOR_EACH_FUNCTION (node)
{
- /* Inline clones might be kept around so their materializing allows further
- cloning. If the function the clone is inlined into is removed, we need
- to turn it into normal cone. */
if (node->global.inlined_to
&& !node->callers)
{
node->global.inlined_to = NULL;
update_inlined_to_pointer (node, node);
}
- node->aux = NULL;
+ node->symbol.aux = NULL;
+ }
+
+ /* Remove unreachable variables. */
+ if (file)
+ fprintf (file, "\nReclaiming variables:");
+ for (vnode = varpool_first_variable (); vnode; vnode = vnext)
+ {
+ vnext = varpool_next_variable (vnode);
+ if (!vnode->symbol.aux)
+ {
+ if (file)
+ fprintf (file, " %s", varpool_node_name (vnode));
+ varpool_remove_node (vnode);
+ changed = true;
+ }
+ else if (!pointer_set_contains (reachable, vnode))
+ {
+ if (vnode->analyzed)
+ {
+ if (file)
+ fprintf (file, " %s", varpool_node_name (vnode));
+ changed = true;
+ }
+ vnode->analyzed = false;
+ vnode->symbol.aux = NULL;
+ }
+ else
+ vnode->symbol.aux = NULL;
}
+
+ pointer_set_destroy (reachable);
+ pointer_set_destroy (body_needed_for_clonning);
+
+ /* Now update address_taken flags and try to promote functions to be local. */
+ if (file)
+ fprintf (file, "\nClearing address taken flags:");
+ FOR_EACH_DEFINED_FUNCTION (node)
+ if (node->symbol.address_taken
+ && !node->symbol.used_from_other_partition)
+ {
+ if (!cgraph_for_node_and_aliases (node, has_addr_references_p, NULL, true))
+ {
+ if (file)
+ fprintf (file, " %s", cgraph_node_name (node));
+ node->symbol.address_taken = false;
+ changed = true;
+ if (cgraph_local_node_p (node))
+ {
+ node->local.local = true;
+ if (file)
+ fprintf (file, " (local)");
+ }
+ }
+ }
+ if (file)
+ fprintf (file, "\n");
+
#ifdef ENABLE_CHECKING
- verify_cgraph ();
+ verify_symtab ();
#endif
- /* Reclaim alias pairs for functions that have disappeared from the
- call graph. */
- remove_unreachable_alias_pairs ();
+ /* If we removed something, perhaps profile could be improved. */
+ if (changed && optimize && inline_edge_summary_vec)
+ FOR_EACH_DEFINED_FUNCTION (node)
+ cgraph_propagate_frequency (node);
return changed;
}
+/* Discover variables that have no longer address taken or that are read only
+ and update their flags.
+
+ FIXME: This can not be done in between gimplify and omp_expand since
+ readonly flag plays role on what is shared and what is not. Currently we do
+ this transformation as part of whole program visibility and re-do at
+ ipa-reference pass (to take into account clonning), but it would
+ make sense to do it before early optimizations. */
+
+void
+ipa_discover_readonly_nonaddressable_vars (void)
+{
+ struct varpool_node *vnode;
+ if (dump_file)
+ fprintf (dump_file, "Clearing variable flags:");
+ FOR_EACH_VARIABLE (vnode)
+ if (vnode->finalized && varpool_all_refs_explicit_p (vnode)
+ && (TREE_ADDRESSABLE (vnode->symbol.decl)
+ || !TREE_READONLY (vnode->symbol.decl)))
+ {
+ bool written = false;
+ bool address_taken = false;
+ int i;
+ struct ipa_ref *ref;
+ for (i = 0; ipa_ref_list_referring_iterate (&vnode->symbol.ref_list,
+ i, ref)
+ && (!written || !address_taken); i++)
+ switch (ref->use)
+ {
+ case IPA_REF_ADDR:
+ address_taken = true;
+ break;
+ case IPA_REF_LOAD:
+ break;
+ case IPA_REF_STORE:
+ written = true;
+ break;
+ }
+ if (TREE_ADDRESSABLE (vnode->symbol.decl) && !address_taken)
+ {
+ if (dump_file)
+ fprintf (dump_file, " %s (addressable)", varpool_node_name (vnode));
+ TREE_ADDRESSABLE (vnode->symbol.decl) = 0;
+ }
+ if (!TREE_READONLY (vnode->symbol.decl) && !address_taken && !written
+ /* Making variable in explicit section readonly can cause section
+ type conflict.
+ See e.g. gcc.c-torture/compile/pr23237.c */
+ && DECL_SECTION_NAME (vnode->symbol.decl) == NULL)
+ {
+ if (dump_file)
+ fprintf (dump_file, " %s (read-only)", varpool_node_name (vnode));
+ TREE_READONLY (vnode->symbol.decl) = 1;
+ }
+ }
+ if (dump_file)
+ fprintf (dump_file, "\n");
+}
+
+/* Return true when there is a reference to node and it is not vtable. */
+static bool
+cgraph_address_taken_from_non_vtable_p (struct cgraph_node *node)
+{
+ int i;
+ struct ipa_ref *ref;
+ for (i = 0; ipa_ref_list_referring_iterate (&node->symbol.ref_list,
+ i, ref); i++)
+ if (ref->use == IPA_REF_ADDR)
+ {
+ struct varpool_node *node;
+ if (symtab_function_p (ref->referring))
+ return true;
+ node = ipa_ref_referring_varpool_node (ref);
+ if (!DECL_VIRTUAL_P (node->symbol.decl))
+ return true;
+ }
+ return false;
+}
+
+/* COMDAT functions must be shared only if they have address taken,
+ otherwise we can produce our own private implementation with
+ -fwhole-program.
+ Return true when turning COMDAT functoin static can not lead to wrong
+ code when the resulting object links with a library defining same COMDAT.
+
+ Virtual functions do have their addresses taken from the vtables,
+ but in C++ there is no way to compare their addresses for equality. */
+
+bool
+cgraph_comdat_can_be_unshared_p (struct cgraph_node *node)
+{
+ if ((cgraph_address_taken_from_non_vtable_p (node)
+ && !DECL_VIRTUAL_P (node->symbol.decl))
+ || !node->analyzed)
+ return false;
+ if (node->symbol.same_comdat_group)
+ {
+ struct cgraph_node *next;
+
+ /* If more than one function is in the same COMDAT group, it must
+ be shared even if just one function in the comdat group has
+ address taken. */
+ for (next = cgraph (node->symbol.same_comdat_group);
+ next != node; next = cgraph (next->symbol.same_comdat_group))
+ if (cgraph_address_taken_from_non_vtable_p (next)
+ && !DECL_VIRTUAL_P (next->symbol.decl))
+ return false;
+ }
+ return true;
+}
+
+/* Return true when function NODE should be considered externally visible. */
+
static bool
-cgraph_externally_visible_p (struct cgraph_node *node, bool whole_program)
+cgraph_externally_visible_p (struct cgraph_node *node,
+ bool whole_program, bool aliased)
{
if (!node->local.finalized)
return false;
- if (!DECL_COMDAT (node->decl)
- && (!TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl)))
+ if (!DECL_COMDAT (node->symbol.decl)
+ && (!TREE_PUBLIC (node->symbol.decl)
+ || DECL_EXTERNAL (node->symbol.decl)))
+ return false;
+
+ /* Do not even try to be smart about aliased nodes. Until we properly
+ represent everything by same body alias, these are just evil. */
+ if (aliased)
+ return true;
+
+ /* Do not try to localize built-in functions yet. One of problems is that we
+ end up mangling their asm for WHOPR that makes it impossible to call them
+ using the implicit built-in declarations anymore. Similarly this enables
+ us to remove them as unreachable before actual calls may appear during
+ expansion or folding. */
+ if (DECL_BUILT_IN (node->symbol.decl))
+ return true;
+
+ /* If linker counts on us, we must preserve the function. */
+ if (symtab_used_from_object_file_p ((symtab_node) node))
+ return true;
+ if (DECL_PRESERVE_P (node->symbol.decl))
+ return true;
+ if (lookup_attribute ("externally_visible",
+ DECL_ATTRIBUTES (node->symbol.decl)))
+ return true;
+ if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
+ && lookup_attribute ("dllexport",
+ DECL_ATTRIBUTES (node->symbol.decl)))
+ return true;
+ if (node->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY)
return false;
- if (!whole_program)
+ /* When doing LTO or whole program, we can bring COMDAT functoins static.
+ This improves code quality and we know we will duplicate them at most twice
+ (in the case that we are not using plugin and link with object file
+ implementing same COMDAT) */
+ if ((in_lto_p || whole_program)
+ && DECL_COMDAT (node->symbol.decl)
+ && cgraph_comdat_can_be_unshared_p (node))
+ return false;
+
+ /* When doing link time optimizations, hidden symbols become local. */
+ if (in_lto_p
+ && (DECL_VISIBILITY (node->symbol.decl) == VISIBILITY_HIDDEN
+ || DECL_VISIBILITY (node->symbol.decl) == VISIBILITY_INTERNAL)
+ /* Be sure that node is defined in IR file, not in other object
+ file. In that case we don't set used_from_other_object_file. */
+ && node->analyzed)
+ ;
+ else if (!whole_program)
return true;
- /* COMDAT functions must be shared only if they have address taken,
- otherwise we can produce our own private implementation with
- -fwhole-program. */
- if (DECL_COMDAT (node->decl))
- {
- if (node->address_taken || !node->analyzed)
- return true;
- if (node->same_comdat_group)
- {
- struct cgraph_node *next;
-
- /* If more than one function is in the same COMDAT group, it must
- be shared even if just one function in the comdat group has
- address taken. */
- for (next = node->same_comdat_group;
- next != node;
- next = next->same_comdat_group)
- if (next->address_taken || !next->analyzed)
- return true;
- }
- }
- if (MAIN_NAME_P (DECL_NAME (node->decl)))
+
+ if (MAIN_NAME_P (DECL_NAME (node->symbol.decl)))
+ return true;
+
+ return false;
+}
+
+/* Return true when variable VNODE should be considered externally visible. */
+
+bool
+varpool_externally_visible_p (struct varpool_node *vnode, bool aliased)
+{
+ /* Do not touch weakrefs; while they are not externally visible,
+ dropping their DECL_EXTERNAL flags confuse most
+ of code handling them. */
+ if (vnode->alias && DECL_EXTERNAL (vnode->symbol.decl))
+ return true;
+
+ if (DECL_EXTERNAL (vnode->symbol.decl))
+ return true;
+
+ if (!DECL_COMDAT (vnode->symbol.decl) && !TREE_PUBLIC (vnode->symbol.decl))
+ return false;
+
+ /* Do not even try to be smart about aliased nodes. Until we properly
+ represent everything by same body alias, these are just evil. */
+ if (aliased)
+ return true;
+
+ /* If linker counts on us, we must preserve the function. */
+ if (symtab_used_from_object_file_p ((symtab_node) vnode))
+ return true;
+
+ if (DECL_HARD_REGISTER (vnode->symbol.decl))
return true;
- if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (node->decl)))
+ if (DECL_PRESERVE_P (vnode->symbol.decl))
+ return true;
+ if (lookup_attribute ("externally_visible",
+ DECL_ATTRIBUTES (vnode->symbol.decl)))
+ return true;
+ if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
+ && lookup_attribute ("dllexport",
+ DECL_ATTRIBUTES (vnode->symbol.decl)))
+ return true;
+
+ /* See if we have linker information about symbol not being used or
+ if we need to make guess based on the declaration.
+
+ Even if the linker clams the symbol is unused, never bring internal
+ symbols that are declared by user as used or externally visible.
+ This is needed for i.e. references from asm statements. */
+ if (symtab_used_from_object_file_p ((symtab_node) vnode))
+ return true;
+ if (vnode->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY)
+ return false;
+
+ /* As a special case, the COMDAT virtual tables can be unshared.
+ In LTO mode turn vtables into static variables. The variable is readonly,
+ so this does not enable more optimization, but referring static var
+ is faster for dynamic linking. Also this match logic hidding vtables
+ from LTO symbol tables. */
+ if ((in_lto_p || flag_whole_program)
+ && !vnode->symbol.force_output
+ && DECL_COMDAT (vnode->symbol.decl) && DECL_VIRTUAL_P (vnode->symbol.decl))
+ return false;
+
+ /* When doing link time optimizations, hidden symbols become local. */
+ if (in_lto_p
+ && (DECL_VISIBILITY (vnode->symbol.decl) == VISIBILITY_HIDDEN
+ || DECL_VISIBILITY (vnode->symbol.decl) == VISIBILITY_INTERNAL)
+ /* Be sure that node is defined in IR file, not in other object
+ file. In that case we don't set used_from_other_object_file. */
+ && vnode->finalized)
+ ;
+ else if (!flag_whole_program)
+ return true;
+
+ /* Do not attempt to privatize COMDATS by default.
+ This would break linking with C++ libraries sharing
+ inline definitions.
+
+ FIXME: We can do so for readonly vars with no address taken and
+ possibly also for vtables since no direct pointer comparsion is done.
+ It might be interesting to do so to reduce linking overhead. */
+ if (DECL_COMDAT (vnode->symbol.decl) || DECL_WEAK (vnode->symbol.decl))
return true;
return false;
}
{
struct cgraph_node *node;
struct varpool_node *vnode;
+ struct pointer_set_t *aliased_nodes = pointer_set_create ();
+ struct pointer_set_t *aliased_vnodes = pointer_set_create ();
+ unsigned i;
+ alias_pair *p;
- for (node = cgraph_nodes; node; node = node->next)
+ /* Discover aliased nodes. */
+ FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
{
+ if (dump_file)
+ fprintf (dump_file, "Alias %s->%s",
+ IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (p->decl)),
+ IDENTIFIER_POINTER (p->target));
+
+ if ((node = cgraph_node_for_asm (p->target)) != NULL
+ && !DECL_EXTERNAL (node->symbol.decl))
+ {
+ if (!node->analyzed)
+ continue;
+ cgraph_mark_force_output_node (node);
+ pointer_set_insert (aliased_nodes, node);
+ if (dump_file)
+ fprintf (dump_file, " node %s/%i",
+ cgraph_node_name (node), node->uid);
+ }
+ else if ((vnode = varpool_node_for_asm (p->target)) != NULL
+ && !DECL_EXTERNAL (vnode->symbol.decl))
+ {
+ vnode->symbol.force_output = 1;
+ pointer_set_insert (aliased_vnodes, vnode);
+ if (dump_file)
+ fprintf (dump_file, " varpool node %s",
+ varpool_node_name (vnode));
+ }
+ if (dump_file)
+ fprintf (dump_file, "\n");
+ }
+
+ FOR_EACH_FUNCTION (node)
+ {
+ int flags = flags_from_decl_or_type (node->symbol.decl);
+
+ /* Optimize away PURE and CONST constructors and destructors. */
+ if (optimize
+ && (flags & (ECF_CONST | ECF_PURE))
+ && !(flags & ECF_LOOPING_CONST_OR_PURE))
+ {
+ DECL_STATIC_CONSTRUCTOR (node->symbol.decl) = 0;
+ DECL_STATIC_DESTRUCTOR (node->symbol.decl) = 0;
+ }
+
+ /* Frontends and alias code marks nodes as needed before parsing is finished.
+ We may end up marking as node external nodes where this flag is meaningless
+ strip it. */
+ if (node->symbol.force_output
+ && (DECL_EXTERNAL (node->symbol.decl) || !node->analyzed))
+ node->symbol.force_output = 0;
+
/* C++ FE on lack of COMDAT support create local COMDAT functions
(that ought to be shared but can not due to object format
- limitations). It is neccesary to keep the flag to make rest of C++ FE
+ limitations). It is necessary to keep the flag to make rest of C++ FE
happy. Clear the flag here to avoid confusion in middle-end. */
- if (DECL_COMDAT (node->decl) && !TREE_PUBLIC (node->decl))
- DECL_COMDAT (node->decl) = 0;
+ if (DECL_COMDAT (node->symbol.decl) && !TREE_PUBLIC (node->symbol.decl))
+ DECL_COMDAT (node->symbol.decl) = 0;
/* For external decls stop tracking same_comdat_group, it doesn't matter
what comdat group they are in when they won't be emitted in this TU,
and simplifies later passes. */
- if (node->same_comdat_group && DECL_EXTERNAL (node->decl))
+ if (node->symbol.same_comdat_group && DECL_EXTERNAL (node->symbol.decl))
{
- struct cgraph_node *n = node, *next;
- do
- {
+#ifdef ENABLE_CHECKING
+ symtab_node n;
+
+ for (n = node->symbol.same_comdat_group;
+ n != (symtab_node)node;
+ n = n->symbol.same_comdat_group)
/* If at least one of same comdat group functions is external,
all of them have to be, otherwise it is a front-end bug. */
- gcc_assert (DECL_EXTERNAL (n->decl));
- next = n->same_comdat_group;
- n->same_comdat_group = NULL;
- n = next;
- }
- while (n != node);
+ gcc_assert (DECL_EXTERNAL (n->symbol.decl));
+#endif
+ symtab_dissolve_same_comdat_group_list ((symtab_node) node);
}
- gcc_assert ((!DECL_WEAK (node->decl) && !DECL_COMDAT (node->decl))
- || TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl));
- if (cgraph_externally_visible_p (node, whole_program))
+ gcc_assert ((!DECL_WEAK (node->symbol.decl)
+ && !DECL_COMDAT (node->symbol.decl))
+ || TREE_PUBLIC (node->symbol.decl)
+ || DECL_EXTERNAL (node->symbol.decl));
+ if (cgraph_externally_visible_p (node, whole_program,
+ pointer_set_contains (aliased_nodes,
+ node)))
{
gcc_assert (!node->global.inlined_to);
- node->local.externally_visible = true;
+ node->symbol.externally_visible = true;
}
else
- node->local.externally_visible = false;
- if (!node->local.externally_visible && node->analyzed
- && !DECL_EXTERNAL (node->decl))
+ node->symbol.externally_visible = false;
+ if (!node->symbol.externally_visible && node->analyzed
+ && !DECL_EXTERNAL (node->symbol.decl))
{
- gcc_assert (whole_program || !TREE_PUBLIC (node->decl));
- cgraph_make_decl_local (node->decl);
+ gcc_assert (whole_program || in_lto_p
+ || !TREE_PUBLIC (node->symbol.decl));
+ symtab_make_decl_local (node->symbol.decl);
+ node->symbol.resolution = LDPR_PREVAILING_DEF_IRONLY;
+ if (node->symbol.same_comdat_group)
+ /* cgraph_externally_visible_p has already checked all other nodes
+ in the group and they will all be made local. We need to
+ dissolve the group at once so that the predicate does not
+ segfault though. */
+ symtab_dissolve_same_comdat_group_list ((symtab_node) node);
+ }
+
+ if (node->thunk.thunk_p
+ && TREE_PUBLIC (node->symbol.decl))
+ {
+ struct cgraph_node *decl_node = node;
+
+ decl_node = cgraph_function_node (decl_node->callees->callee, NULL);
+
+ /* Thunks have the same visibility as function they are attached to.
+ Make sure the C++ front end set this up properly. */
+ if (DECL_ONE_ONLY (decl_node->symbol.decl))
+ {
+ gcc_checking_assert (DECL_COMDAT (node->symbol.decl)
+ == DECL_COMDAT (decl_node->symbol.decl));
+ gcc_checking_assert (DECL_COMDAT_GROUP (node->symbol.decl)
+ == DECL_COMDAT_GROUP (decl_node->symbol.decl));
+ gcc_checking_assert (node->symbol.same_comdat_group);
+ }
+ if (DECL_EXTERNAL (decl_node->symbol.decl))
+ DECL_EXTERNAL (node->symbol.decl) = 1;
}
- node->local.local = (cgraph_only_called_directly_p (node)
- && node->analyzed
- && !DECL_EXTERNAL (node->decl)
- && !node->local.externally_visible);
}
- for (vnode = varpool_nodes; vnode; vnode = vnode->next)
+ FOR_EACH_DEFINED_FUNCTION (node)
+ node->local.local = cgraph_local_node_p (node);
+ FOR_EACH_VARIABLE (vnode)
{
/* weak flag makes no sense on local variables. */
- gcc_assert (!DECL_WEAK (vnode->decl)
- || TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl));
+ gcc_assert (!DECL_WEAK (vnode->symbol.decl)
+ || TREE_PUBLIC (vnode->symbol.decl)
+ || DECL_EXTERNAL (vnode->symbol.decl));
/* In several cases declarations can not be common:
- when declaration has initializer
static int a __attribute__ ((common))
Canonicalize things here and clear the redundant flag. */
- if (DECL_COMMON (vnode->decl)
- && (!(TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl))
- || (DECL_INITIAL (vnode->decl)
- && DECL_INITIAL (vnode->decl) != error_mark_node)
- || DECL_WEAK (vnode->decl)
- || DECL_SECTION_NAME (vnode->decl) != NULL
+ if (DECL_COMMON (vnode->symbol.decl)
+ && (!(TREE_PUBLIC (vnode->symbol.decl)
+ || DECL_EXTERNAL (vnode->symbol.decl))
+ || (DECL_INITIAL (vnode->symbol.decl)
+ && DECL_INITIAL (vnode->symbol.decl) != error_mark_node)
+ || DECL_WEAK (vnode->symbol.decl)
+ || DECL_SECTION_NAME (vnode->symbol.decl) != NULL
|| ! (ADDR_SPACE_GENERIC_P
- (TYPE_ADDR_SPACE (TREE_TYPE (vnode->decl))))))
- DECL_COMMON (vnode->decl) = 0;
+ (TYPE_ADDR_SPACE (TREE_TYPE (vnode->symbol.decl))))))
+ DECL_COMMON (vnode->symbol.decl) = 0;
}
- for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
+ FOR_EACH_DEFINED_VARIABLE (vnode)
{
if (!vnode->finalized)
continue;
- if (vnode->needed
- && (DECL_COMDAT (vnode->decl) || TREE_PUBLIC (vnode->decl))
- && (!whole_program
- /* We can privatize comdat readonly variables whose address is not taken,
- but doing so is not going to bring us optimization oppurtunities until
- we start reordering datastructures. */
- || DECL_COMDAT (vnode->decl)
- || DECL_WEAK (vnode->decl)
- || lookup_attribute ("externally_visible",
- DECL_ATTRIBUTES (vnode->decl))))
- vnode->externally_visible = true;
+ if (varpool_externally_visible_p
+ (vnode,
+ pointer_set_contains (aliased_vnodes, vnode)))
+ vnode->symbol.externally_visible = true;
else
- vnode->externally_visible = false;
- if (!vnode->externally_visible)
+ vnode->symbol.externally_visible = false;
+ if (!vnode->symbol.externally_visible)
{
- gcc_assert (whole_program || !TREE_PUBLIC (vnode->decl));
- cgraph_make_decl_local (vnode->decl);
+ gcc_assert (in_lto_p || whole_program || !TREE_PUBLIC (vnode->symbol.decl));
+ symtab_make_decl_local (vnode->symbol.decl);
+ if (vnode->symbol.same_comdat_group)
+ symtab_dissolve_same_comdat_group_list ((symtab_node) vnode);
+ vnode->symbol.resolution = LDPR_PREVAILING_DEF_IRONLY;
}
- gcc_assert (TREE_STATIC (vnode->decl));
}
+ pointer_set_destroy (aliased_nodes);
+ pointer_set_destroy (aliased_vnodes);
if (dump_file)
{
fprintf (dump_file, "\nMarking local functions:");
- for (node = cgraph_nodes; node; node = node->next)
+ FOR_EACH_DEFINED_FUNCTION (node)
if (node->local.local)
fprintf (dump_file, " %s", cgraph_node_name (node));
fprintf (dump_file, "\n\n");
fprintf (dump_file, "\nMarking externally visible functions:");
- for (node = cgraph_nodes; node; node = node->next)
- if (node->local.externally_visible)
+ FOR_EACH_DEFINED_FUNCTION (node)
+ if (node->symbol.externally_visible)
fprintf (dump_file, " %s", cgraph_node_name (node));
fprintf (dump_file, "\n\n");
fprintf (dump_file, "\nMarking externally visible variables:");
- for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
- if (vnode->externally_visible)
+ FOR_EACH_DEFINED_VARIABLE (vnode)
+ if (vnode->symbol.externally_visible)
fprintf (dump_file, " %s", varpool_node_name (vnode));
fprintf (dump_file, "\n\n");
}
static unsigned int
local_function_and_variable_visibility (void)
{
- return function_and_variable_visibility (flag_whole_program && !flag_lto && !flag_whopr);
+ return function_and_variable_visibility (flag_whole_program && !flag_lto);
}
struct simple_ipa_opt_pass pass_ipa_function_and_variable_visibility =
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_remove_functions | TODO_dump_cgraph/* todo_flags_finish */
+ TODO_remove_functions | TODO_dump_symtab
+ | TODO_ggc_collect /* todo_flags_finish */
+ }
+};
+
+/* Free inline summary. */
+
+static unsigned
+free_inline_summary (void)
+{
+ inline_free_summary ();
+ return 0;
+}
+
+struct simple_ipa_opt_pass pass_ipa_free_inline_summary =
+{
+ {
+ SIMPLE_IPA_PASS,
+ "*free_inline_summary", /* name */
+ NULL, /* gate */
+ free_inline_summary, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_IPA_FREE_INLINE_SUMMARY, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_ggc_collect /* todo_flags_finish */
}
};
return !flag_ltrans;
}
-/* Bring functionss local at LTO time whith -fwhole-program. */
+/* Bring functionss local at LTO time with -fwhole-program. */
static unsigned int
whole_program_function_and_variable_visibility (void)
{
- struct cgraph_node *node;
- struct varpool_node *vnode;
-
function_and_variable_visibility (flag_whole_program);
-
- for (node = cgraph_nodes; node; node = node->next)
- if ((node->local.externally_visible && !DECL_COMDAT (node->decl))
- && node->local.finalized)
- cgraph_mark_needed_node (node);
- for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
- if (vnode->externally_visible && !DECL_COMDAT (vnode->decl))
- varpool_mark_needed_node (vnode);
- if (dump_file)
- {
- fprintf (dump_file, "\nNeeded variables:");
- for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
- if (vnode->needed)
- fprintf (dump_file, " %s", varpool_node_name (vnode));
- fprintf (dump_file, "\n\n");
- }
+ if (optimize)
+ ipa_discover_readonly_nonaddressable_vars ();
return 0;
}
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_dump_cgraph | TODO_remove_functions/* todo_flags_finish */
+ TODO_remove_functions | TODO_dump_symtab
+ | TODO_ggc_collect /* todo_flags_finish */
},
NULL, /* generate_summary */
NULL, /* write_summary */
NULL, /* read_summary */
- NULL, /* function_read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
NULL, /* stmt_fixup */
0, /* TODOs */
NULL, /* function_transform */
NULL, /* variable_transform */
};
-/* Hash a cgraph node set element. */
-
-static hashval_t
-hash_cgraph_node_set_element (const void *p)
-{
- const_cgraph_node_set_element element = (const_cgraph_node_set_element) p;
- return htab_hash_pointer (element->node);
-}
-/* Compare two cgraph node set elements. */
+/* Simple ipa profile pass propagating frequencies across the callgraph. */
-static int
-eq_cgraph_node_set_element (const void *p1, const void *p2)
+static unsigned int
+ipa_profile (void)
{
- const_cgraph_node_set_element e1 = (const_cgraph_node_set_element) p1;
- const_cgraph_node_set_element e2 = (const_cgraph_node_set_element) p2;
+ struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
+ struct cgraph_edge *e;
+ int order_pos;
+ bool something_changed = false;
+ int i;
- return e1->node == e2->node;
+ order_pos = ipa_reverse_postorder (order);
+ for (i = order_pos - 1; i >= 0; i--)
+ {
+ if (order[i]->local.local && cgraph_propagate_frequency (order[i]))
+ {
+ for (e = order[i]->callees; e; e = e->next_callee)
+ if (e->callee->local.local && !e->callee->symbol.aux)
+ {
+ something_changed = true;
+ e->callee->symbol.aux = (void *)1;
+ }
+ }
+ order[i]->symbol.aux = NULL;
+ }
+
+ while (something_changed)
+ {
+ something_changed = false;
+ for (i = order_pos - 1; i >= 0; i--)
+ {
+ if (order[i]->symbol.aux && cgraph_propagate_frequency (order[i]))
+ {
+ for (e = order[i]->callees; e; e = e->next_callee)
+ if (e->callee->local.local && !e->callee->symbol.aux)
+ {
+ something_changed = true;
+ e->callee->symbol.aux = (void *)1;
+ }
+ }
+ order[i]->symbol.aux = NULL;
+ }
+ }
+ free (order);
+ return 0;
}
-/* Create a new cgraph node set. */
+static bool
+gate_ipa_profile (void)
+{
+ return flag_ipa_profile;
+}
-cgraph_node_set
-cgraph_node_set_new (void)
+struct ipa_opt_pass_d pass_ipa_profile =
{
- cgraph_node_set new_node_set;
+ {
+ IPA_PASS,
+ "profile_estimate", /* name */
+ gate_ipa_profile, /* gate */
+ ipa_profile, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_IPA_PROFILE, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0 /* todo_flags_finish */
+ },
+ NULL, /* generate_summary */
+ NULL, /* write_summary */
+ NULL, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* TODOs */
+ NULL, /* function_transform */
+ NULL /* variable_transform */
+};
- new_node_set = GGC_NEW (struct cgraph_node_set_def);
- new_node_set->hashtab = htab_create_ggc (10,
- hash_cgraph_node_set_element,
- eq_cgraph_node_set_element,
- NULL);
- new_node_set->nodes = NULL;
- return new_node_set;
-}
+/* Generate and emit a static constructor or destructor. WHICH must
+ be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
+ is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
+ initialization priority for this constructor or destructor.
-/* Add cgraph_node NODE to cgraph_node_set SET. */
+ FINAL specify whether the externally visible name for collect2 should
+ be produced. */
-void
-cgraph_node_set_add (cgraph_node_set set, struct cgraph_node *node)
+static void
+cgraph_build_static_cdtor_1 (char which, tree body, int priority, bool final)
{
- void **slot;
- cgraph_node_set_element element;
- struct cgraph_node_set_element_def dummy;
+ static int counter = 0;
+ char which_buf[16];
+ tree decl, name, resdecl;
+
+ /* The priority is encoded in the constructor or destructor name.
+ collect2 will sort the names and arrange that they are called at
+ program startup. */
+ if (final)
+ sprintf (which_buf, "%c_%.5d_%d", which, priority, counter++);
+ else
+ /* Proudce sane name but one not recognizable by collect2, just for the
+ case we fail to inline the function. */
+ sprintf (which_buf, "sub_%c_%.5d_%d", which, priority, counter++);
+ name = get_file_function_name (which_buf);
+
+ decl = build_decl (input_location, FUNCTION_DECL, name,
+ build_function_type_list (void_type_node, NULL_TREE));
+ current_function_decl = decl;
+
+ resdecl = build_decl (input_location,
+ RESULT_DECL, NULL_TREE, void_type_node);
+ DECL_ARTIFICIAL (resdecl) = 1;
+ DECL_RESULT (decl) = resdecl;
+ DECL_CONTEXT (resdecl) = decl;
+
+ allocate_struct_function (decl, false);
+
+ TREE_STATIC (decl) = 1;
+ TREE_USED (decl) = 1;
+ DECL_ARTIFICIAL (decl) = 1;
+ DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
+ DECL_SAVED_TREE (decl) = body;
+ if (!targetm.have_ctors_dtors && final)
+ {
+ TREE_PUBLIC (decl) = 1;
+ DECL_PRESERVE_P (decl) = 1;
+ }
+ DECL_UNINLINABLE (decl) = 1;
+
+ DECL_INITIAL (decl) = make_node (BLOCK);
+ TREE_USED (DECL_INITIAL (decl)) = 1;
- dummy.node = node;
- slot = htab_find_slot (set->hashtab, &dummy, INSERT);
+ DECL_SOURCE_LOCATION (decl) = input_location;
+ cfun->function_end_locus = input_location;
- if (*slot != HTAB_EMPTY_ENTRY)
+ switch (which)
{
- element = (cgraph_node_set_element) *slot;
- gcc_assert (node == element->node
- && (VEC_index (cgraph_node_ptr, set->nodes, element->index)
- == node));
- return;
+ case 'I':
+ DECL_STATIC_CONSTRUCTOR (decl) = 1;
+ decl_init_priority_insert (decl, priority);
+ break;
+ case 'D':
+ DECL_STATIC_DESTRUCTOR (decl) = 1;
+ decl_fini_priority_insert (decl, priority);
+ break;
+ default:
+ gcc_unreachable ();
}
- /* Insert node into hash table. */
- element =
- (cgraph_node_set_element) GGC_NEW (struct cgraph_node_set_element_def);
- element->node = node;
- element->index = VEC_length (cgraph_node_ptr, set->nodes);
- *slot = element;
+ gimplify_function_tree (decl);
- /* Insert into node vector. */
- VEC_safe_push (cgraph_node_ptr, gc, set->nodes, node);
+ cgraph_add_new_function (decl, false);
+
+ set_cfun (NULL);
+ current_function_decl = NULL;
}
-/* Remove cgraph_node NODE from cgraph_node_set SET. */
+/* Generate and emit a static constructor or destructor. WHICH must
+ be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
+ is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
+ initialization priority for this constructor or destructor. */
void
-cgraph_node_set_remove (cgraph_node_set set, struct cgraph_node *node)
+cgraph_build_static_cdtor (char which, tree body, int priority)
{
- void **slot, **last_slot;
- cgraph_node_set_element element, last_element;
- struct cgraph_node *last_node;
- struct cgraph_node_set_element_def dummy;
+ cgraph_build_static_cdtor_1 (which, body, priority, false);
+}
- dummy.node = node;
- slot = htab_find_slot (set->hashtab, &dummy, NO_INSERT);
- if (slot == NULL)
- return;
+/* A vector of FUNCTION_DECLs declared as static constructors. */
+static VEC(tree, heap) *static_ctors;
+/* A vector of FUNCTION_DECLs declared as static destructors. */
+static VEC(tree, heap) *static_dtors;
- element = (cgraph_node_set_element) *slot;
- gcc_assert (VEC_index (cgraph_node_ptr, set->nodes, element->index)
- == node);
+/* When target does not have ctors and dtors, we call all constructor
+ and destructor by special initialization/destruction function
+ recognized by collect2.
- /* Remove from vector. We do this by swapping node with the last element
- of the vector. */
- last_node = VEC_pop (cgraph_node_ptr, set->nodes);
- if (last_node != node)
- {
- dummy.node = last_node;
- last_slot = htab_find_slot (set->hashtab, &dummy, NO_INSERT);
- last_element = (cgraph_node_set_element) *last_slot;
- gcc_assert (last_element);
-
- /* Move the last element to the original spot of NODE. */
- last_element->index = element->index;
- VEC_replace (cgraph_node_ptr, set->nodes, last_element->index,
- last_node);
- }
+ When we are going to build this function, collect all constructors and
+ destructors and turn them into normal functions. */
- /* Remove element from hash table. */
- htab_clear_slot (set->hashtab, slot);
- ggc_free (element);
+static void
+record_cdtor_fn (struct cgraph_node *node)
+{
+ if (DECL_STATIC_CONSTRUCTOR (node->symbol.decl))
+ VEC_safe_push (tree, heap, static_ctors, node->symbol.decl);
+ if (DECL_STATIC_DESTRUCTOR (node->symbol.decl))
+ VEC_safe_push (tree, heap, static_dtors, node->symbol.decl);
+ node = cgraph_get_node (node->symbol.decl);
+ DECL_DISREGARD_INLINE_LIMITS (node->symbol.decl) = 1;
}
-/* Find NODE in SET and return an iterator to it if found. A null iterator
- is returned if NODE is not in SET. */
+/* Define global constructors/destructor functions for the CDTORS, of
+ which they are LEN. The CDTORS are sorted by initialization
+ priority. If CTOR_P is true, these are constructors; otherwise,
+ they are destructors. */
-cgraph_node_set_iterator
-cgraph_node_set_find (cgraph_node_set set, struct cgraph_node *node)
+static void
+build_cdtor (bool ctor_p, VEC (tree, heap) *cdtors)
{
- void **slot;
- struct cgraph_node_set_element_def dummy;
- cgraph_node_set_element element;
- cgraph_node_set_iterator csi;
+ size_t i,j;
+ size_t len = VEC_length (tree, cdtors);
- dummy.node = node;
- slot = htab_find_slot (set->hashtab, &dummy, NO_INSERT);
- if (slot == NULL)
- csi.index = (unsigned) ~0;
- else
+ i = 0;
+ while (i < len)
{
- element = (cgraph_node_set_element) *slot;
- gcc_assert (VEC_index (cgraph_node_ptr, set->nodes, element->index)
- == node);
- csi.index = element->index;
+ tree body;
+ tree fn;
+ priority_type priority;
+
+ priority = 0;
+ body = NULL_TREE;
+ j = i;
+ do
+ {
+ priority_type p;
+ fn = VEC_index (tree, cdtors, j);
+ p = ctor_p ? DECL_INIT_PRIORITY (fn) : DECL_FINI_PRIORITY (fn);
+ if (j == i)
+ priority = p;
+ else if (p != priority)
+ break;
+ j++;
+ }
+ while (j < len);
+
+ /* When there is only one cdtor and target supports them, do nothing. */
+ if (j == i + 1
+ && targetm.have_ctors_dtors)
+ {
+ i++;
+ continue;
+ }
+ /* Find the next batch of constructors/destructors with the same
+ initialization priority. */
+ for (;i < j; i++)
+ {
+ tree call;
+ fn = VEC_index (tree, cdtors, i);
+ call = build_call_expr (fn, 0);
+ if (ctor_p)
+ DECL_STATIC_CONSTRUCTOR (fn) = 0;
+ else
+ DECL_STATIC_DESTRUCTOR (fn) = 0;
+ /* We do not want to optimize away pure/const calls here.
+ When optimizing, these should be already removed, when not
+ optimizing, we want user to be able to breakpoint in them. */
+ TREE_SIDE_EFFECTS (call) = 1;
+ append_to_statement_list (call, &body);
+ }
+ gcc_assert (body != NULL_TREE);
+ /* Generate a function to call all the function of like
+ priority. */
+ cgraph_build_static_cdtor_1 (ctor_p ? 'I' : 'D', body, priority, true);
}
- csi.set = set;
+}
+
+/* Comparison function for qsort. P1 and P2 are actually of type
+ "tree *" and point to static constructors. DECL_INIT_PRIORITY is
+ used to determine the sort order. */
- return csi;
+static int
+compare_ctor (const void *p1, const void *p2)
+{
+ tree f1;
+ tree f2;
+ int priority1;
+ int priority2;
+
+ f1 = *(const tree *)p1;
+ f2 = *(const tree *)p2;
+ priority1 = DECL_INIT_PRIORITY (f1);
+ priority2 = DECL_INIT_PRIORITY (f2);
+
+ if (priority1 < priority2)
+ return -1;
+ else if (priority1 > priority2)
+ return 1;
+ else
+ /* Ensure a stable sort. Constructors are executed in backwarding
+ order to make LTO initialize braries first. */
+ return DECL_UID (f2) - DECL_UID (f1);
}
-/* Dump content of SET to file F. */
+/* Comparison function for qsort. P1 and P2 are actually of type
+ "tree *" and point to static destructors. DECL_FINI_PRIORITY is
+ used to determine the sort order. */
-void
-dump_cgraph_node_set (FILE *f, cgraph_node_set set)
+static int
+compare_dtor (const void *p1, const void *p2)
{
- cgraph_node_set_iterator iter;
+ tree f1;
+ tree f2;
+ int priority1;
+ int priority2;
+
+ f1 = *(const tree *)p1;
+ f2 = *(const tree *)p2;
+ priority1 = DECL_FINI_PRIORITY (f1);
+ priority2 = DECL_FINI_PRIORITY (f2);
+
+ if (priority1 < priority2)
+ return -1;
+ else if (priority1 > priority2)
+ return 1;
+ else
+ /* Ensure a stable sort. */
+ return DECL_UID (f1) - DECL_UID (f2);
+}
+
+/* Generate functions to call static constructors and destructors
+ for targets that do not support .ctors/.dtors sections. These
+ functions have magic names which are detected by collect2. */
- for (iter = csi_start (set); !csi_end_p (iter); csi_next (&iter))
+static void
+build_cdtor_fns (void)
+{
+ if (!VEC_empty (tree, static_ctors))
{
- struct cgraph_node *node = csi_node (iter);
- dump_cgraph_node (f, node);
+ gcc_assert (!targetm.have_ctors_dtors || in_lto_p);
+ VEC_qsort (tree, static_ctors, compare_ctor);
+ build_cdtor (/*ctor_p=*/true, static_ctors);
+ }
+
+ if (!VEC_empty (tree, static_dtors))
+ {
+ gcc_assert (!targetm.have_ctors_dtors || in_lto_p);
+ VEC_qsort (tree, static_dtors, compare_dtor);
+ build_cdtor (/*ctor_p=*/false, static_dtors);
}
}
-/* Dump content of SET to stderr. */
+/* Look for constructors and destructors and produce function calling them.
+ This is needed for targets not supporting ctors or dtors, but we perform the
+ transformation also at linktime to merge possibly numerous
+ constructors/destructors into single function to improve code locality and
+ reduce size. */
-void
-debug_cgraph_node_set (cgraph_node_set set)
+static unsigned int
+ipa_cdtor_merge (void)
+{
+ struct cgraph_node *node;
+ FOR_EACH_DEFINED_FUNCTION (node)
+ if (DECL_STATIC_CONSTRUCTOR (node->symbol.decl)
+ || DECL_STATIC_DESTRUCTOR (node->symbol.decl))
+ record_cdtor_fn (node);
+ build_cdtor_fns ();
+ VEC_free (tree, heap, static_ctors);
+ VEC_free (tree, heap, static_dtors);
+ return 0;
+}
+
+/* Perform the pass when we have no ctors/dtors support
+ or at LTO time to merge multiple constructors into single
+ function. */
+
+static bool
+gate_ipa_cdtor_merge (void)
{
- dump_cgraph_node_set (stderr, set);
+ return !targetm.have_ctors_dtors || (optimize && in_lto_p);
}
+struct ipa_opt_pass_d pass_ipa_cdtor_merge =
+{
+ {
+ IPA_PASS,
+ "cdtor", /* name */
+ gate_ipa_cdtor_merge, /* gate */
+ ipa_cdtor_merge, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_CGRAPHOPT, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0 /* todo_flags_finish */
+ },
+ NULL, /* generate_summary */
+ NULL, /* write_summary */
+ NULL, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* TODOs */
+ NULL, /* function_transform */
+ NULL /* variable_transform */
+};