/* Callgraph handling code.
- Copyright (C) 2003 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2004 Free Software Foundation, Inc.
Contributed by Jan Hubicka
This file is part of GCC.
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
+/* This file contains basic routines manipulating call graph and variable pool
+
+The callgraph:
+
+ The call-graph is data structure designed for intra-procedural optimization
+ but it is also used in non-unit-at-a-time compilation to allow easier code
+ sharing.
+
+ The call-graph consist of nodes and edges represented via linked lists.
+ Each function (external or not) corresponds to the unique node (in
+ contrast to tree DECL nodes where we can have multiple nodes for each
+ function).
+
+ The mapping from declarations to call-graph nodes is done using hash table
+ based on DECL_ASSEMBLER_NAME, so it is essential for assembler name to
+ not change once the declaration is inserted into the call-graph.
+ The call-graph nodes are created lazily using cgraph_node function when
+ called for unknown declaration.
+
+ When built, there is one edge for each direct call. It is possible that
+ the reference will be later optimized out. The call-graph is built
+ conservatively in order to make conservative data flow analysis possible.
+
+ The callgraph at the moment does not represent indirect calls or calls
+ from other compilation unit. Flag NEEDED is set for each node that may
+ be accessed in such a invisible way and it shall be considered an
+ entry point to the callgraph.
+
+ Intraprocedural information:
+
+ Callgraph is place to store data needed for intraprocedural optimization.
+ All data structures are divided into three components: local_info that
+ is produced while analyzing the function, global_info that is result
+ of global walking of the callgraph on the end of compilation and
+ rtl_info used by RTL backend to propagate data from already compiled
+ functions to their callers.
+
+ Inlining plans:
+
+ The function inlining information is decided in advance and maintained
+ in the callgraph as so called inline plan.
+ For each inlined call, the callee's node is cloned to represent the
+ new function copy produced by inliner.
+ Each inlined call gets a unique corresponding clone node of the callee
+ and the data structure is updated while inlining is performed, so
+ the clones are eliminated and their callee edges redirected to the
+ caller.
+
+ Each edge has "inline_failed" field. When the field is set to NULL,
+ the call will be inlined. When it is non-NULL it contains a reason
+ why inlining wasn't performed.
+
+
+The varpool data structure:
+
+ Varpool is used to maintain variables in similar manner as call-graph
+ is used for functions. Most of the API is symmetric replacing cgraph
+ function prefix by cgraph_varpool */
+
+
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "cgraph.h"
#include "varray.h"
#include "output.h"
-
+#include "intl.h"
/* Hash table used to convert declarations into nodes. */
static GTY((param_is (struct cgraph_node))) htab_t cgraph_hash;
/* The linked list of cgraph varpool nodes. */
static GTY(()) struct cgraph_varpool_node *cgraph_varpool_nodes;
-static struct cgraph_edge *create_edge (struct cgraph_node *,
- struct cgraph_node *);
static hashval_t hash_node (const void *);
static int eq_node (const void *, const void *);
static hashval_t
hash_node (const void *p)
{
- return ((hashval_t)
- IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME
- (((struct cgraph_node *) p)->decl)));
+ const struct cgraph_node *n = p;
+ return (hashval_t) DECL_UID (n->decl);
}
/* Returns nonzero if P1 and P2 are equal. */
static int
eq_node (const void *p1, const void *p2)
{
- return ((DECL_ASSEMBLER_NAME (((struct cgraph_node *) p1)->decl)) ==
- (tree) p2);
+ const struct cgraph_node *n1 = p1, *n2 = p2;
+ return DECL_UID (n1->decl) == DECL_UID (n2->decl);
+}
+
+/* Allocate new callgraph node and insert it into basic data structures. */
+static struct cgraph_node *
+cgraph_create_node (void)
+{
+ struct cgraph_node *node;
+
+ node = ggc_alloc_cleared (sizeof (*node));
+ node->next = cgraph_nodes;
+ node->uid = cgraph_max_uid++;
+ if (cgraph_nodes)
+ cgraph_nodes->previous = node;
+ node->previous = NULL;
+ cgraph_nodes = node;
+ cgraph_n_nodes++;
+ return node;
}
/* Return cgraph node assigned to DECL. Create new one when needed. */
struct cgraph_node *
cgraph_node (tree decl)
{
- struct cgraph_node *node;
- struct cgraph_node **slot;
+ struct cgraph_node key, *node, **slot;
- if (TREE_CODE (decl) != FUNCTION_DECL)
- abort ();
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
if (!cgraph_hash)
cgraph_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
- slot = (struct cgraph_node **)
- htab_find_slot_with_hash (cgraph_hash, DECL_ASSEMBLER_NAME (decl),
- IDENTIFIER_HASH_VALUE
- (DECL_ASSEMBLER_NAME (decl)), 1);
+ key.decl = decl;
+
+ slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
+
if (*slot)
return *slot;
- node = ggc_alloc_cleared (sizeof (*node));
+
+ node = cgraph_create_node ();
node->decl = decl;
- node->next = cgraph_nodes;
- node->uid = cgraph_max_uid++;
- if (cgraph_nodes)
- cgraph_nodes->previous = node;
- node->previous = NULL;
- cgraph_nodes = node;
- cgraph_n_nodes++;
*slot = node;
if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
{
return node;
}
-/* Try to find existing function for identifier ID. */
-struct cgraph_node *
-cgraph_node_for_identifier (tree id)
+/* Return callgraph edge representing CALL_EXPR. */
+struct cgraph_edge *
+cgraph_edge (struct cgraph_node *node, tree call_expr)
{
- struct cgraph_node **slot;
-
- if (TREE_CODE (id) != IDENTIFIER_NODE)
- abort ();
-
- if (!cgraph_hash)
- return NULL;
-
- slot = (struct cgraph_node **)
- htab_find_slot_with_hash (cgraph_hash, id,
- IDENTIFIER_HASH_VALUE (id), 0);
- if (!slot)
- return NULL;
- return *slot;
+ struct cgraph_edge *e;
+
+ /* This loop may turn out to be performance problem. In such case adding
+ hashtables into call nodes with very many edges is probably best
+ solution. It is not good idea to add pointer into CALL_EXPR itself
+ because we want to make possible having multiple cgraph nodes representing
+ different clones of the same body before the body is actually cloned. */
+ for (e = node->callees; e; e= e->next_callee)
+ if (e->call_expr == call_expr)
+ break;
+ return e;
}
/* Create edge from CALLER to CALLEE in the cgraph. */
-static struct cgraph_edge *
-create_edge (struct cgraph_node *caller, struct cgraph_node *callee)
+struct cgraph_edge *
+cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
+ tree call_expr)
{
struct cgraph_edge *edge = ggc_alloc (sizeof (struct cgraph_edge));
- struct cgraph_edge *edge2;
-
- edge->inline_call = false;
- /* At the moment we don't associate calls with specific CALL_EXPRs
- as we probably ought to, so we must preserve inline_call flags to
- be the same in all copies of the same edge. */
- if (cgraph_global_info_ready)
- for (edge2 = caller->callees; edge2; edge2 = edge2->next_callee)
- if (edge2->callee == callee)
- {
- edge->inline_call = edge2->inline_call;
- break;
- }
+#ifdef ENABLE_CHECKING
+ struct cgraph_edge *e;
+
+ for (e = caller->callees; e; e = e->next_callee)
+ gcc_assert (e->call_expr != call_expr);
+#endif
+
+ gcc_assert (TREE_CODE (call_expr) == CALL_EXPR);
+
+ if (!DECL_SAVED_TREE (callee->decl))
+ edge->inline_failed = N_("function body not available");
+ else if (callee->local.redefined_extern_inline)
+ edge->inline_failed = N_("redefined extern inline functions are not "
+ "considered for inlining");
+ else if (callee->local.inlinable)
+ edge->inline_failed = N_("function not considered for inlining");
+ else
+ edge->inline_failed = N_("function not inlinable");
+
+ edge->aux = NULL;
edge->caller = caller;
edge->callee = callee;
+ edge->call_expr = call_expr;
edge->next_caller = callee->callers;
edge->next_callee = caller->callees;
caller->callees = edge;
return edge;
}
-/* Remove the edge from CALLER to CALLEE in the cgraph. */
+/* Remove the edge E the cgraph. */
void
-cgraph_remove_edge (struct cgraph_node *caller, struct cgraph_node *callee)
+cgraph_remove_edge (struct cgraph_edge *e)
{
struct cgraph_edge **edge, **edge2;
- for (edge = &callee->callers; *edge && (*edge)->caller != caller;
+ for (edge = &e->callee->callers; *edge && *edge != e;
edge = &((*edge)->next_caller))
continue;
- if (!*edge)
- abort ();
+ gcc_assert (*edge);
*edge = (*edge)->next_caller;
- for (edge2 = &caller->callees; *edge2 && (*edge2)->callee != callee;
+ for (edge2 = &e->caller->callees; *edge2 && *edge2 != e;
edge2 = &(*edge2)->next_callee)
continue;
- if (!*edge2)
- abort ();
+ gcc_assert (*edge2);
*edge2 = (*edge2)->next_callee;
}
+/* Redirect callee of E to N. The function does not update underlying
+ call expression. */
+
+void
+cgraph_redirect_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
+{
+ struct cgraph_edge **edge;
+
+ for (edge = &e->callee->callers; *edge && *edge != e;
+ edge = &((*edge)->next_caller))
+ continue;
+ gcc_assert (*edge);
+ *edge = (*edge)->next_caller;
+ e->callee = n;
+ e->next_caller = n->callers;
+ n->callers = e;
+}
+
/* Remove the node from cgraph. */
void
cgraph_remove_node (struct cgraph_node *node)
{
void **slot;
+ bool check_dead = 1;
+
while (node->callers)
- cgraph_remove_edge (node->callers->caller, node);
+ cgraph_remove_edge (node->callers);
while (node->callees)
- cgraph_remove_edge (node, node->callees->callee);
+ cgraph_remove_edge (node->callees);
while (node->nested)
cgraph_remove_node (node->nested);
if (node->origin)
if (node->previous)
node->previous->next = node->next;
else
- cgraph_nodes = node;
+ cgraph_nodes = node->next;
if (node->next)
node->next->previous = node->previous;
- DECL_SAVED_TREE (node->decl) = NULL;
- slot =
- htab_find_slot_with_hash (cgraph_hash, DECL_ASSEMBLER_NAME (node->decl),
- IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME
- (node->decl)), 1);
- htab_clear_slot (cgraph_hash, slot);
+ slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
+ if (*slot == node)
+ {
+ if (node->next_clone)
+ *slot = node->next_clone;
+ else
+ {
+ htab_clear_slot (cgraph_hash, slot);
+ if (!dump_enabled_p (TDI_tree_all))
+ {
+ DECL_SAVED_TREE (node->decl) = NULL;
+ DECL_STRUCT_FUNCTION (node->decl) = NULL;
+ }
+ check_dead = false;
+ }
+ }
+ else
+ {
+ struct cgraph_node *n;
+
+ for (n = *slot; n->next_clone != node; n = n->next_clone)
+ continue;
+ n->next_clone = node->next_clone;
+ }
+
+ /* Work out whether we still need a function body (either there is inline
+ clone or there is out of line function whose body is not written). */
+ if (check_dead && flag_unit_at_a_time)
+ {
+ struct cgraph_node *n;
+
+ for (n = *slot; n; n = n->next_clone)
+ if (n->global.inlined_to
+ || (!n->global.inlined_to
+ && !TREE_ASM_WRITTEN (n->decl) && !DECL_EXTERNAL (n->decl)))
+ break;
+ if (!n && !dump_enabled_p (TDI_tree_all))
+ {
+ DECL_SAVED_TREE (node->decl) = NULL;
+ DECL_STRUCT_FUNCTION (node->decl) = NULL;
+ DECL_INITIAL (node->decl) = error_mark_node;
+ }
+ }
+ cgraph_n_nodes--;
/* Do not free the structure itself so the walk over chain can continue. */
}
node->next_needed = cgraph_nodes_queue;
cgraph_nodes_queue = node;
-
- /* At the moment frontend automatically emits all nested functions. */
- if (node->nested)
- {
- struct cgraph_node *node2;
-
- for (node2 = node->nested; node2; node2 = node2->next_nested)
- if (!node2->reachable)
- cgraph_mark_reachable_node (node2);
- }
}
}
cgraph_mark_reachable_node (node);
}
-/* Record call from CALLER to CALLEE */
-
-struct cgraph_edge *
-cgraph_record_call (tree caller, tree callee)
-{
- return create_edge (cgraph_node (caller), cgraph_node (callee));
-}
-
-void
-cgraph_remove_call (tree caller, tree callee)
-{
- cgraph_remove_edge (cgraph_node (caller), cgraph_node (callee));
-}
-
/* Return true when CALLER_DECL calls CALLEE_DECL. */
bool
cgraph_local_info (tree decl)
{
struct cgraph_node *node;
- if (TREE_CODE (decl) != FUNCTION_DECL)
- abort ();
+
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
node = cgraph_node (decl);
return &node->local;
}
cgraph_global_info (tree decl)
{
struct cgraph_node *node;
- if (TREE_CODE (decl) != FUNCTION_DECL || !cgraph_global_info_ready)
- abort ();
+
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL && cgraph_global_info_ready);
node = cgraph_node (decl);
return &node->global;
}
cgraph_rtl_info (tree decl)
{
struct cgraph_node *node;
- if (TREE_CODE (decl) != FUNCTION_DECL)
- abort ();
+
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
node = cgraph_node (decl);
if (decl != current_function_decl
&& !TREE_ASM_WRITTEN (node->decl))
const char *
cgraph_node_name (struct cgraph_node *node)
{
- return (*lang_hooks.decl_printable_name) (node->decl, 2);
+ return lang_hooks.decl_printable_name (node->decl, 2);
+}
+
+/* Dump given cgraph node. */
+void
+dump_cgraph_node (FILE *f, struct cgraph_node *node)
+{
+ struct cgraph_edge *edge;
+ fprintf (f, "%s/%i:", cgraph_node_name (node), node->uid);
+ if (node->global.inlined_to)
+ fprintf (f, " (inline copy in %s/%i)",
+ cgraph_node_name (node->global.inlined_to),
+ node->global.inlined_to->uid);
+ if (node->local.self_insns)
+ fprintf (f, " %i insns", node->local.self_insns);
+ if (node->global.insns && node->global.insns != node->local.self_insns)
+ fprintf (f, " (%i after inlining)", node->global.insns);
+ if (node->origin)
+ fprintf (f, " nested in: %s", cgraph_node_name (node->origin));
+ if (node->needed)
+ fprintf (f, " needed");
+ else if (node->reachable)
+ fprintf (f, " reachable");
+ if (DECL_SAVED_TREE (node->decl))
+ fprintf (f, " tree");
+ if (node->output)
+ fprintf (f, " output");
+ if (node->local.local)
+ fprintf (f, " local");
+ if (node->local.disregard_inline_limits)
+ fprintf (f, " always_inline");
+ else if (node->local.inlinable)
+ fprintf (f, " inlinable");
+ if (TREE_ASM_WRITTEN (node->decl))
+ fprintf (f, " asm_written");
+
+ fprintf (f, "\n called by: ");
+ for (edge = node->callers; edge; edge = edge->next_caller)
+ {
+ fprintf (f, "%s/%i ", cgraph_node_name (edge->caller),
+ edge->caller->uid);
+ if (!edge->inline_failed)
+ fprintf(f, "(inlined) ");
+ }
+
+ fprintf (f, "\n calls: ");
+ for (edge = node->callees; edge; edge = edge->next_callee)
+ {
+ fprintf (f, "%s/%i ", cgraph_node_name (edge->callee),
+ edge->callee->uid);
+ if (!edge->inline_failed)
+ fprintf(f, "(inlined) ");
+ }
+ fprintf (f, "\n");
}
/* Dump the callgraph. */
fprintf (f, "callgraph:\n\n");
for (node = cgraph_nodes; node; node = node->next)
- {
- struct cgraph_edge *edge;
- fprintf (f, "%s:", cgraph_node_name (node));
- if (node->local.self_insns)
- fprintf (f, " %i insns", node->local.self_insns);
- if (node->global.insns && node->global.insns != node->local.self_insns)
- fprintf (f, " (%i after inlining)", node->global.insns);
- if (node->origin)
- fprintf (f, " nested in: %s", cgraph_node_name (node->origin));
- if (node->needed)
- fprintf (f, " needed");
- else if (node->reachable)
- fprintf (f, " reachable");
- if (DECL_SAVED_TREE (node->decl))
- fprintf (f, " tree");
-
- if (node->local.local)
- fprintf (f, " local");
- if (node->local.disregard_inline_limits)
- fprintf (f, " always_inline");
- else if (node->local.inlinable)
- fprintf (f, " inlinable");
- if (node->global.cloned_times > 1)
- fprintf (f, " cloned %ix", node->global.cloned_times);
-
- fprintf (f, "\n called by: ");
- for (edge = node->callers; edge; edge = edge->next_caller)
- {
- fprintf (f, "%s ", cgraph_node_name (edge->caller));
- if (edge->inline_call)
- fprintf(f, "(inlined) ");
- }
-
- fprintf (f, "\n calls: ");
- for (edge = node->callees; edge; edge = edge->next_callee)
- {
- fprintf (f, "%s ", cgraph_node_name (edge->callee));
- if (edge->inline_call)
- fprintf(f, "(inlined) ");
- }
- fprintf (f, "\n");
- }
+ dump_cgraph_node (f, node);
}
/* Returns a hash code for P. */
static hashval_t
-cgraph_varpool_hash_node (const void *p)
+hash_varpool_node (const void *p)
{
- return ((hashval_t)
- IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME
- (((struct cgraph_varpool_node *) p)->decl)));
+ const struct cgraph_varpool_node *n = p;
+ return (hashval_t) DECL_UID (n->decl);
}
/* Returns nonzero if P1 and P2 are equal. */
static int
-eq_cgraph_varpool_node (const void *p1, const void *p2)
+eq_varpool_node (const void *p1, const void *p2)
{
- return ((DECL_ASSEMBLER_NAME (((struct cgraph_varpool_node *) p1)->decl)) ==
- (tree) p2);
+ const struct cgraph_varpool_node *n1 = p1, *n2 = p2;
+ return DECL_UID (n1->decl) == DECL_UID (n2->decl);
}
/* Return cgraph_varpool node assigned to DECL. Create new one when needed. */
struct cgraph_varpool_node *
cgraph_varpool_node (tree decl)
{
- struct cgraph_varpool_node *node;
- struct cgraph_varpool_node **slot;
+ struct cgraph_varpool_node key, *node, **slot;
- if (!DECL_P (decl) || TREE_CODE (decl) == FUNCTION_DECL)
- abort ();
+ gcc_assert (DECL_P (decl) && TREE_CODE (decl) != FUNCTION_DECL);
if (!cgraph_varpool_hash)
- cgraph_varpool_hash = htab_create_ggc (10, cgraph_varpool_hash_node,
- eq_cgraph_varpool_node, NULL);
-
-
+ cgraph_varpool_hash = htab_create_ggc (10, hash_varpool_node,
+ eq_varpool_node, NULL);
+ key.decl = decl;
slot = (struct cgraph_varpool_node **)
- htab_find_slot_with_hash (cgraph_varpool_hash, DECL_ASSEMBLER_NAME (decl),
- IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME (decl)),
- 1);
+ htab_find_slot (cgraph_varpool_hash, &key, INSERT);
if (*slot)
return *slot;
node = ggc_alloc_cleared (sizeof (*node));
return node;
}
-/* Try to find existing function for identifier ID. */
-struct cgraph_varpool_node *
-cgraph_varpool_node_for_identifier (tree id)
+/* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables. */
+void
+change_decl_assembler_name (tree decl, tree name)
{
- struct cgraph_varpool_node **slot;
-
- if (TREE_CODE (id) != IDENTIFIER_NODE)
- abort ();
+ if (!DECL_ASSEMBLER_NAME_SET_P (decl))
+ {
+ SET_DECL_ASSEMBLER_NAME (decl, name);
+ return;
+ }
+ if (name == DECL_ASSEMBLER_NAME (decl))
+ return;
- if (!cgraph_varpool_hash)
- return NULL;
+ if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
+ && DECL_RTL_SET_P (decl))
+ warning ("%D renamed after being referenced in assembly", decl);
- slot = (struct cgraph_varpool_node **)
- htab_find_slot_with_hash (cgraph_varpool_hash, id,
- IDENTIFIER_HASH_VALUE (id), 0);
- if (!slot)
- return NULL;
- return *slot;
+ SET_DECL_ASSEMBLER_NAME (decl, name);
}
/* Notify finalize_compilation_unit that given node is reachable
return changed;
}
+/* Return true when the DECL can possibly be inlined. */
+bool
+cgraph_function_possibly_inlined_p (tree decl)
+{
+ if (!cgraph_global_info_ready)
+ return (DECL_INLINE (decl) && !flag_really_no_inline);
+ return DECL_POSSIBLY_INLINED (decl);
+}
+
+/* Create clone of E in the node N represented by CALL_EXPR the callgraph. */
+struct cgraph_edge *
+cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n, tree call_expr)
+{
+ struct cgraph_edge *new = cgraph_create_edge (n, e->callee, call_expr);
+
+ new->inline_failed = e->inline_failed;
+ return new;
+}
+
+/* Create node representing clone of N. */
+struct cgraph_node *
+cgraph_clone_node (struct cgraph_node *n)
+{
+ struct cgraph_node *new = cgraph_create_node ();
+ struct cgraph_edge *e;
+
+ new->decl = n->decl;
+ new->origin = n->origin;
+ if (new->origin)
+ {
+ new->next_nested = new->origin->nested;
+ new->origin->nested = new;
+ }
+ new->analyzed = n->analyzed;
+ new->local = n->local;
+ new->global = n->global;
+ new->rtl = n->rtl;
+
+ for (e = n->callees;e; e=e->next_callee)
+ cgraph_clone_edge (e, new, e->call_expr);
+
+ new->next_clone = n->next_clone;
+ n->next_clone = new;
+
+ return new;
+}
+/* NODE is no longer nested function; update cgraph accordingly. */
+void
+cgraph_unnest_node (struct cgraph_node *node)
+{
+ struct cgraph_node **node2 = &node->origin->nested;
+ gcc_assert (node->origin);
+
+ while (*node2 != node)
+ node2 = &(*node2)->next_nested;
+ *node2 = node->next_nested;
+ node->origin = NULL;
+}
#include "gt-cgraph.h"
OSDN Git Service
