You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
/* This file contains basic routines manipulating call graph and variable pool
#include "output.h"
#include "intl.h"
#include "tree-gimple.h"
+#include "tree-dump.h"
static void cgraph_node_remove_callers (struct cgraph_node *node);
static inline void cgraph_edge_remove_caller (struct cgraph_edge *e);
/* Queue of cgraph nodes scheduled to be lowered. */
struct cgraph_node *cgraph_nodes_queue;
+/* Queue of cgraph nodes scheduled to be expanded. This is a
+ secondary queue used during optimization to accommodate passes that
+ may generate new functions that need to be optimized and expanded. */
+struct cgraph_node *cgraph_expand_queue;
+
/* Number of nodes in existence. */
int cgraph_n_nodes;
/* Queue of cgraph nodes scheduled to be lowered and output. */
struct cgraph_varpool_node *cgraph_varpool_nodes_queue, *cgraph_varpool_first_unanalyzed_node;
-
/* The linked list of cgraph varpool nodes. */
static GTY(()) struct cgraph_varpool_node *cgraph_varpool_nodes;
/* End of the varpool queue. Needs to be QTYed to work with PCH. */
static GTY(()) struct cgraph_varpool_node *cgraph_varpool_last_needed_node;
+/* Linked list of cgraph asm nodes. */
+struct cgraph_asm_node *cgraph_asm_nodes;
+
+/* Last node in cgraph_asm_nodes. */
+static GTY(()) struct cgraph_asm_node *cgraph_asm_last_node;
+
+/* The order index of the next cgraph node to be created. This is
+ used so that we can sort the cgraph nodes in order by when we saw
+ them, to support -fno-toplevel-reorder. */
+int cgraph_order;
+
static hashval_t hash_node (const void *);
static int eq_node (const void *, const void *);
static hashval_t
hash_node (const void *p)
{
- const struct cgraph_node *n = p;
+ const struct cgraph_node *n = (const struct cgraph_node *) p;
return (hashval_t) DECL_UID (n->decl);
}
static int
eq_node (const void *p1, const void *p2)
{
- const struct cgraph_node *n1 = p1, *n2 = p2;
+ const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
+ const struct cgraph_node *n2 = (const struct cgraph_node *) p2;
return DECL_UID (n1->decl) == DECL_UID (n2->decl);
}
{
struct cgraph_node *node;
- node = ggc_alloc_cleared (sizeof (*node));
+ node = GGC_CNEW (struct cgraph_node);
node->next = cgraph_nodes;
node->uid = cgraph_max_uid++;
+ node->order = cgraph_order++;
if (cgraph_nodes)
cgraph_nodes->previous = node;
node->previous = NULL;
return node;
}
+/* Insert already constructed node into hashtable. */
+
+void
+cgraph_insert_node_to_hashtable (struct cgraph_node *node)
+{
+ struct cgraph_node **slot;
+
+ slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, node, INSERT);
+
+ gcc_assert (!*slot);
+ *slot = node;
+}
+
/* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
static bool
cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
tree call_stmt, gcov_type count, int nest)
{
- struct cgraph_edge *edge = ggc_alloc (sizeof (struct cgraph_edge));
+ struct cgraph_edge *edge = GGC_NEW (struct cgraph_edge);
#ifdef ENABLE_CHECKING
struct cgraph_edge *e;
*/
if (!kill_body && *slot)
{
- struct cgraph_node *n = *slot;
+ struct cgraph_node *n = (struct cgraph_node *) *slot;
if (!n->next_clone && !n->global.inlined_to
- && (TREE_ASM_WRITTEN (n->decl) || DECL_EXTERNAL (n->decl)))
+ && (cgraph_global_info_ready
+ && (TREE_ASM_WRITTEN (n->decl) || DECL_EXTERNAL (n->decl))))
kill_body = true;
}
static hashval_t
hash_varpool_node (const void *p)
{
- const struct cgraph_varpool_node *n = p;
+ const struct cgraph_varpool_node *n = (const struct cgraph_varpool_node *) p;
return (hashval_t) DECL_UID (n->decl);
}
static int
eq_varpool_node (const void *p1, const void *p2)
{
- const struct cgraph_varpool_node *n1 = p1, *n2 = p2;
+ const struct cgraph_varpool_node *n1 =
+ (const struct cgraph_varpool_node *) p1;
+ const struct cgraph_varpool_node *n2 =
+ (const struct cgraph_varpool_node *) p2;
return DECL_UID (n1->decl) == DECL_UID (n2->decl);
}
htab_find_slot (cgraph_varpool_hash, &key, INSERT);
if (*slot)
return *slot;
- node = ggc_alloc_cleared (sizeof (*node));
+ node = GGC_CNEW (struct cgraph_varpool_node);
node->decl = decl;
+ node->order = cgraph_order++;
node->next = cgraph_varpool_nodes;
cgraph_varpool_nodes = node;
*slot = node;
decide_is_variable_needed (struct cgraph_varpool_node *node, tree decl)
{
/* If the user told us it is used, then it must be so. */
- if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
+ if (node->externally_visible
+ || lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
return true;
/* ??? If the assembler name is set by hand, it is possible to assemble
if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
return true;
- if (flag_unit_at_a_time)
+ /* When not reordering top level variables, we have to assume that
+ we are going to keep everything. */
+ if (flag_unit_at_a_time && flag_toplevel_reorder)
return false;
- /* If not doing unit at a time, then we'll only defer this function
- if its marked for inlining. Otherwise we want to emit it now. */
-
/* We want to emit COMDAT variables only when absolutely necessary. */
if (DECL_COMDAT (decl))
return false;
if this function has already run. */
if (node->finalized)
{
- if (cgraph_global_info_ready || !flag_unit_at_a_time)
+ if (cgraph_global_info_ready || (!flag_unit_at_a_time && !flag_openmp))
cgraph_varpool_assemble_pending_decls ();
return;
}
/* Since we reclaim unreachable nodes at the end of every language
level unit, we need to be conservative about possible entry points
there. */
- if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
+ else if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
cgraph_varpool_mark_needed_node (node);
- if (cgraph_global_info_ready || !flag_unit_at_a_time)
+ if (cgraph_global_info_ready || (!flag_unit_at_a_time && !flag_openmp))
cgraph_varpool_assemble_pending_decls ();
}
+/* Add a top-level asm statement to the list. */
+
+struct cgraph_asm_node *
+cgraph_add_asm_node (tree asm_str)
+{
+ struct cgraph_asm_node *node;
+
+ node = GGC_CNEW (struct cgraph_asm_node);
+ node->asm_str = asm_str;
+ node->order = cgraph_order++;
+ node->next = NULL;
+ if (cgraph_asm_nodes == NULL)
+ cgraph_asm_nodes = node;
+ else
+ cgraph_asm_last_node->next = node;
+ cgraph_asm_last_node = node;
+ return node;
+}
+
/* Return true when the DECL can possibly be inlined. */
bool
cgraph_function_possibly_inlined_p (tree 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_stmt, int count_scale, int loop_nest)
+ tree call_stmt, gcov_type count_scale, int loop_nest,
+ bool update_original)
{
struct cgraph_edge *new;
e->loop_nest + loop_nest);
new->inline_failed = e->inline_failed;
- e->count -= new->count;
+ if (update_original)
+ {
+ e->count -= new->count;
+ if (e->count < 0)
+ e->count = 0;
+ }
return new;
}
/* Create node representing clone of N executed COUNT times. Decrease
- the execution counts from original node too. */
+ the execution counts from original node too.
+
+ When UPDATE_ORIGINAL is true, the counts are subtracted from the original
+ function's profile to reflect the fact that part of execution is handled
+ by node. */
struct cgraph_node *
-cgraph_clone_node (struct cgraph_node *n, gcov_type count, int loop_nest)
+cgraph_clone_node (struct cgraph_node *n, gcov_type count, int loop_nest,
+ bool update_original)
{
struct cgraph_node *new = cgraph_create_node ();
struct cgraph_edge *e;
- int count_scale;
+ gcov_type count_scale;
new->decl = n->decl;
new->origin = n->origin;
count_scale = new->count * REG_BR_PROB_BASE / n->count;
else
count_scale = 0;
- n->count -= count;
+ if (update_original)
+ {
+ n->count -= count;
+ if (n->count < 0)
+ n->count = 0;
+ }
for (e = n->callees;e; e=e->next_callee)
- cgraph_clone_edge (e, new, e->call_stmt, count_scale, loop_nest);
+ cgraph_clone_edge (e, new, e->call_stmt, count_scale, loop_nest,
+ update_original);
new->next_clone = n->next_clone;
new->prev_clone = n;
{
enum availability avail;
gcc_assert (cgraph_function_flags_ready);
- if (!node->local.finalized)
+ if (!node->analyzed)
avail = AVAIL_NOT_AVAILABLE;
else if (node->local.local)
avail = AVAIL_LOCAL;
return AVAIL_AVAILABLE;
}
+
+/* Add the function FNDECL to the call graph. FNDECL is assumed to be
+ in low GIMPLE form and ready to be processed by cgraph_finalize_function.
+
+ When operating in unit-at-a-time, a new callgraph node is added to
+ CGRAPH_EXPAND_QUEUE, which is processed after all the original
+ functions in the call graph .
+
+ When not in unit-at-a-time, the new callgraph node is added to
+ CGRAPH_NODES_QUEUE for cgraph_assemble_pending_functions to
+ process. */
+
+void
+cgraph_add_new_function (tree fndecl)
+{
+ struct cgraph_node *n = cgraph_node (fndecl);
+ n->next_needed = cgraph_expand_queue;
+ cgraph_expand_queue = n;
+}
+
#include "gt-cgraph.h"
OSDN Git Service
