/* Callgraph handling code.
- Copyright (C) 2003 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2004, 2005 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 an 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 "tm.h"
#include "tree.h"
-#include "tree-inline.h"
#include "langhooks.h"
#include "hashtab.h"
#include "toplev.h"
#include "ggc.h"
#include "debug.h"
#include "target.h"
+#include "cgraph.h"
+#include "varray.h"
+#include "output.h"
+#include "intl.h"
-/* The cgraph data strutcture.
- Each function decl has assigned cgraph_node listing calees and callers. */
-
-struct cgraph_node
-{
- tree decl;
- struct cgraph_edge *callees;
- struct cgraph_edge *callers;
- struct cgraph_node *next;
- /* For nested functions points to function the node is nested in. */
- struct cgraph_node *origin;
- /* Points to first nested function, if any. */
- struct cgraph_node *nested;
- /* Pointer to the next function with same origin, if any. */
- struct cgraph_node *next_nested;
- void *aux;
-
- /* Set when function must be output - it is externally visible
- or it's address is taken. */
- bool needed;
- /* Set when function is reachable by call from other function
- that is eighter reachable or needed. */
- bool reachable;
- /* Set when the frontend has been asked to lower representation of this
- function into trees. Callees lists are not available when lowered
- is not set. */
- bool lowered;
- /* Set when function is scheduled to be assembled. */
- bool output;
-};
-
-struct cgraph_edge
-{
- struct cgraph_node *caller, *callee;
- struct cgraph_edge *next_caller;
- struct cgraph_edge *next_callee;
-};
+static void cgraph_node_remove_callers (struct cgraph_node *node);
+static inline void cgraph_edge_remove_caller (struct cgraph_edge *e);
+static inline void cgraph_edge_remove_callee (struct cgraph_edge *e);
/* Hash table used to convert declarations into nodes. */
-static htab_t cgraph_hash = 0;
+static GTY((param_is (struct cgraph_node))) htab_t cgraph_hash;
/* The linked list of cgraph nodes. */
-static struct cgraph_node *cgraph_nodes;
+struct cgraph_node *cgraph_nodes;
+
+/* Queue of cgraph nodes scheduled to be lowered. */
+struct cgraph_node *cgraph_nodes_queue;
/* Number of nodes in existence. */
-static int cgraph_n_nodes;
-
-static struct cgraph_node *cgraph_node PARAMS ((tree decl));
-static struct cgraph_edge *create_edge PARAMS ((struct cgraph_node *,
- struct cgraph_node *));
-static void remove_edge PARAMS ((struct cgraph_node *, struct cgraph_node *));
-static struct cgraph_edge *record_call PARAMS ((tree, tree));
-static tree record_call_1 PARAMS ((tree *, int *, void *));
-static hashval_t hash_node PARAMS ((const PTR));
-static int eq_node PARAMS ((const PTR, const PTR));
-static struct cgraph_node *cgraph_node PARAMS ((tree));
-static void cgraph_expand_functions PARAMS ((void));
-static void cgraph_mark_functions_to_output PARAMS ((void));
-static void cgraph_expand_function PARAMS ((struct cgraph_node *));
-static void cgraph_mark_needed_node PARAMS ((struct cgraph_node *, int));
+int cgraph_n_nodes;
+
+/* Maximal uid used in cgraph nodes. */
+int cgraph_max_uid;
+
+/* Set when whole unit has been analyzed so we can access global info. */
+bool cgraph_global_info_ready = false;
+
+/* Hash table used to convert declarations into nodes. */
+static GTY((param_is (struct cgraph_varpool_node))) htab_t cgraph_varpool_hash;
+
+/* Queue of cgraph nodes scheduled to be lowered and output. */
+struct cgraph_varpool_node *cgraph_varpool_nodes_queue;
+
+/* The linked list of cgraph varpool nodes. */
+static GTY(()) struct cgraph_varpool_node *cgraph_varpool_nodes;
+
+static hashval_t hash_node (const void *);
+static int eq_node (const void *, const void *);
/* Returns a hash code for P. */
static hashval_t
-hash_node (p)
- const PTR p;
+hash_node (const void *p)
{
- return (hashval_t)
- htab_hash_pointer (DECL_ASSEMBLER_NAME
- (((struct cgraph_node *) p)->decl));
+ const struct cgraph_node *n = p;
+ return (hashval_t) DECL_UID (n->decl);
}
-/* Returns non-zero if P1 and P2 are equal. */
+/* Returns nonzero if P1 and P2 are equal. */
static int
-eq_node (p1, p2)
- const PTR p1;
- const PTR p2;
+eq_node (const void *p1, const void *p2)
{
- return ((DECL_ASSEMBLER_NAME (((struct cgraph_node *) p1)->decl)) ==
- DECL_ASSEMBLER_NAME ((tree) p2));
+ const struct cgraph_node *n1 = p1, *n2 = p2;
+ return DECL_UID (n1->decl) == DECL_UID (n2->decl);
}
-/* Return cgraph node assigned to DECL. Create new one when needed. */
+/* Allocate new callgraph node and insert it into basic data structures. */
static struct cgraph_node *
-cgraph_node (decl)
- tree decl;
+cgraph_create_node (void)
{
struct cgraph_node *node;
- struct cgraph_node **slot;
+
+ 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 key, *node, **slot;
+
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
if (!cgraph_hash)
- cgraph_hash = htab_create (10, hash_node, eq_node, NULL);
+ cgraph_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
+
+ key.decl = decl;
+
+ slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
- slot =
- (struct cgraph_node **) htab_find_slot_with_hash (cgraph_hash, decl,
- htab_hash_pointer
- (DECL_ASSEMBLER_NAME
- (decl)), 1);
if (*slot)
return *slot;
- node = xcalloc (sizeof (*node), 1);
+
+ node = cgraph_create_node ();
node->decl = decl;
- node->next = cgraph_nodes;
- cgraph_nodes = node;
- cgraph_n_nodes++;
*slot = node;
- if (DECL_CONTEXT (decl))
+ if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
{
node->origin = cgraph_node (DECL_CONTEXT (decl));
node->next_nested = node->origin->nested;
return node;
}
+/* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
+
+static bool
+decl_assembler_name_equal (tree decl, tree asmname)
+{
+ tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
+
+ if (decl_asmname == asmname)
+ return true;
+
+ /* If the target assembler name was set by the user, things are trickier.
+ We have a leading '*' to begin with. After that, it's arguable what
+ is the correct thing to do with -fleading-underscore. Arguably, we've
+ historically been doing the wrong thing in assemble_alias by always
+ printing the leading underscore. Since we're not changing that, make
+ sure user_label_prefix follows the '*' before matching. */
+ if (IDENTIFIER_POINTER (decl_asmname)[0] == '*')
+ {
+ const char *decl_str = IDENTIFIER_POINTER (decl_asmname) + 1;
+ size_t ulp_len = strlen (user_label_prefix);
+
+ if (ulp_len == 0)
+ ;
+ else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
+ decl_str += ulp_len;
+ else
+ return false;
+
+ return strcmp (decl_str, IDENTIFIER_POINTER (asmname)) == 0;
+ }
+
+ return false;
+}
+
+
+/* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
+ Return NULL if there's no such node. */
+
+struct cgraph_node *
+cgraph_node_for_asm (tree asmname)
+{
+ struct cgraph_node *node;
+
+ for (node = cgraph_nodes; node ; node = node->next)
+ if (decl_assembler_name_equal (node->decl, asmname))
+ return node;
+
+ return NULL;
+}
+
+/* Return callgraph edge representing CALL_EXPR. */
+struct cgraph_edge *
+cgraph_edge (struct cgraph_node *node, tree call_expr)
+{
+ 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 (caller, callee)
- struct cgraph_node *caller, *callee;
+struct cgraph_edge *
+cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
+ tree call_expr)
{
- struct cgraph_edge *edge = xmalloc (sizeof (struct cgraph_edge));
+ struct cgraph_edge *edge = ggc_alloc (sizeof (struct cgraph_edge));
+#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->prev_caller = NULL;
edge->next_caller = callee->callers;
+ if (callee->callers)
+ callee->callers->prev_caller = edge;
+ edge->prev_callee = NULL;
edge->next_callee = caller->callees;
+ if (caller->callees)
+ caller->callees->prev_callee = edge;
caller->callees = edge;
callee->callers = edge;
return edge;
}
-/* Remove the edge from CALLER to CALLEE in the cgraph. */
+/* Remove the edge E from the list of the callers of the callee. */
-static void
-remove_edge (caller, callee)
- struct cgraph_node *caller, *callee;
+static inline void
+cgraph_edge_remove_callee (struct cgraph_edge *e)
{
- struct cgraph_edge **edge, **edge2;
+ if (e->prev_caller)
+ e->prev_caller->next_caller = e->next_caller;
+ if (e->next_caller)
+ e->next_caller->prev_caller = e->prev_caller;
+ if (!e->prev_caller)
+ e->callee->callers = e->next_caller;
+}
+
+/* Remove the edge E from the list of the callees of the caller. */
- for (edge = &callee->callers; *edge && (*edge)->caller != caller;
- edge = &((*edge)->next_caller))
- continue;
- if (!*edge)
- abort ();
- *edge = (*edge)->next_caller;
- for (edge2 = &caller->callees; *edge2 && (*edge2)->callee != callee;
- edge2 = &(*edge2)->next_callee)
- continue;
- if (!*edge2)
- abort ();
- *edge2 = (*edge2)->next_callee;
+static inline void
+cgraph_edge_remove_caller (struct cgraph_edge *e)
+{
+ if (e->prev_callee)
+ e->prev_callee->next_callee = e->next_callee;
+ if (e->next_callee)
+ e->next_callee->prev_callee = e->prev_callee;
+ if (!e->prev_callee)
+ e->caller->callees = e->next_callee;
}
-/* Record call from CALLER to CALLEE */
+/* Remove the edge E in the cgraph. */
-static struct cgraph_edge *
-record_call (caller, callee)
- tree caller, callee;
+void
+cgraph_remove_edge (struct cgraph_edge *e)
{
- return create_edge (cgraph_node (caller), cgraph_node (callee));
+ /* Remove from callers list of the callee. */
+ cgraph_edge_remove_callee (e);
+
+ /* Remove from callees list of the callers. */
+ cgraph_edge_remove_caller (e);
}
+/* Redirect callee of E to N. The function does not update underlying
+ call expression. */
+
void
-cgraph_remove_call (caller, callee)
- tree caller, callee;
+cgraph_redirect_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
{
- remove_edge (cgraph_node (caller), cgraph_node (callee));
+ /* Remove from callers list of the current callee. */
+ cgraph_edge_remove_callee (e);
+
+ /* Insert to callers list of the new callee. */
+ e->prev_caller = NULL;
+ if (n->callers)
+ n->callers->prev_caller = e;
+ e->next_caller = n->callers;
+ n->callers = e;
+ e->callee = n;
}
-/* Return true when CALLER_DECL calls CALLEE_DECL. */
+/* Remove all callees from the node. */
-bool
-cgraph_calls_p (caller_decl, callee_decl)
- tree caller_decl, callee_decl;
+void
+cgraph_node_remove_callees (struct cgraph_node *node)
{
- struct cgraph_node *caller = cgraph_node (caller_decl);
- struct cgraph_node *callee = cgraph_node (callee_decl);
- struct cgraph_edge *edge;
+ struct cgraph_edge *e;
+
+ /* It is sufficient to remove the edges from the lists of callers of
+ the callees. The callee list of the node can be zapped with one
+ assignment. */
+ for (e = node->callees; e; e = e->next_callee)
+ cgraph_edge_remove_callee (e);
+ node->callees = NULL;
+}
- for (edge = callee->callers; edge && (edge)->caller != caller;
- edge = (edge->next_caller))
- continue;
- return edge != NULL;
+/* Remove all callers from the node. */
+
+static void
+cgraph_node_remove_callers (struct cgraph_node *node)
+{
+ struct cgraph_edge *e;
+
+ /* It is sufficient to remove the edges from the lists of callees of
+ the callers. The caller list of the node can be zapped with one
+ assignment. */
+ for (e = node->callers; e; e = e->next_caller)
+ cgraph_edge_remove_caller (e);
+ node->callers = NULL;
}
-/* Walk tree and record all calls. Called via walk_tree. */
-static tree
-record_call_1 (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees;
- void *data;
+/* Remove the node from cgraph. */
+
+void
+cgraph_remove_node (struct cgraph_node *node)
{
- /* Record dereferences to the functions. This makes the functions
- reachable unconditionally. */
- if (TREE_CODE (*tp) == ADDR_EXPR)
+ void **slot;
+ bool check_dead = 1;
+
+ cgraph_node_remove_callers (node);
+ cgraph_node_remove_callees (node);
+ while (node->nested)
+ cgraph_remove_node (node->nested);
+ if (node->origin)
{
- tree decl = TREE_OPERAND (*tp, 0);
- if (TREE_CODE (decl) == FUNCTION_DECL)
- cgraph_mark_needed_node (cgraph_node (decl), 1);
+ struct cgraph_node **node2 = &node->origin->nested;
+
+ while (*node2 != node)
+ node2 = &(*node2)->next_nested;
+ *node2 = node->next_nested;
}
- else if (TREE_CODE (*tp) == CALL_EXPR)
+ if (node->previous)
+ node->previous->next = node->next;
+ else
+ cgraph_nodes = node->next;
+ if (node->next)
+ node->next->previous = node->previous;
+ slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
+ if (*slot == node)
{
- tree decl = TREE_OPERAND (*tp, 0);
- if (TREE_CODE (decl) == ADDR_EXPR)
- decl = TREE_OPERAND (decl, 0);
- if (TREE_CODE (decl) == FUNCTION_DECL)
+ if (node->next_clone)
+ *slot = node->next_clone;
+ else
{
- if (DECL_BUILT_IN (decl))
- return NULL;
- record_call (data, decl);
- walk_tree (&TREE_OPERAND (*tp, 1), record_call_1, data, NULL);
- *walk_subtrees = 0;
+ 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;
}
}
- return NULL;
+ 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. */
}
-/* Create cgraph edges for function calles via BODY. */
+/* Notify finalize_compilation_unit that given node is reachable. */
void
-cgraph_create_edges (decl, body)
- tree decl;
- tree body;
+cgraph_mark_reachable_node (struct cgraph_node *node)
{
- walk_tree (&body, record_call_1, decl, NULL);
+ if (!node->reachable && node->local.finalized)
+ {
+ notice_global_symbol (node->decl);
+ node->reachable = 1;
+
+ node->next_needed = cgraph_nodes_queue;
+ cgraph_nodes_queue = node;
+ }
}
-/* Analyze function once it is parsed. Set up the local information
- available - create cgraph edges for function calles via BODY. */
+/* Likewise indicate that a node is needed, i.e. reachable via some
+ external means. */
void
-cgraph_finalize_function (decl, body)
- tree decl;
- tree body ATTRIBUTE_UNUSED;
+cgraph_mark_needed_node (struct cgraph_node *node)
{
- struct cgraph_node *node = cgraph_node (decl);
-
- node->decl = decl;
+ node->needed = 1;
+ cgraph_mark_reachable_node (node);
+}
- /* Set TREE_UNINLINABLE flag. */
- tree_inlinable_function_p (decl);
+/* Return local info for the compiled function. */
- (*debug_hooks->deferred_inline_function) (decl);
+struct cgraph_local_info *
+cgraph_local_info (tree decl)
+{
+ struct cgraph_node *node;
+
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
+ node = cgraph_node (decl);
+ return &node->local;
}
-/* Dump the callgraph. */
+/* Return local info for the compiled function. */
-void
-dump_cgraph (f)
- FILE *f;
+struct cgraph_global_info *
+cgraph_global_info (tree decl)
{
struct cgraph_node *node;
+
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL && cgraph_global_info_ready);
+ node = cgraph_node (decl);
+ return &node->global;
+}
- fprintf (f, "\nCallgraph:\n\n");
- for (node = cgraph_nodes; node; node = node->next)
- {
- struct cgraph_edge *edge;
- fprintf (f, "%s", IDENTIFIER_POINTER (DECL_NAME (node->decl)));
- if (node->origin)
- fprintf (f, " nested in: %s",
- IDENTIFIER_POINTER (DECL_NAME (node->origin->decl)));
- if (node->needed)
- fprintf (f, " needed");
- else if (node->reachable)
- fprintf (f, " reachable");
- if (DECL_SAVED_TREE (node->decl))
- fprintf (f, " tree");
-
- fprintf (f, "\n called by :");
- for (edge = node->callers; edge; edge = edge->next_caller)
- fprintf (f, "%s ",
- IDENTIFIER_POINTER (DECL_NAME (edge->caller->decl)));
-
- fprintf (f, "\n calls: ");
- for (edge = node->callees; edge; edge = edge->next_callee)
- fprintf (f, "%s ",
- IDENTIFIER_POINTER (DECL_NAME (edge->callee->decl)));
- fprintf (f, "\n");
- }
+/* Return local info for the compiled function. */
+
+struct cgraph_rtl_info *
+cgraph_rtl_info (tree decl)
+{
+ struct cgraph_node *node;
+
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
+ node = cgraph_node (decl);
+ if (decl != current_function_decl
+ && !TREE_ASM_WRITTEN (node->decl))
+ return NULL;
+ return &node->rtl;
}
-static struct cgraph_node *queue = NULL;
+/* Return name of the node used in debug output. */
+const char *
+cgraph_node_name (struct cgraph_node *node)
+{
+ return lang_hooks.decl_printable_name (node->decl, 2);
+}
-/* Notify finalize_compilation_unit that given node is reachable
- or needed. */
-static void
-cgraph_mark_needed_node (node, needed)
- struct cgraph_node *node;
- int needed;
+/* Dump given cgraph node. */
+void
+dump_cgraph_node (FILE *f, struct cgraph_node *node)
{
- if (needed)
+ 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)
{
- if (DECL_SAVED_TREE (node->decl))
- announce_function (node->decl);
- node->needed = 1;
+ fprintf (f, "%s/%i ", cgraph_node_name (edge->caller),
+ edge->caller->uid);
+ if (!edge->inline_failed)
+ fprintf(f, "(inlined) ");
}
- if (!node->reachable)
+
+ fprintf (f, "\n calls: ");
+ for (edge = node->callees; edge; edge = edge->next_callee)
{
- node->reachable = 1;
- if (DECL_SAVED_TREE (node->decl))
- {
- node->aux = queue;
- queue = node;
- }
+ fprintf (f, "%s/%i ", cgraph_node_name (edge->callee),
+ edge->callee->uid);
+ if (!edge->inline_failed)
+ fprintf(f, "(inlined) ");
}
+ fprintf (f, "\n");
}
-/* Analyze the whole compilation unit once it is parsed completely. */
+/* Dump the callgraph. */
void
-cgraph_finalize_compilation_unit ()
+dump_cgraph (FILE *f)
{
struct cgraph_node *node;
- struct cgraph_edge *edge;
-
- /* Collect entry points to the unit. */
-
- if (!quiet_flag)
- fprintf (stderr, "\n\nUnit entry points:");
+ fprintf (f, "callgraph:\n\n");
for (node = cgraph_nodes; node; node = node->next)
- {
- tree decl = node->decl;
+ dump_cgraph_node (f, node);
+}
- if (!DECL_SAVED_TREE (decl))
- continue;
- if ((TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
- || (DECL_ASSEMBLER_NAME_SET_P (decl)
- && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
- {
- cgraph_mark_needed_node (node, 1);
- }
- }
+/* Returns a hash code for P. */
- /* Propagate reachability flag and lower representation of all reachable
- functions. In the future, lowering will introduce new functions and
- new entry points on the way (by template instantiation and virtual
- method table generation for instance). */
- while (queue)
- {
- tree decl = queue->decl;
+static hashval_t
+hash_varpool_node (const void *p)
+{
+ const struct cgraph_varpool_node *n = p;
+ return (hashval_t) DECL_UID (n->decl);
+}
- node = queue;
- queue = queue->aux;
- if (node->lowered || !node->reachable || !DECL_SAVED_TREE (decl))
- abort ();
+/* Returns nonzero if P1 and P2 are equal. */
- /* At the moment frontend automatically emits all nested functions. */
- if (node->nested)
- {
- struct cgraph_node *node2;
+static int
+eq_varpool_node (const void *p1, const void *p2)
+{
+ const struct cgraph_varpool_node *n1 = p1, *n2 = p2;
+ return DECL_UID (n1->decl) == DECL_UID (n2->decl);
+}
- for (node2 = node->nested; node2; node2 = node2->next_nested)
- if (!node2->reachable)
- cgraph_mark_needed_node (node2, 0);
- }
+/* 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 key, *node, **slot;
- if (lang_hooks.callgraph.lower_function)
- (*lang_hooks.callgraph.lower_function) (decl);
- /* First kill forward declaration so reverse inling works properly. */
- cgraph_create_edges (decl, DECL_SAVED_TREE (decl));
+ gcc_assert (DECL_P (decl) && TREE_CODE (decl) != FUNCTION_DECL);
- for (edge = node->callees; edge; edge = edge->next_callee)
- {
- if (!edge->callee->reachable)
- cgraph_mark_needed_node (edge->callee, 0);
- }
- node->lowered = true;
- }
- if (!quiet_flag)
- fprintf (stderr, "\n\nReclaiming functions:");
+ if (!cgraph_varpool_hash)
+ 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 (cgraph_varpool_hash, &key, INSERT);
+ if (*slot)
+ return *slot;
+ node = ggc_alloc_cleared (sizeof (*node));
+ node->decl = decl;
+ node->next = cgraph_varpool_nodes;
+ cgraph_varpool_nodes = node;
+ *slot = node;
+ return node;
+}
- for (node = cgraph_nodes; node; node = node->next)
- {
- tree decl = node->decl;
+struct cgraph_varpool_node *
+cgraph_varpool_node_for_asm (tree asmname)
+{
+ struct cgraph_varpool_node *node;
- if (!node->reachable && DECL_SAVED_TREE (decl))
- {
- DECL_SAVED_TREE (decl) = NULL;
- announce_function (decl);
- }
- }
- ggc_collect ();
+ for (node = cgraph_varpool_nodes; node ; node = node->next)
+ if (decl_assembler_name_equal (node->decl, asmname))
+ return node;
+
+ return NULL;
}
-/* Expand all functions that must be output. */
+/* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables. */
+void
+change_decl_assembler_name (tree decl, tree name)
+{
+ if (!DECL_ASSEMBLER_NAME_SET_P (decl))
+ {
+ SET_DECL_ASSEMBLER_NAME (decl, name);
+ return;
+ }
+ if (name == DECL_ASSEMBLER_NAME (decl))
+ return;
-#define NPREDECESORS(node) (size_t)((node)->aux)
-#define SET_NPREDECESORS(node,n) (node)->aux = (void *) (n);
+ if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
+ && DECL_RTL_SET_P (decl))
+ warning ("%D renamed after being referenced in assembly", decl);
-/* Figure out what functions we want to assemble. */
+ SET_DECL_ASSEMBLER_NAME (decl, name);
+}
-static void
-cgraph_mark_functions_to_output ()
+/* Notify finalize_compilation_unit that given node is reachable
+ or needed. */
+void
+cgraph_varpool_mark_needed_node (struct cgraph_varpool_node *node)
{
- struct cgraph_node *node;
-
- /* Figure out functions we want to assemble. */
- for (node = cgraph_nodes; node; node = node->next)
+ if (!node->needed && node->finalized)
{
- tree decl = node->decl;
-
- if (DECL_SAVED_TREE (decl)
- && (node->needed
- || (DECL_UNINLINABLE (decl) && node->reachable)
- || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
- && !TREE_ASM_WRITTEN (decl) && !node->origin
- && !DECL_EXTERNAL (decl))
- node->output = 1;
+ node->next_needed = cgraph_varpool_nodes_queue;
+ cgraph_varpool_nodes_queue = node;
+ notice_global_symbol (node->decl);
}
+ node->needed = 1;
}
-/* Expand function specified by NODE. */
-static void
-cgraph_expand_function (node)
- struct cgraph_node *node;
+void
+cgraph_varpool_finalize_decl (tree decl)
{
- tree decl = node->decl;
-
- announce_function (decl);
- if (flag_inline_trees)
- optimize_inline_calls (decl);
- (*lang_hooks.callgraph.expand_function) (decl);
- if (DECL_UNINLINABLE (decl))
- DECL_SAVED_TREE (decl) = NULL;
- current_function_decl = NULL;
+ struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
+
+ /* The first declaration of a variable that comes through this function
+ decides whether it is global (in C, has external linkage)
+ or local (in C, has internal linkage). So do nothing more
+ if this function has already run. */
+ if (node->finalized)
+ return;
+ if (node->needed)
+ {
+ node->next_needed = cgraph_varpool_nodes_queue;
+ cgraph_varpool_nodes_queue = node;
+ notice_global_symbol (decl);
+ }
+ node->finalized = true;
+
+ if (/* Externally visible variables must be output. The exception are
+ COMDAT functions that must be output only when they are needed. */
+ (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
+ /* Function whose name is output to the assembler file must be produced.
+ It is possible to assemble the name later after finalizing the function
+ and the fact is noticed in assemble_name then. */
+ || (DECL_ASSEMBLER_NAME_SET_P (decl)
+ && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
+ {
+ cgraph_varpool_mark_needed_node (node);
+ }
}
-
-/* Expand all functions that must be output.
-
- Attempt to topologically sort the nodes so function is output when
- all called functions are already assembled to allow data to be propagated
- accross the callgraph. Use stack to get smaller distance between function
- and it's callees (later we may use more sophisticated algorithm for
- function reordering, we will likely want to use subsections to make output
- functions to appear in top-down order, not bottom-up they are assembled). */
-
-static void
-cgraph_expand_functions ()
+bool
+cgraph_varpool_assemble_pending_decls (void)
{
- struct cgraph_node *node;
- struct cgraph_node **stack =
- xcalloc (sizeof (struct cgraph_node *), cgraph_n_nodes);
- int stack_size = 0;
- struct cgraph_edge *edge;
-
- cgraph_mark_functions_to_output ();
+ bool changed = false;
- for (node = cgraph_nodes; node; node = node->next)
- if (node->output)
- {
- int n = 0;
- for (edge = node->callees; edge; edge = edge->next_callee)
- if (edge->callee->output)
- n++;
- SET_NPREDECESORS (node, n);
- if (n == 0)
- stack[stack_size++] = node;
- }
- while (1)
+ while (cgraph_varpool_nodes_queue)
{
- struct cgraph_node *minnode;
- while (stack_size)
+ tree decl = cgraph_varpool_nodes_queue->decl;
+ struct cgraph_varpool_node *node = cgraph_varpool_nodes_queue;
+
+ cgraph_varpool_nodes_queue = cgraph_varpool_nodes_queue->next_needed;
+ if (!TREE_ASM_WRITTEN (decl))
{
- node = stack[--stack_size];
- node->output = 0;
-
- for (edge = node->callers; edge; edge = edge->next_caller)
- if (edge->caller->output)
- {
- SET_NPREDECESORS (edge->caller,
- NPREDECESORS (edge->caller) - 1);
- if (!NPREDECESORS (edge->caller))
- stack[stack_size++] = edge->caller;
- }
- if (!node->reachable)
- abort ();
- cgraph_expand_function (node);
+ assemble_variable (decl, 0, 1, 0);
+ changed = true;
}
- minnode = NULL;
- /* We found cycle. Break it and try again. */
- for (node = cgraph_nodes; node; node = node->next)
- if (node->output
- && (!minnode
- || NPREDECESORS (minnode) > NPREDECESORS (node)))
- minnode = node;
- if (!minnode)
- return;
- stack[stack_size++] = minnode;
+ node->next_needed = NULL;
}
+ return changed;
}
-/* Perform simple optimizations based on callgraph. */
+/* 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);
+}
-void
-cgraph_optimize ()
+/* 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_node *node;
- bool changed = true;
- struct cgraph_edge *edge;
+ struct cgraph_edge *new = cgraph_create_edge (n, e->callee, call_expr);
+
+ new->inline_failed = e->inline_failed;
+ return new;
+}
- if (!quiet_flag)
- fprintf (stderr, "\n\nAssembling functions:");
+/* 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;
- /* Output everything.
- ??? Our inline heuristic may decide to not inline functions previously
- marked as inlinable thus adding new function bodies that must be output.
- Later we should move all inlining decisions to callgraph code to make
- this impossible. */
- cgraph_expand_functions ();
- while (changed)
+ new->decl = n->decl;
+ new->origin = n->origin;
+ if (new->origin)
{
- changed = false;
- for (node = cgraph_nodes; node; node = node->next)
- {
- if (!node->needed)
- continue;
-
- for (edge = node->callees; edge; edge = edge->next_callee)
- if (!edge->callee->needed)
- changed = edge->callee->needed = true;
- }
+ new->next_nested = new->origin->nested;
+ new->origin->nested = new;
}
- cgraph_expand_functions ();
+ 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
