/* Basic IPA optimizations and utilities.
|
/* Basic IPA optimizations and utilities.
|
Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
|
Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "gimple.h"
|
#include "gimple.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
|
|
/* Fill array order with all nodes with output flag set in the reverse
|
/* Fill array order with all nodes with output flag set in the reverse
|
topological order. */
|
topological order. */
|
|
|
int
|
int
|
cgraph_postorder (struct cgraph_node **order)
|
cgraph_postorder (struct cgraph_node **order)
|
{
|
{
|
struct cgraph_node *node, *node2;
|
struct cgraph_node *node, *node2;
|
int stack_size = 0;
|
int stack_size = 0;
|
int order_pos = 0;
|
int order_pos = 0;
|
struct cgraph_edge *edge, last;
|
struct cgraph_edge *edge, last;
|
int pass;
|
int pass;
|
|
|
struct cgraph_node **stack =
|
struct cgraph_node **stack =
|
XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
|
XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
|
|
|
/* We have to deal with cycles nicely, so use a depth first traversal
|
/* We have to deal with cycles nicely, so use a depth first traversal
|
output algorithm. Ignore the fact that some functions won't need
|
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
|
to be output and put them into order as well, so we get dependencies
|
right through inline functions. */
|
right through inline functions. */
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
node->aux = NULL;
|
node->aux = NULL;
|
for (pass = 0; pass < 2; pass++)
|
for (pass = 0; pass < 2; pass++)
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
if (!node->aux
|
if (!node->aux
|
&& (pass
|
&& (pass
|
|| (!cgraph_only_called_directly_p (node)
|
|| (!cgraph_only_called_directly_p (node)
|
&& !node->address_taken)))
|
&& !node->address_taken)))
|
{
|
{
|
node2 = node;
|
node2 = node;
|
if (!node->callers)
|
if (!node->callers)
|
node->aux = &last;
|
node->aux = &last;
|
else
|
else
|
node->aux = node->callers;
|
node->aux = node->callers;
|
while (node2)
|
while (node2)
|
{
|
{
|
while (node2->aux != &last)
|
while (node2->aux != &last)
|
{
|
{
|
edge = (struct cgraph_edge *) node2->aux;
|
edge = (struct cgraph_edge *) node2->aux;
|
if (edge->next_caller)
|
if (edge->next_caller)
|
node2->aux = edge->next_caller;
|
node2->aux = edge->next_caller;
|
else
|
else
|
node2->aux = &last;
|
node2->aux = &last;
|
if (!edge->caller->aux)
|
if (!edge->caller->aux)
|
{
|
{
|
if (!edge->caller->callers)
|
if (!edge->caller->callers)
|
edge->caller->aux = &last;
|
edge->caller->aux = &last;
|
else
|
else
|
edge->caller->aux = edge->caller->callers;
|
edge->caller->aux = edge->caller->callers;
|
stack[stack_size++] = node2;
|
stack[stack_size++] = node2;
|
node2 = edge->caller;
|
node2 = edge->caller;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (node2->aux == &last)
|
if (node2->aux == &last)
|
{
|
{
|
order[order_pos++] = node2;
|
order[order_pos++] = node2;
|
if (stack_size)
|
if (stack_size)
|
node2 = stack[--stack_size];
|
node2 = stack[--stack_size];
|
else
|
else
|
node2 = NULL;
|
node2 = NULL;
|
}
|
}
|
}
|
}
|
}
|
}
|
free (stack);
|
free (stack);
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
node->aux = NULL;
|
node->aux = NULL;
|
return order_pos;
|
return order_pos;
|
}
|
}
|
|
|
/* Look for all functions inlined to NODE and update their inlined_to pointers
|
/* Look for all functions inlined to NODE and update their inlined_to pointers
|
to INLINED_TO. */
|
to INLINED_TO. */
|
|
|
static void
|
static void
|
update_inlined_to_pointer (struct cgraph_node *node, struct cgraph_node *inlined_to)
|
update_inlined_to_pointer (struct cgraph_node *node, struct cgraph_node *inlined_to)
|
{
|
{
|
struct cgraph_edge *e;
|
struct cgraph_edge *e;
|
for (e = node->callees; e; e = e->next_callee)
|
for (e = node->callees; e; e = e->next_callee)
|
if (e->callee->global.inlined_to)
|
if (e->callee->global.inlined_to)
|
{
|
{
|
e->callee->global.inlined_to = inlined_to;
|
e->callee->global.inlined_to = inlined_to;
|
update_inlined_to_pointer (e->callee, inlined_to);
|
update_inlined_to_pointer (e->callee, inlined_to);
|
}
|
}
|
}
|
}
|
|
|
/* Perform reachability analysis and reclaim all unreachable nodes.
|
/* Perform reachability analysis and reclaim all unreachable nodes.
|
If BEFORE_INLINING_P is true this function is called before inlining
|
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
|
decisions has been made. If BEFORE_INLINING_P is false this function also
|
removes unneeded bodies of extern inline functions. */
|
removes unneeded bodies of extern inline functions. */
|
|
|
bool
|
bool
|
cgraph_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
|
cgraph_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
|
{
|
{
|
struct cgraph_node *first = (struct cgraph_node *) (void *) 1;
|
struct cgraph_node *first = (struct cgraph_node *) (void *) 1;
|
struct cgraph_node *processed = (struct cgraph_node *) (void *) 2;
|
struct cgraph_node *processed = (struct cgraph_node *) (void *) 2;
|
struct cgraph_node *node, *next;
|
struct cgraph_node *node, *next;
|
bool changed = false;
|
bool changed = false;
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
verify_cgraph ();
|
verify_cgraph ();
|
#endif
|
#endif
|
if (file)
|
if (file)
|
fprintf (file, "\nReclaiming functions:");
|
fprintf (file, "\nReclaiming functions:");
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
gcc_assert (!node->aux);
|
gcc_assert (!node->aux);
|
#endif
|
#endif
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
if (!cgraph_can_remove_if_no_direct_calls_p (node)
|
if (!cgraph_can_remove_if_no_direct_calls_p (node)
|
&& ((!DECL_EXTERNAL (node->decl))
|
&& ((!DECL_EXTERNAL (node->decl))
|
|| !node->analyzed
|
|| !node->analyzed
|
|| before_inlining_p))
|
|| before_inlining_p))
|
{
|
{
|
gcc_assert (!node->global.inlined_to);
|
gcc_assert (!node->global.inlined_to);
|
node->aux = first;
|
node->aux = first;
|
first = node;
|
first = node;
|
node->reachable = true;
|
node->reachable = true;
|
}
|
}
|
else
|
else
|
{
|
{
|
gcc_assert (!node->aux);
|
gcc_assert (!node->aux);
|
node->reachable = false;
|
node->reachable = false;
|
}
|
}
|
|
|
/* Perform reachability analysis. As a special case do not consider
|
/* Perform reachability analysis. As a special case do not consider
|
extern inline functions not inlined as live because we won't output
|
extern inline functions not inlined as live because we won't output
|
them at all. */
|
them at all. */
|
while (first != (void *) 1)
|
while (first != (void *) 1)
|
{
|
{
|
struct cgraph_edge *e;
|
struct cgraph_edge *e;
|
node = first;
|
node = first;
|
first = (struct cgraph_node *) first->aux;
|
first = (struct cgraph_node *) first->aux;
|
node->aux = processed;
|
node->aux = processed;
|
|
|
if (node->reachable)
|
if (node->reachable)
|
for (e = node->callees; e; e = e->next_callee)
|
for (e = node->callees; e; e = e->next_callee)
|
if (!e->callee->reachable
|
if (!e->callee->reachable
|
&& node->analyzed
|
&& node->analyzed
|
&& (!e->inline_failed || !e->callee->analyzed
|
&& (!e->inline_failed || !e->callee->analyzed
|
|| (!DECL_EXTERNAL (e->callee->decl))
|
|| (!DECL_EXTERNAL (e->callee->decl))
|
|| before_inlining_p))
|
|| before_inlining_p))
|
{
|
{
|
bool prev_reachable = e->callee->reachable;
|
bool prev_reachable = e->callee->reachable;
|
e->callee->reachable |= node->reachable;
|
e->callee->reachable |= node->reachable;
|
if (!e->callee->aux
|
if (!e->callee->aux
|
|| (e->callee->aux == processed
|
|| (e->callee->aux == processed
|
&& prev_reachable != e->callee->reachable))
|
&& prev_reachable != e->callee->reachable))
|
{
|
{
|
e->callee->aux = first;
|
e->callee->aux = first;
|
first = e->callee;
|
first = e->callee;
|
}
|
}
|
}
|
}
|
|
|
/* If any function in a comdat group is reachable, force
|
/* If any function in a comdat group is reachable, force
|
all other functions in the same comdat group to be
|
all other functions in the same comdat group to be
|
also reachable. */
|
also reachable. */
|
if (node->same_comdat_group
|
if (node->same_comdat_group
|
&& node->reachable
|
&& node->reachable
|
&& !node->global.inlined_to)
|
&& !node->global.inlined_to)
|
{
|
{
|
for (next = node->same_comdat_group;
|
for (next = node->same_comdat_group;
|
next != node;
|
next != node;
|
next = next->same_comdat_group)
|
next = next->same_comdat_group)
|
if (!next->reachable)
|
if (!next->reachable)
|
{
|
{
|
next->aux = first;
|
next->aux = first;
|
first = next;
|
first = next;
|
next->reachable = true;
|
next->reachable = true;
|
}
|
}
|
}
|
}
|
|
|
/* We can freely remove inline clones even if they are cloned, however if
|
/* 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
|
function is clone of real clone, we must keep it around in order to
|
make materialize_clones produce function body with the changes
|
make materialize_clones produce function body with the changes
|
applied. */
|
applied. */
|
while (node->clone_of && !node->clone_of->aux && !gimple_has_body_p (node->decl))
|
while (node->clone_of && !node->clone_of->aux && !gimple_has_body_p (node->decl))
|
{
|
{
|
bool noninline = node->clone_of->decl != node->decl;
|
bool noninline = node->clone_of->decl != node->decl;
|
node = node->clone_of;
|
node = node->clone_of;
|
if (noninline)
|
if (noninline)
|
{
|
{
|
node->aux = first;
|
node->aux = first;
|
first = node;
|
first = node;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Remove unreachable nodes. Extern inline functions need special care;
|
/* Remove unreachable nodes. Extern inline functions need special care;
|
Unreachable extern inline functions shall be removed.
|
Unreachable extern inline functions shall be removed.
|
Reachable extern inline functions we never inlined shall get their bodies
|
Reachable extern inline functions we never inlined shall get their bodies
|
eliminated.
|
eliminated.
|
Reachable extern inline functions we sometimes inlined will be turned into
|
Reachable extern inline functions we sometimes inlined will be turned into
|
unanalyzed nodes so they look like for true extern functions to the rest
|
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
|
of code. Body of such functions is released via remove_node once the
|
inline clones are eliminated. */
|
inline clones are eliminated. */
|
for (node = cgraph_nodes; node; node = next)
|
for (node = cgraph_nodes; node; node = next)
|
{
|
{
|
next = node->next;
|
next = node->next;
|
if (node->aux && !node->reachable)
|
if (node->aux && !node->reachable)
|
{
|
{
|
cgraph_node_remove_callees (node);
|
cgraph_node_remove_callees (node);
|
node->analyzed = false;
|
node->analyzed = false;
|
node->local.inlinable = false;
|
node->local.inlinable = false;
|
}
|
}
|
if (!node->aux)
|
if (!node->aux)
|
{
|
{
|
node->global.inlined_to = NULL;
|
node->global.inlined_to = NULL;
|
if (file)
|
if (file)
|
fprintf (file, " %s", cgraph_node_name (node));
|
fprintf (file, " %s", cgraph_node_name (node));
|
if (!node->analyzed || !DECL_EXTERNAL (node->decl) || before_inlining_p)
|
if (!node->analyzed || !DECL_EXTERNAL (node->decl) || before_inlining_p)
|
cgraph_remove_node (node);
|
cgraph_remove_node (node);
|
else
|
else
|
{
|
{
|
struct cgraph_edge *e;
|
struct cgraph_edge *e;
|
|
|
/* See if there is reachable caller. */
|
/* See if there is reachable caller. */
|
for (e = node->callers; e; e = e->next_caller)
|
for (e = node->callers; e; e = e->next_caller)
|
if (e->caller->aux)
|
if (e->caller->aux)
|
break;
|
break;
|
|
|
/* If so, we need to keep node in the callgraph. */
|
/* If so, we need to keep node in the callgraph. */
|
if (e || node->needed)
|
if (e || node->needed)
|
{
|
{
|
struct cgraph_node *clone;
|
struct cgraph_node *clone;
|
|
|
/* If there are still clones, we must keep body around.
|
/* If there are still clones, we must keep body around.
|
Otherwise we can just remove the body but keep the clone. */
|
Otherwise we can just remove the body but keep the clone. */
|
for (clone = node->clones; clone;
|
for (clone = node->clones; clone;
|
clone = clone->next_sibling_clone)
|
clone = clone->next_sibling_clone)
|
if (clone->aux)
|
if (clone->aux)
|
break;
|
break;
|
if (!clone)
|
if (!clone)
|
{
|
{
|
cgraph_release_function_body (node);
|
cgraph_release_function_body (node);
|
node->analyzed = false;
|
node->analyzed = false;
|
node->local.inlinable = false;
|
node->local.inlinable = false;
|
}
|
}
|
cgraph_node_remove_callees (node);
|
cgraph_node_remove_callees (node);
|
if (node->prev_sibling_clone)
|
if (node->prev_sibling_clone)
|
node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
|
node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
|
else if (node->clone_of)
|
else if (node->clone_of)
|
node->clone_of->clones = node->next_sibling_clone;
|
node->clone_of->clones = node->next_sibling_clone;
|
if (node->next_sibling_clone)
|
if (node->next_sibling_clone)
|
node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
|
node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
|
node->clone_of = NULL;
|
node->clone_of = NULL;
|
node->next_sibling_clone = NULL;
|
node->next_sibling_clone = NULL;
|
node->prev_sibling_clone = NULL;
|
node->prev_sibling_clone = NULL;
|
}
|
}
|
else
|
else
|
cgraph_remove_node (node);
|
cgraph_remove_node (node);
|
}
|
}
|
changed = true;
|
changed = true;
|
}
|
}
|
}
|
}
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
{
|
{
|
/* Inline clones might be kept around so their materializing allows further
|
/* Inline clones might be kept around so their materializing allows further
|
cloning. If the function the clone is inlined into is removed, we need
|
cloning. If the function the clone is inlined into is removed, we need
|
to turn it into normal cone. */
|
to turn it into normal cone. */
|
if (node->global.inlined_to
|
if (node->global.inlined_to
|
&& !node->callers)
|
&& !node->callers)
|
{
|
{
|
gcc_assert (node->clones);
|
gcc_assert (node->clones);
|
node->global.inlined_to = NULL;
|
node->global.inlined_to = NULL;
|
update_inlined_to_pointer (node, node);
|
update_inlined_to_pointer (node, node);
|
}
|
}
|
node->aux = NULL;
|
node->aux = NULL;
|
}
|
}
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
verify_cgraph ();
|
verify_cgraph ();
|
#endif
|
#endif
|
|
|
/* Reclaim alias pairs for functions that have disappeared from the
|
/* Reclaim alias pairs for functions that have disappeared from the
|
call graph. */
|
call graph. */
|
remove_unreachable_alias_pairs ();
|
remove_unreachable_alias_pairs ();
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
static bool
|
static bool
|
cgraph_externally_visible_p (struct cgraph_node *node, bool whole_program)
|
cgraph_externally_visible_p (struct cgraph_node *node, bool whole_program)
|
{
|
{
|
if (!node->local.finalized)
|
if (!node->local.finalized)
|
return false;
|
return false;
|
if (!DECL_COMDAT (node->decl)
|
if (!DECL_COMDAT (node->decl)
|
&& (!TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl)))
|
&& (!TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl)))
|
return false;
|
return false;
|
if (!whole_program)
|
if (!whole_program)
|
return true;
|
return true;
|
if (DECL_PRESERVE_P (node->decl))
|
if (DECL_PRESERVE_P (node->decl))
|
return true;
|
return true;
|
/* COMDAT functions must be shared only if they have address taken,
|
/* COMDAT functions must be shared only if they have address taken,
|
otherwise we can produce our own private implementation with
|
otherwise we can produce our own private implementation with
|
-fwhole-program. */
|
-fwhole-program. */
|
if (DECL_COMDAT (node->decl))
|
if (DECL_COMDAT (node->decl))
|
{
|
{
|
if (node->address_taken || !node->analyzed)
|
if (node->address_taken || !node->analyzed)
|
return true;
|
return true;
|
if (node->same_comdat_group)
|
if (node->same_comdat_group)
|
{
|
{
|
struct cgraph_node *next;
|
struct cgraph_node *next;
|
|
|
/* If more than one function is in the same COMDAT group, it must
|
/* 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
|
be shared even if just one function in the comdat group has
|
address taken. */
|
address taken. */
|
for (next = node->same_comdat_group;
|
for (next = node->same_comdat_group;
|
next != node;
|
next != node;
|
next = next->same_comdat_group)
|
next = next->same_comdat_group)
|
if (next->address_taken || !next->analyzed)
|
if (next->address_taken || !next->analyzed)
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
if (MAIN_NAME_P (DECL_NAME (node->decl)))
|
if (MAIN_NAME_P (DECL_NAME (node->decl)))
|
return true;
|
return true;
|
if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (node->decl)))
|
if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (node->decl)))
|
return true;
|
return true;
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Dissolve the same_comdat_group list in which NODE resides. */
|
/* Dissolve the same_comdat_group list in which NODE resides. */
|
|
|
static void
|
static void
|
dissolve_same_comdat_group_list (struct cgraph_node *node)
|
dissolve_same_comdat_group_list (struct cgraph_node *node)
|
{
|
{
|
struct cgraph_node *n = node, *next;
|
struct cgraph_node *n = node, *next;
|
do
|
do
|
{
|
{
|
next = n->same_comdat_group;
|
next = n->same_comdat_group;
|
n->same_comdat_group = NULL;
|
n->same_comdat_group = NULL;
|
n = next;
|
n = next;
|
}
|
}
|
while (n != node);
|
while (n != node);
|
}
|
}
|
|
|
/* Mark visibility of all functions.
|
/* Mark visibility of all functions.
|
|
|
A local function is one whose calls can occur only in the current
|
A local function is one whose calls can occur only in the current
|
compilation unit and all its calls are explicit, so we can change
|
compilation unit and all its calls are explicit, so we can change
|
its calling convention. We simply mark all static functions whose
|
its calling convention. We simply mark all static functions whose
|
address is not taken as local.
|
address is not taken as local.
|
|
|
We also change the TREE_PUBLIC flag of all declarations that are public
|
We also change the TREE_PUBLIC flag of all declarations that are public
|
in language point of view but we want to overwrite this default
|
in language point of view but we want to overwrite this default
|
via visibilities for the backend point of view. */
|
via visibilities for the backend point of view. */
|
|
|
static unsigned int
|
static unsigned int
|
function_and_variable_visibility (bool whole_program)
|
function_and_variable_visibility (bool whole_program)
|
{
|
{
|
struct cgraph_node *node;
|
struct cgraph_node *node;
|
struct varpool_node *vnode;
|
struct varpool_node *vnode;
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
{
|
{
|
/* C++ FE on lack of COMDAT support create local COMDAT functions
|
/* C++ FE on lack of COMDAT support create local COMDAT functions
|
(that ought to be shared but can not due to object format
|
(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 neccesary to keep the flag to make rest of C++ FE
|
happy. Clear the flag here to avoid confusion in middle-end. */
|
happy. Clear the flag here to avoid confusion in middle-end. */
|
if (DECL_COMDAT (node->decl) && !TREE_PUBLIC (node->decl))
|
if (DECL_COMDAT (node->decl) && !TREE_PUBLIC (node->decl))
|
DECL_COMDAT (node->decl) = 0;
|
DECL_COMDAT (node->decl) = 0;
|
/* For external decls stop tracking same_comdat_group, it doesn't matter
|
/* 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,
|
what comdat group they are in when they won't be emitted in this TU,
|
and simplifies later passes. */
|
and simplifies later passes. */
|
if (node->same_comdat_group && DECL_EXTERNAL (node->decl))
|
if (node->same_comdat_group && DECL_EXTERNAL (node->decl))
|
{
|
{
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
struct cgraph_node *n;
|
struct cgraph_node *n;
|
|
|
for (n = node->same_comdat_group;
|
for (n = node->same_comdat_group;
|
n != node;
|
n != node;
|
n = n->same_comdat_group)
|
n = n->same_comdat_group)
|
/* If at least one of same comdat group functions is external,
|
/* If at least one of same comdat group functions is external,
|
all of them have to be, otherwise it is a front-end bug. */
|
all of them have to be, otherwise it is a front-end bug. */
|
gcc_assert (DECL_EXTERNAL (n->decl));
|
gcc_assert (DECL_EXTERNAL (n->decl));
|
#endif
|
#endif
|
dissolve_same_comdat_group_list (node);
|
dissolve_same_comdat_group_list (node);
|
}
|
}
|
gcc_assert ((!DECL_WEAK (node->decl) && !DECL_COMDAT (node->decl))
|
gcc_assert ((!DECL_WEAK (node->decl) && !DECL_COMDAT (node->decl))
|
|| TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl));
|
|| TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl));
|
if (cgraph_externally_visible_p (node, whole_program))
|
if (cgraph_externally_visible_p (node, whole_program))
|
{
|
{
|
gcc_assert (!node->global.inlined_to);
|
gcc_assert (!node->global.inlined_to);
|
node->local.externally_visible = true;
|
node->local.externally_visible = true;
|
}
|
}
|
else
|
else
|
node->local.externally_visible = false;
|
node->local.externally_visible = false;
|
if (!node->local.externally_visible && node->analyzed
|
if (!node->local.externally_visible && node->analyzed
|
&& !DECL_EXTERNAL (node->decl))
|
&& !DECL_EXTERNAL (node->decl))
|
{
|
{
|
gcc_assert (whole_program || !TREE_PUBLIC (node->decl));
|
gcc_assert (whole_program || !TREE_PUBLIC (node->decl));
|
cgraph_make_decl_local (node->decl);
|
cgraph_make_decl_local (node->decl);
|
if (node->same_comdat_group)
|
if (node->same_comdat_group)
|
/* cgraph_externally_visible_p has already checked all other nodes
|
/* cgraph_externally_visible_p has already checked all other nodes
|
in the group and they will all be made local. We need to
|
in the group and they will all be made local. We need to
|
dissolve the group at once so that the predicate does not
|
dissolve the group at once so that the predicate does not
|
segfault though. */
|
segfault though. */
|
dissolve_same_comdat_group_list (node);
|
dissolve_same_comdat_group_list (node);
|
}
|
}
|
node->local.local = (cgraph_only_called_directly_p (node)
|
node->local.local = (cgraph_only_called_directly_p (node)
|
&& node->analyzed
|
&& node->analyzed
|
&& !DECL_EXTERNAL (node->decl)
|
&& !DECL_EXTERNAL (node->decl)
|
&& !node->local.externally_visible);
|
&& !node->local.externally_visible);
|
}
|
}
|
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
|
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
|
{
|
{
|
/* weak flag makes no sense on local variables. */
|
/* weak flag makes no sense on local variables. */
|
gcc_assert (!DECL_WEAK (vnode->decl)
|
gcc_assert (!DECL_WEAK (vnode->decl)
|
|| TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl));
|
|| TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl));
|
/* In several cases declarations can not be common:
|
/* In several cases declarations can not be common:
|
|
|
- when declaration has initializer
|
- when declaration has initializer
|
- when it is in weak
|
- when it is in weak
|
- when it has specific section
|
- when it has specific section
|
- when it resides in non-generic address space.
|
- when it resides in non-generic address space.
|
- if declaration is local, it will get into .local common section
|
- if declaration is local, it will get into .local common section
|
so common flag is not needed. Frontends still produce these in
|
so common flag is not needed. Frontends still produce these in
|
certain cases, such as for:
|
certain cases, such as for:
|
|
|
static int a __attribute__ ((common))
|
static int a __attribute__ ((common))
|
|
|
Canonicalize things here and clear the redundant flag. */
|
Canonicalize things here and clear the redundant flag. */
|
if (DECL_COMMON (vnode->decl)
|
if (DECL_COMMON (vnode->decl)
|
&& (!(TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl))
|
&& (!(TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl))
|
|| (DECL_INITIAL (vnode->decl)
|
|| (DECL_INITIAL (vnode->decl)
|
&& DECL_INITIAL (vnode->decl) != error_mark_node)
|
&& DECL_INITIAL (vnode->decl) != error_mark_node)
|
|| DECL_WEAK (vnode->decl)
|
|| DECL_WEAK (vnode->decl)
|
|| DECL_SECTION_NAME (vnode->decl) != NULL
|
|| DECL_SECTION_NAME (vnode->decl) != NULL
|
|| ! (ADDR_SPACE_GENERIC_P
|
|| ! (ADDR_SPACE_GENERIC_P
|
(TYPE_ADDR_SPACE (TREE_TYPE (vnode->decl))))))
|
(TYPE_ADDR_SPACE (TREE_TYPE (vnode->decl))))))
|
DECL_COMMON (vnode->decl) = 0;
|
DECL_COMMON (vnode->decl) = 0;
|
}
|
}
|
for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
|
for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
|
{
|
{
|
if (!vnode->finalized)
|
if (!vnode->finalized)
|
continue;
|
continue;
|
if (vnode->needed
|
if (vnode->needed
|
&& (DECL_COMDAT (vnode->decl) || TREE_PUBLIC (vnode->decl))
|
&& (DECL_COMDAT (vnode->decl) || TREE_PUBLIC (vnode->decl))
|
&& (!whole_program
|
&& (!whole_program
|
/* We can privatize comdat readonly variables whose address is not taken,
|
/* We can privatize comdat readonly variables whose address is not taken,
|
but doing so is not going to bring us optimization oppurtunities until
|
but doing so is not going to bring us optimization oppurtunities until
|
we start reordering datastructures. */
|
we start reordering datastructures. */
|
|| DECL_COMDAT (vnode->decl)
|
|| DECL_COMDAT (vnode->decl)
|
|| DECL_WEAK (vnode->decl)
|
|| DECL_WEAK (vnode->decl)
|
|| lookup_attribute ("externally_visible",
|
|| lookup_attribute ("externally_visible",
|
DECL_ATTRIBUTES (vnode->decl))))
|
DECL_ATTRIBUTES (vnode->decl))))
|
vnode->externally_visible = true;
|
vnode->externally_visible = true;
|
else
|
else
|
vnode->externally_visible = false;
|
vnode->externally_visible = false;
|
if (!vnode->externally_visible)
|
if (!vnode->externally_visible)
|
{
|
{
|
gcc_assert (whole_program || !TREE_PUBLIC (vnode->decl));
|
gcc_assert (whole_program || !TREE_PUBLIC (vnode->decl));
|
cgraph_make_decl_local (vnode->decl);
|
cgraph_make_decl_local (vnode->decl);
|
}
|
}
|
gcc_assert (TREE_STATIC (vnode->decl));
|
gcc_assert (TREE_STATIC (vnode->decl));
|
}
|
}
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "\nMarking local functions:");
|
fprintf (dump_file, "\nMarking local functions:");
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
if (node->local.local)
|
if (node->local.local)
|
fprintf (dump_file, " %s", cgraph_node_name (node));
|
fprintf (dump_file, " %s", cgraph_node_name (node));
|
fprintf (dump_file, "\n\n");
|
fprintf (dump_file, "\n\n");
|
fprintf (dump_file, "\nMarking externally visible functions:");
|
fprintf (dump_file, "\nMarking externally visible functions:");
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
if (node->local.externally_visible)
|
if (node->local.externally_visible)
|
fprintf (dump_file, " %s", cgraph_node_name (node));
|
fprintf (dump_file, " %s", cgraph_node_name (node));
|
fprintf (dump_file, "\n\n");
|
fprintf (dump_file, "\n\n");
|
fprintf (dump_file, "\nMarking externally visible variables:");
|
fprintf (dump_file, "\nMarking externally visible variables:");
|
for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
|
for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
|
if (vnode->externally_visible)
|
if (vnode->externally_visible)
|
fprintf (dump_file, " %s", varpool_node_name (vnode));
|
fprintf (dump_file, " %s", varpool_node_name (vnode));
|
fprintf (dump_file, "\n\n");
|
fprintf (dump_file, "\n\n");
|
}
|
}
|
cgraph_function_flags_ready = true;
|
cgraph_function_flags_ready = true;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Local function pass handling visibilities. This happens before LTO streaming
|
/* Local function pass handling visibilities. This happens before LTO streaming
|
so in particular -fwhole-program should be ignored at this level. */
|
so in particular -fwhole-program should be ignored at this level. */
|
|
|
static unsigned int
|
static unsigned int
|
local_function_and_variable_visibility (void)
|
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 && !flag_whopr);
|
}
|
}
|
|
|
struct simple_ipa_opt_pass pass_ipa_function_and_variable_visibility =
|
struct simple_ipa_opt_pass pass_ipa_function_and_variable_visibility =
|
{
|
{
|
{
|
{
|
SIMPLE_IPA_PASS,
|
SIMPLE_IPA_PASS,
|
"visibility", /* name */
|
"visibility", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
local_function_and_variable_visibility,/* execute */
|
local_function_and_variable_visibility,/* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_CGRAPHOPT, /* tv_id */
|
TV_CGRAPHOPT, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_remove_functions | TODO_dump_cgraph/* todo_flags_finish */
|
TODO_remove_functions | TODO_dump_cgraph/* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
/* Do not re-run on ltrans stage. */
|
/* Do not re-run on ltrans stage. */
|
|
|
static bool
|
static bool
|
gate_whole_program_function_and_variable_visibility (void)
|
gate_whole_program_function_and_variable_visibility (void)
|
{
|
{
|
return !flag_ltrans;
|
return !flag_ltrans;
|
}
|
}
|
|
|
/* Bring functionss local at LTO time whith -fwhole-program. */
|
/* Bring functionss local at LTO time whith -fwhole-program. */
|
|
|
static unsigned int
|
static unsigned int
|
whole_program_function_and_variable_visibility (void)
|
whole_program_function_and_variable_visibility (void)
|
{
|
{
|
struct cgraph_node *node;
|
struct cgraph_node *node;
|
struct varpool_node *vnode;
|
struct varpool_node *vnode;
|
|
|
function_and_variable_visibility (flag_whole_program);
|
function_and_variable_visibility (flag_whole_program);
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
if ((node->local.externally_visible && !DECL_COMDAT (node->decl))
|
if ((node->local.externally_visible && !DECL_COMDAT (node->decl))
|
&& node->local.finalized)
|
&& node->local.finalized)
|
cgraph_mark_needed_node (node);
|
cgraph_mark_needed_node (node);
|
for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
|
for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
|
if (vnode->externally_visible && !DECL_COMDAT (vnode->decl))
|
if (vnode->externally_visible && !DECL_COMDAT (vnode->decl))
|
varpool_mark_needed_node (vnode);
|
varpool_mark_needed_node (vnode);
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "\nNeeded variables:");
|
fprintf (dump_file, "\nNeeded variables:");
|
for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
|
for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
|
if (vnode->needed)
|
if (vnode->needed)
|
fprintf (dump_file, " %s", varpool_node_name (vnode));
|
fprintf (dump_file, " %s", varpool_node_name (vnode));
|
fprintf (dump_file, "\n\n");
|
fprintf (dump_file, "\n\n");
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct ipa_opt_pass_d pass_ipa_whole_program_visibility =
|
struct ipa_opt_pass_d pass_ipa_whole_program_visibility =
|
{
|
{
|
{
|
{
|
IPA_PASS,
|
IPA_PASS,
|
"whole-program", /* name */
|
"whole-program", /* name */
|
gate_whole_program_function_and_variable_visibility,/* gate */
|
gate_whole_program_function_and_variable_visibility,/* gate */
|
whole_program_function_and_variable_visibility,/* execute */
|
whole_program_function_and_variable_visibility,/* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_CGRAPHOPT, /* tv_id */
|
TV_CGRAPHOPT, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_cgraph | TODO_remove_functions/* todo_flags_finish */
|
TODO_dump_cgraph | TODO_remove_functions/* todo_flags_finish */
|
},
|
},
|
NULL, /* generate_summary */
|
NULL, /* generate_summary */
|
NULL, /* write_summary */
|
NULL, /* write_summary */
|
NULL, /* read_summary */
|
NULL, /* read_summary */
|
NULL, /* function_read_summary */
|
NULL, /* function_read_summary */
|
NULL, /* stmt_fixup */
|
NULL, /* stmt_fixup */
|
0, /* TODOs */
|
0, /* TODOs */
|
NULL, /* function_transform */
|
NULL, /* function_transform */
|
NULL, /* variable_transform */
|
NULL, /* variable_transform */
|
};
|
};
|
|
|
/* Hash a cgraph node set element. */
|
/* Hash a cgraph node set element. */
|
|
|
static hashval_t
|
static hashval_t
|
hash_cgraph_node_set_element (const void *p)
|
hash_cgraph_node_set_element (const void *p)
|
{
|
{
|
const_cgraph_node_set_element element = (const_cgraph_node_set_element) p;
|
const_cgraph_node_set_element element = (const_cgraph_node_set_element) p;
|
return htab_hash_pointer (element->node);
|
return htab_hash_pointer (element->node);
|
}
|
}
|
|
|
/* Compare two cgraph node set elements. */
|
/* Compare two cgraph node set elements. */
|
|
|
static int
|
static int
|
eq_cgraph_node_set_element (const void *p1, const void *p2)
|
eq_cgraph_node_set_element (const void *p1, const void *p2)
|
{
|
{
|
const_cgraph_node_set_element e1 = (const_cgraph_node_set_element) p1;
|
const_cgraph_node_set_element e1 = (const_cgraph_node_set_element) p1;
|
const_cgraph_node_set_element e2 = (const_cgraph_node_set_element) p2;
|
const_cgraph_node_set_element e2 = (const_cgraph_node_set_element) p2;
|
|
|
return e1->node == e2->node;
|
return e1->node == e2->node;
|
}
|
}
|
|
|
/* Create a new cgraph node set. */
|
/* Create a new cgraph node set. */
|
|
|
cgraph_node_set
|
cgraph_node_set
|
cgraph_node_set_new (void)
|
cgraph_node_set_new (void)
|
{
|
{
|
cgraph_node_set new_node_set;
|
cgraph_node_set new_node_set;
|
|
|
new_node_set = GGC_NEW (struct cgraph_node_set_def);
|
new_node_set = GGC_NEW (struct cgraph_node_set_def);
|
new_node_set->hashtab = htab_create_ggc (10,
|
new_node_set->hashtab = htab_create_ggc (10,
|
hash_cgraph_node_set_element,
|
hash_cgraph_node_set_element,
|
eq_cgraph_node_set_element,
|
eq_cgraph_node_set_element,
|
NULL);
|
NULL);
|
new_node_set->nodes = NULL;
|
new_node_set->nodes = NULL;
|
return new_node_set;
|
return new_node_set;
|
}
|
}
|
|
|
/* Add cgraph_node NODE to cgraph_node_set SET. */
|
/* Add cgraph_node NODE to cgraph_node_set SET. */
|
|
|
void
|
void
|
cgraph_node_set_add (cgraph_node_set set, struct cgraph_node *node)
|
cgraph_node_set_add (cgraph_node_set set, struct cgraph_node *node)
|
{
|
{
|
void **slot;
|
void **slot;
|
cgraph_node_set_element element;
|
cgraph_node_set_element element;
|
struct cgraph_node_set_element_def dummy;
|
struct cgraph_node_set_element_def dummy;
|
|
|
dummy.node = node;
|
dummy.node = node;
|
slot = htab_find_slot (set->hashtab, &dummy, INSERT);
|
slot = htab_find_slot (set->hashtab, &dummy, INSERT);
|
|
|
if (*slot != HTAB_EMPTY_ENTRY)
|
if (*slot != HTAB_EMPTY_ENTRY)
|
{
|
{
|
element = (cgraph_node_set_element) *slot;
|
element = (cgraph_node_set_element) *slot;
|
gcc_assert (node == element->node
|
gcc_assert (node == element->node
|
&& (VEC_index (cgraph_node_ptr, set->nodes, element->index)
|
&& (VEC_index (cgraph_node_ptr, set->nodes, element->index)
|
== node));
|
== node));
|
return;
|
return;
|
}
|
}
|
|
|
/* Insert node into hash table. */
|
/* Insert node into hash table. */
|
element =
|
element =
|
(cgraph_node_set_element) GGC_NEW (struct cgraph_node_set_element_def);
|
(cgraph_node_set_element) GGC_NEW (struct cgraph_node_set_element_def);
|
element->node = node;
|
element->node = node;
|
element->index = VEC_length (cgraph_node_ptr, set->nodes);
|
element->index = VEC_length (cgraph_node_ptr, set->nodes);
|
*slot = element;
|
*slot = element;
|
|
|
/* Insert into node vector. */
|
/* Insert into node vector. */
|
VEC_safe_push (cgraph_node_ptr, gc, set->nodes, node);
|
VEC_safe_push (cgraph_node_ptr, gc, set->nodes, node);
|
}
|
}
|
|
|
/* Remove cgraph_node NODE from cgraph_node_set SET. */
|
/* Remove cgraph_node NODE from cgraph_node_set SET. */
|
|
|
void
|
void
|
cgraph_node_set_remove (cgraph_node_set set, struct cgraph_node *node)
|
cgraph_node_set_remove (cgraph_node_set set, struct cgraph_node *node)
|
{
|
{
|
void **slot, **last_slot;
|
void **slot, **last_slot;
|
cgraph_node_set_element element, last_element;
|
cgraph_node_set_element element, last_element;
|
struct cgraph_node *last_node;
|
struct cgraph_node *last_node;
|
struct cgraph_node_set_element_def dummy;
|
struct cgraph_node_set_element_def dummy;
|
|
|
dummy.node = node;
|
dummy.node = node;
|
slot = htab_find_slot (set->hashtab, &dummy, NO_INSERT);
|
slot = htab_find_slot (set->hashtab, &dummy, NO_INSERT);
|
if (slot == NULL)
|
if (slot == NULL)
|
return;
|
return;
|
|
|
element = (cgraph_node_set_element) *slot;
|
element = (cgraph_node_set_element) *slot;
|
gcc_assert (VEC_index (cgraph_node_ptr, set->nodes, element->index)
|
gcc_assert (VEC_index (cgraph_node_ptr, set->nodes, element->index)
|
== node);
|
== node);
|
|
|
/* Remove from vector. We do this by swapping node with the last element
|
/* Remove from vector. We do this by swapping node with the last element
|
of the vector. */
|
of the vector. */
|
last_node = VEC_pop (cgraph_node_ptr, set->nodes);
|
last_node = VEC_pop (cgraph_node_ptr, set->nodes);
|
if (last_node != node)
|
if (last_node != node)
|
{
|
{
|
dummy.node = last_node;
|
dummy.node = last_node;
|
last_slot = htab_find_slot (set->hashtab, &dummy, NO_INSERT);
|
last_slot = htab_find_slot (set->hashtab, &dummy, NO_INSERT);
|
last_element = (cgraph_node_set_element) *last_slot;
|
last_element = (cgraph_node_set_element) *last_slot;
|
gcc_assert (last_element);
|
gcc_assert (last_element);
|
|
|
/* Move the last element to the original spot of NODE. */
|
/* Move the last element to the original spot of NODE. */
|
last_element->index = element->index;
|
last_element->index = element->index;
|
VEC_replace (cgraph_node_ptr, set->nodes, last_element->index,
|
VEC_replace (cgraph_node_ptr, set->nodes, last_element->index,
|
last_node);
|
last_node);
|
}
|
}
|
|
|
/* Remove element from hash table. */
|
/* Remove element from hash table. */
|
htab_clear_slot (set->hashtab, slot);
|
htab_clear_slot (set->hashtab, slot);
|
ggc_free (element);
|
ggc_free (element);
|
}
|
}
|
|
|
/* Find NODE in SET and return an iterator to it if found. A null iterator
|
/* Find NODE in SET and return an iterator to it if found. A null iterator
|
is returned if NODE is not in SET. */
|
is returned if NODE is not in SET. */
|
|
|
cgraph_node_set_iterator
|
cgraph_node_set_iterator
|
cgraph_node_set_find (cgraph_node_set set, struct cgraph_node *node)
|
cgraph_node_set_find (cgraph_node_set set, struct cgraph_node *node)
|
{
|
{
|
void **slot;
|
void **slot;
|
struct cgraph_node_set_element_def dummy;
|
struct cgraph_node_set_element_def dummy;
|
cgraph_node_set_element element;
|
cgraph_node_set_element element;
|
cgraph_node_set_iterator csi;
|
cgraph_node_set_iterator csi;
|
|
|
dummy.node = node;
|
dummy.node = node;
|
slot = htab_find_slot (set->hashtab, &dummy, NO_INSERT);
|
slot = htab_find_slot (set->hashtab, &dummy, NO_INSERT);
|
if (slot == NULL)
|
if (slot == NULL)
|
csi.index = (unsigned) ~0;
|
csi.index = (unsigned) ~0;
|
else
|
else
|
{
|
{
|
element = (cgraph_node_set_element) *slot;
|
element = (cgraph_node_set_element) *slot;
|
gcc_assert (VEC_index (cgraph_node_ptr, set->nodes, element->index)
|
gcc_assert (VEC_index (cgraph_node_ptr, set->nodes, element->index)
|
== node);
|
== node);
|
csi.index = element->index;
|
csi.index = element->index;
|
}
|
}
|
csi.set = set;
|
csi.set = set;
|
|
|
return csi;
|
return csi;
|
}
|
}
|
|
|
/* Dump content of SET to file F. */
|
/* Dump content of SET to file F. */
|
|
|
void
|
void
|
dump_cgraph_node_set (FILE *f, cgraph_node_set set)
|
dump_cgraph_node_set (FILE *f, cgraph_node_set set)
|
{
|
{
|
cgraph_node_set_iterator iter;
|
cgraph_node_set_iterator iter;
|
|
|
for (iter = csi_start (set); !csi_end_p (iter); csi_next (&iter))
|
for (iter = csi_start (set); !csi_end_p (iter); csi_next (&iter))
|
{
|
{
|
struct cgraph_node *node = csi_node (iter);
|
struct cgraph_node *node = csi_node (iter);
|
dump_cgraph_node (f, node);
|
dump_cgraph_node (f, node);
|
}
|
}
|
}
|
}
|
|
|
/* Dump content of SET to stderr. */
|
/* Dump content of SET to stderr. */
|
|
|
void
|
void
|
debug_cgraph_node_set (cgraph_node_set set)
|
debug_cgraph_node_set (cgraph_node_set set)
|
{
|
{
|
dump_cgraph_node_set (stderr, set);
|
dump_cgraph_node_set (stderr, set);
|
}
|
}
|
|
|
|
|
