#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 "flags.h"
#include "ggc.h"
#include "debug.h"
#include "target.h"
#include "basic-block.h"
#include "cgraph.h"
#include "varray.h"
#include "output.h"
#include "intl.h"
#include "function.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);
static inline void cgraph_edge_remove_callee (struct cgraph_edge *e);
static GTY((param_is (struct cgraph_node))) htab_t cgraph_hash;
struct cgraph_node *cgraph_nodes;
struct cgraph_node *cgraph_nodes_queue;
struct cgraph_node *cgraph_expand_queue;
int cgraph_n_nodes;
int cgraph_max_uid;
bool cgraph_global_info_ready = false;
bool cgraph_function_flags_ready = false;
static GTY((param_is (struct cgraph_varpool_node))) htab_t cgraph_varpool_hash;
struct cgraph_varpool_node *cgraph_varpool_nodes_queue, *cgraph_varpool_first_unanalyzed_node;
struct cgraph_varpool_node *cgraph_varpool_nodes;
struct cgraph_varpool_node *cgraph_varpool_last_needed_node;
struct cgraph_asm_node *cgraph_asm_nodes;
static GTY(()) struct cgraph_asm_node *cgraph_asm_last_node;
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 = (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 = (const struct cgraph_node *) p1;
const struct cgraph_node *n2 = (const struct cgraph_node *) p2;
return DECL_UID (n1->decl) == DECL_UID (n2->decl);
}
static struct cgraph_node *
cgraph_create_node (void)
{
struct cgraph_node *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;
node->global.estimated_growth = INT_MIN;
cgraph_nodes = node;
cgraph_n_nodes++;
return node;
}
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_ggc (10, hash_node, eq_node, NULL);
key.decl = decl;
slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
if (*slot)
{
node = *slot;
if (!node->master_clone)
node->master_clone = node;
return node;
}
node = cgraph_create_node ();
node->decl = decl;
*slot = node;
if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
{
node->origin = cgraph_node (DECL_CONTEXT (decl));
node->next_nested = node->origin->nested;
node->origin->nested = node;
node->master_clone = node;
}
return node;
}
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;
}
static bool
decl_assembler_name_equal (tree decl, tree asmname)
{
tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
if (decl_asmname == asmname)
return true;
#ifdef ENABLE_LLVM
if (IDENTIFIER_POINTER (decl_asmname)[0] == 1)
#else
if (IDENTIFIER_POINTER (decl_asmname)[0] == '*')
#endif
{
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;
}
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;
}
static hashval_t
edge_hash (const void *x)
{
return htab_hash_pointer (((struct cgraph_edge *) x)->call_stmt);
}
static int
edge_eq (const void *x, const void *y)
{
return ((struct cgraph_edge *) x)->call_stmt == y;
}
struct cgraph_edge *
cgraph_edge (struct cgraph_node *node, tree call_stmt)
{
struct cgraph_edge *e, *e2;
int n = 0;
if (node->call_site_hash)
return htab_find_with_hash (node->call_site_hash, call_stmt,
htab_hash_pointer (call_stmt));
for (e = node->callees; e; e= e->next_callee)
{
if (e->call_stmt == call_stmt)
break;
n++;
}
if (n > 100)
{
node->call_site_hash = htab_create_ggc (120, edge_hash, edge_eq, NULL);
for (e2 = node->callees; e2; e2 = e2->next_callee)
{
void **slot;
slot = htab_find_slot_with_hash (node->call_site_hash,
e2->call_stmt,
htab_hash_pointer (e2->call_stmt),
INSERT);
gcc_assert (!*slot);
*slot = e2;
}
}
return e;
}
void
cgraph_set_call_stmt (struct cgraph_edge *e, tree new_stmt)
{
if (e->caller->call_site_hash)
{
htab_remove_elt_with_hash (e->caller->call_site_hash,
e->call_stmt,
htab_hash_pointer (e->call_stmt));
}
e->call_stmt = new_stmt;
if (e->caller->call_site_hash)
{
void **slot;
slot = htab_find_slot_with_hash (e->caller->call_site_hash,
e->call_stmt,
htab_hash_pointer
(e->call_stmt), INSERT);
gcc_assert (!*slot);
*slot = e;
}
}
struct cgraph_edge *
cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
tree call_stmt, gcov_type count, int nest)
{
struct cgraph_edge *edge = GGC_NEW (struct cgraph_edge);
#ifdef ENABLE_CHECKING
struct cgraph_edge *e;
for (e = caller->callees; e; e = e->next_callee)
gcc_assert (e->call_stmt != call_stmt);
#endif
gcc_assert (get_call_expr_in (call_stmt));
if (!DECL_SAVED_TREE (callee->decl))
edge->inline_failed = N_("the function body must appear before caller");
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_stmt = call_stmt;
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;
edge->count = count;
edge->loop_nest = nest;
if (caller->call_site_hash)
{
void **slot;
slot = htab_find_slot_with_hash (caller->call_site_hash,
edge->call_stmt,
htab_hash_pointer
(edge->call_stmt),
INSERT);
gcc_assert (!*slot);
*slot = edge;
}
return edge;
}
static inline void
cgraph_edge_remove_callee (struct cgraph_edge *e)
{
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;
}
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;
if (e->caller->call_site_hash)
htab_remove_elt_with_hash (e->caller->call_site_hash,
e->call_stmt,
htab_hash_pointer (e->call_stmt));
}
void
cgraph_remove_edge (struct cgraph_edge *e)
{
cgraph_edge_remove_callee (e);
cgraph_edge_remove_caller (e);
}
void
cgraph_redirect_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
{
cgraph_edge_remove_callee (e);
e->prev_caller = NULL;
if (n->callers)
n->callers->prev_caller = e;
e->next_caller = n->callers;
n->callers = e;
e->callee = n;
}
void
cgraph_node_remove_callees (struct cgraph_node *node)
{
struct cgraph_edge *e;
for (e = node->callees; e; e = e->next_callee)
cgraph_edge_remove_callee (e);
node->callees = NULL;
if (node->call_site_hash)
{
htab_delete (node->call_site_hash);
node->call_site_hash = NULL;
}
}
static void
cgraph_node_remove_callers (struct cgraph_node *node)
{
struct cgraph_edge *e;
for (e = node->callers; e; e = e->next_caller)
cgraph_edge_remove_caller (e);
node->callers = NULL;
}
void
cgraph_remove_node (struct cgraph_node *node)
{
void **slot;
bool kill_body = false;
cgraph_node_remove_callers (node);
cgraph_node_remove_callees (node);
node->needed = node->reachable = false;
while (node->nested)
cgraph_remove_node (node->nested);
if (node->origin)
{
struct cgraph_node **node2 = &node->origin->nested;
while (*node2 != node)
node2 = &(*node2)->next_nested;
*node2 = node->next_nested;
}
if (node->previous)
node->previous->next = node->next;
else
cgraph_nodes = node->next;
if (node->next)
node->next->previous = node->previous;
node->next = NULL;
node->previous = NULL;
slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
if (*slot == node)
{
if (node->next_clone)
{
struct cgraph_node *new_node = node->next_clone;
struct cgraph_node *n;
for (n = new_node; n; n = n->next_clone)
n->master_clone = new_node;
*slot = new_node;
node->next_clone->prev_clone = NULL;
}
else
{
htab_clear_slot (cgraph_hash, slot);
kill_body = true;
}
}
else
{
node->prev_clone->next_clone = node->next_clone;
if (node->next_clone)
node->next_clone->prev_clone = node->prev_clone;
}
if (!kill_body && *slot)
{
struct cgraph_node *n = (struct cgraph_node *) *slot;
if (!n->next_clone && !n->global.inlined_to
&& (cgraph_global_info_ready
&& (TREE_ASM_WRITTEN (n->decl) || IS_EXTERN_NOINLINE (n->decl))))
kill_body = true;
}
if (kill_body && flag_unit_at_a_time)
{
DECL_SAVED_TREE (node->decl) = NULL;
DECL_STRUCT_FUNCTION (node->decl) = NULL;
DECL_INITIAL (node->decl) = error_mark_node;
}
node->decl = NULL;
if (node->call_site_hash)
{
htab_delete (node->call_site_hash);
node->call_site_hash = NULL;
}
cgraph_n_nodes--;
}
void
cgraph_mark_reachable_node (struct cgraph_node *node)
{
if (!node->reachable && node->local.finalized)
{
notice_global_symbol (node->decl);
node->reachable = 1;
gcc_assert (!cgraph_global_info_ready);
node->next_needed = cgraph_nodes_queue;
cgraph_nodes_queue = node;
}
}
void
cgraph_mark_needed_node (struct cgraph_node *node)
{
node->needed = 1;
cgraph_mark_reachable_node (node);
}
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;
}
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;
}
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;
}
const char *
cgraph_node_name (struct cgraph_node *node)
{
return lang_hooks.decl_printable_name (node->decl, 2);
}
static const char *
cgraph_varpool_node_name (struct cgraph_varpool_node *node)
{
return lang_hooks.decl_printable_name (node->decl, 2);
}
static const char * const availability_names[] =
{"unset", "not_available", "overwrittable", "available", "local"};
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 (cgraph_function_flags_ready)
fprintf (f, " availability:%s",
availability_names [cgraph_function_body_availability (node)]);
if (node->master_clone && node->master_clone->uid != node->uid)
fprintf (f, "(%i)", node->master_clone->uid);
if (node->count)
fprintf (f, " executed "HOST_WIDEST_INT_PRINT_DEC"x",
(HOST_WIDEST_INT)node->count);
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.externally_visible)
fprintf (f, " externally_visible");
if (node->local.finalized)
fprintf (f, " finalized");
if (node->local.disregard_inline_limits)
fprintf (f, " always_inline");
else if (node->local.inlinable)
fprintf (f, " inlinable");
if (node->local.redefined_extern_inline)
fprintf (f, " redefined_extern_inline");
if (TREE_ASM_WRITTEN (node->decl))
fprintf (f, " asm_written");
if (DECL_STRUCT_FUNCTION (node->decl) && DECL_STRUCT_FUNCTION (node->decl)->uses_vector)
fprintf (f, " uses_vector");
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->count)
fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
(HOST_WIDEST_INT)edge->count);
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) ");
if (edge->count)
fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
(HOST_WIDEST_INT)edge->count);
if (edge->loop_nest)
fprintf (f, "(nested in %i loops) ", edge->loop_nest);
}
fprintf (f, "\n");
}
void
dump_cgraph (FILE *f)
{
struct cgraph_node *node;
fprintf (f, "callgraph:\n\n");
for (node = cgraph_nodes; node; node = node->next)
dump_cgraph_node (f, node);
}
void
dump_cgraph_varpool_node (FILE *f, struct cgraph_varpool_node *node)
{
fprintf (f, "%s:", cgraph_varpool_node_name (node));
fprintf (f, " availability:%s",
cgraph_function_flags_ready
? availability_names[cgraph_variable_initializer_availability (node)]
: "not-ready");
if (DECL_INITIAL (node->decl))
fprintf (f, " initialized");
if (node->needed)
fprintf (f, " needed");
if (node->analyzed)
fprintf (f, " analyzed");
if (node->finalized)
fprintf (f, " finalized");
if (node->output)
fprintf (f, " output");
if (node->externally_visible)
fprintf (f, " externally_visible");
fprintf (f, "\n");
}
void
dump_varpool (FILE *f)
{
struct cgraph_varpool_node *node;
fprintf (f, "variable pool:\n\n");
for (node = cgraph_varpool_nodes; node; node = node->next_needed)
dump_cgraph_varpool_node (f, node);
}
static hashval_t
hash_varpool_node (const void *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 =
(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);
}
struct cgraph_varpool_node *
cgraph_varpool_node (tree decl)
{
struct cgraph_varpool_node key, *node, **slot;
gcc_assert (DECL_P (decl) && TREE_CODE (decl) != FUNCTION_DECL);
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_CNEW (struct cgraph_varpool_node);
node->decl = decl;
node->order = cgraph_order++;
node->next = cgraph_varpool_nodes;
cgraph_varpool_nodes = node;
*slot = node;
return node;
}
struct cgraph_varpool_node *
cgraph_varpool_node_for_asm (tree asmname)
{
struct cgraph_varpool_node *node;
for (node = cgraph_varpool_nodes; node ; node = node->next)
if (decl_assembler_name_equal (node->decl, asmname))
return node;
return NULL;
}
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;
if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
&& DECL_RTL_SET_P (decl))
warning (0, "%D renamed after being referenced in assembly", decl);
SET_DECL_ASSEMBLER_NAME (decl, name);
}
void
cgraph_varpool_enqueue_needed_node (struct cgraph_varpool_node *node)
{
if (cgraph_varpool_last_needed_node)
cgraph_varpool_last_needed_node->next_needed = node;
cgraph_varpool_last_needed_node = node;
node->next_needed = NULL;
if (!cgraph_varpool_nodes_queue)
cgraph_varpool_nodes_queue = node;
if (!cgraph_varpool_first_unanalyzed_node)
cgraph_varpool_first_unanalyzed_node = node;
notice_global_symbol (node->decl);
}
void
cgraph_varpool_reset_queue (void)
{
cgraph_varpool_last_needed_node = NULL;
cgraph_varpool_nodes_queue = NULL;
cgraph_varpool_first_unanalyzed_node = NULL;
}
void
cgraph_varpool_mark_needed_node (struct cgraph_varpool_node *node)
{
if (!node->needed && node->finalized
&& !TREE_ASM_WRITTEN (node->decl))
cgraph_varpool_enqueue_needed_node (node);
node->needed = 1;
}
bool
decide_is_variable_needed (struct cgraph_varpool_node *node, tree decl)
{
if (node->externally_visible)
return true;
if (!flag_unit_at_a_time
&& lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
return true;
if (DECL_ASSEMBLER_NAME_SET_P (decl)
&& TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
return true;
if (node->needed)
return true;
if (TREE_PUBLIC (decl) && !flag_whole_program && !DECL_COMDAT (decl)
&& !DECL_EXTERNAL (decl))
return true;
if (flag_unit_at_a_time && flag_toplevel_reorder)
return false;
if (DECL_COMDAT (decl))
return false;
return true;
}
void
cgraph_varpool_finalize_decl (tree decl)
{
struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
if (node->finalized)
{
if (cgraph_global_info_ready || (!flag_unit_at_a_time && !flag_openmp))
cgraph_varpool_assemble_pending_decls ();
return;
}
if (node->needed)
cgraph_varpool_enqueue_needed_node (node);
node->finalized = true;
if (decide_is_variable_needed (node, decl))
cgraph_varpool_mark_needed_node (node);
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 && !flag_openmp))
cgraph_varpool_assemble_pending_decls ();
}
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;
}
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);
}
struct cgraph_edge *
cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n,
tree call_stmt, gcov_type count_scale, int loop_nest,
bool update_original)
{
struct cgraph_edge *new;
new = cgraph_create_edge (n, e->callee, call_stmt,
e->count * count_scale / REG_BR_PROB_BASE,
e->loop_nest + loop_nest);
new->inline_failed = e->inline_failed;
if (update_original)
{
e->count -= new->count;
if (e->count < 0)
e->count = 0;
}
return new;
}
struct cgraph_node *
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;
gcov_type count_scale;
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;
new->master_clone = n->master_clone;
new->count = count;
if (n->count)
count_scale = new->count * REG_BR_PROB_BASE / n->count;
else
count_scale = 0;
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,
update_original);
new->next_clone = n->next_clone;
new->prev_clone = n;
n->next_clone = new;
if (new->next_clone)
new->next_clone->prev_clone = new;
return new;
}
bool
cgraph_is_master_clone (struct cgraph_node *n)
{
return (n == cgraph_master_clone (n));
}
struct cgraph_node *
cgraph_master_clone (struct cgraph_node *n)
{
enum availability avail = cgraph_function_body_availability (n);
if (avail == AVAIL_NOT_AVAILABLE || avail == AVAIL_OVERWRITABLE)
return NULL;
if (!n->master_clone)
n->master_clone = cgraph_node (n->decl);
return n->master_clone;
}
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;
}
enum availability
cgraph_function_body_availability (struct cgraph_node *node)
{
enum availability avail;
gcc_assert (cgraph_function_flags_ready);
if (!node->analyzed)
avail = AVAIL_NOT_AVAILABLE;
else if (node->local.local)
avail = AVAIL_LOCAL;
else if (node->local.externally_visible)
avail = AVAIL_AVAILABLE;
else if (!(*targetm.binds_local_p) (node->decl)
&& !DECL_COMDAT (node->decl) && !IS_EXTERN_INLINE (node->decl))
avail = AVAIL_OVERWRITABLE;
else avail = AVAIL_AVAILABLE;
return avail;
}
enum availability
cgraph_variable_initializer_availability (struct cgraph_varpool_node *node)
{
gcc_assert (cgraph_function_flags_ready);
if (!node->finalized)
return AVAIL_NOT_AVAILABLE;
if (!TREE_PUBLIC (node->decl))
return AVAIL_AVAILABLE;
if (!(*targetm.binds_local_p) (node->decl) && !DECL_COMDAT (node->decl))
return AVAIL_OVERWRITABLE;
return AVAIL_AVAILABLE;
}
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"