int getSize(char *name) {
struct cgraph_node *node;
basic_block bb;
gimple statement;
enum gimple_code code;
gimple_stmt_iterator gsi;
int size = 0;
for (node = cgraph_nodes; node; node = node->next) {
/* Nodes without a body, and clone nodes are not interesting. */
if (!gimple_has_body_p(node->decl) || node->clone_of)
continue;
if (strcmp(cgraph_node_name(node), name) == 0) {
set_cfun(DECL_STRUCT_FUNCTION(node->decl));
//fprintf(stderr, "%s --> ", cgraph_node_name(node));
FOR_ALL_BB(bb) {
for (gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) {
statement = gsi_stmt(gsi);
code = gimple_code(statement);
//debug_gimple_stmt(statement);
if (code != GIMPLE_CALL) {
size++;
}
}
}
return size;
}
}
static void
test_conversion_to_ssa ()
{
/* As above, construct a trivial function, gimplify it, and build a CFG: */
tree fndecl = build_trivial_high_gimple_function ();
function *fun = DECL_STRUCT_FUNCTION (fndecl);
ASSERT_TRUE (fun != NULL);
build_cfg (fndecl);
convert_to_ssa (fndecl);
verify_three_block_gimple_cfg (fun);
/* For out trivial test function we should now have something like
this:
test_fn ()
{
<bb 2>:
_1 = 42;
return _1;
}
*/
basic_block bb2 = get_real_block (fun);
gimple *stmt_a = gimple_seq_first_stmt (bb_seq (bb2));
ASSERT_EQ (GIMPLE_ASSIGN, gimple_code (stmt_a));
gimple *stmt_b = stmt_a->next;
ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt_b));
ASSERT_EQ (NULL, stmt_b->next);
greturn *return_stmt = as_a <greturn *> (stmt_b);
ASSERT_EQ (SSA_NAME, TREE_CODE (gimple_return_retval (return_stmt)));
}
void
record_vars_into (tree vars, tree fn)
{
bool change_cfun = fn != current_function_decl;
if (change_cfun)
push_cfun (DECL_STRUCT_FUNCTION (fn));
for (; vars; vars = DECL_CHAIN (vars))
{
tree var = vars;
/* BIND_EXPRs contains also function/type/constant declarations
we don't need to care about. */
if (TREE_CODE (var) != VAR_DECL)
continue;
/* Nothing to do in this case. */
if (DECL_EXTERNAL (var))
continue;
/* Record the variable. */
add_local_decl (cfun, var);
}
if (change_cfun)
pop_cfun ();
}
static void
call_graph_add_fn (tree fndecl)
{
const tree outer = current_function_decl;
struct function *f = DECL_STRUCT_FUNCTION (fndecl);
gcc_assert (TREE_CODE (fndecl) == FUNCTION_DECL);
f->is_cilk_function = 1;
f->curr_properties = cfun->curr_properties;
gcc_assert (cfun == DECL_STRUCT_FUNCTION (outer));
gcc_assert (cfun->decl == outer);
push_cfun (f);
cgraph_node::create (fndecl);
pop_cfun_to (outer);
}
static void
set_callers_may_not_allocate_frame (function *fn)
{
basic_block bb;
gimple_stmt_iterator gsi;
gimple *stmt;
tree called_fn_tree;
function *called_fn;
if (fn->cfg == NULL)
return;
FOR_EACH_BB_FN (bb, fn)
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
stmt = gsi_stmt (gsi);
if (is_gimple_call (stmt))
{
called_fn_tree = gimple_call_fndecl (stmt);
if (called_fn_tree != NULL)
{
called_fn = DECL_STRUCT_FUNCTION (called_fn_tree);
if (called_fn != NULL)
called_fn->machine->callers_may_not_allocate_frame = true;
}
}
}
}
return;
}
static void
analyze_function (struct cgraph_node *fn)
{
ipa_reference_vars_info_t info
= xcalloc (1, sizeof (struct ipa_reference_vars_info_d));
ipa_reference_local_vars_info_t l
= xcalloc (1, sizeof (struct ipa_reference_local_vars_info_d));
tree decl = fn->decl;
/* Add the info to the tree's annotation. */
get_function_ann (fn->decl)->reference_vars_info = info;
info->local = l;
l->statics_read = BITMAP_ALLOC (&ipa_obstack);
l->statics_written = BITMAP_ALLOC (&ipa_obstack);
if (dump_file)
fprintf (dump_file, "\n local analysis of %s\n", cgraph_node_name (fn));
{
struct function *this_cfun = DECL_STRUCT_FUNCTION (decl);
basic_block this_block;
FOR_EACH_BB_FN (this_block, this_cfun)
{
block_stmt_iterator bsi;
for (bsi = bsi_start (this_block); !bsi_end_p (bsi); bsi_next (&bsi))
walk_tree (bsi_stmt_ptr (bsi), scan_for_static_refs,
fn, visited_nodes);
}
}
static void
pop_cfun_to (tree outer)
{
pop_cfun ();
current_function_decl = outer;
gcc_assert (cfun == DECL_STRUCT_FUNCTION (current_function_decl));
gcc_assert (cfun->decl == current_function_decl);
}
static void
build_function (tree fndecl, tree stmts, tree block)
{
DECL_INITIAL(fndecl) = block;
DECL_SAVED_TREE (fndecl) = stmts ;
tree resdecl = build_decl(input_location,RESULT_DECL, NULL_TREE, integer_type_node);
DECL_CONTEXT (resdecl) = fndecl;
DECL_RESULT(fndecl) = resdecl;
current_function_decl = fndecl;
if (DECL_STRUCT_FUNCTION(fndecl) == NULL)
push_struct_function(fndecl);
else
push_cfun(DECL_STRUCT_FUNCTION(fndecl));
cfun->function_end_locus = BUILTINS_LOCATION;
}
/* Computes the frequency of the call statement so that it can be stored in
cgraph_edge. BB is the basic block of the call statement. */
int
compute_call_stmt_bb_frequency (tree decl, basic_block bb)
{
int entry_freq = ENTRY_BLOCK_PTR_FOR_FN
(DECL_STRUCT_FUNCTION (decl))->frequency;
int freq = bb->frequency;
if (profile_status_for_fn (DECL_STRUCT_FUNCTION (decl)) == PROFILE_ABSENT)
return CGRAPH_FREQ_BASE;
if (!entry_freq)
entry_freq = 1, freq++;
freq = freq * CGRAPH_FREQ_BASE / entry_freq;
if (freq > CGRAPH_FREQ_MAX)
freq = CGRAPH_FREQ_MAX;
return freq;
}
static void
afdo_indirect_call (gimple_stmt_iterator *gsi, const icall_target_map &map,
bool transform)
{
gimple gs = gsi_stmt (*gsi);
tree callee;
if (map.size () == 0)
return;
gcall *stmt = dyn_cast <gcall *> (gs);
if ((!stmt) || gimple_call_fndecl (stmt) != NULL_TREE)
return;
callee = gimple_call_fn (stmt);
histogram_value hist = gimple_alloc_histogram_value (
cfun, HIST_TYPE_INDIR_CALL, stmt, callee);
hist->n_counters = 3;
hist->hvalue.counters = XNEWVEC (gcov_type, hist->n_counters);
gimple_add_histogram_value (cfun, stmt, hist);
gcov_type total = 0;
icall_target_map::const_iterator max_iter = map.end ();
for (icall_target_map::const_iterator iter = map.begin ();
iter != map.end (); ++iter)
{
total += iter->second;
if (max_iter == map.end () || max_iter->second < iter->second)
max_iter = iter;
}
hist->hvalue.counters[0]
= (unsigned long long)afdo_string_table->get_name (max_iter->first);
hist->hvalue.counters[1] = max_iter->second;
hist->hvalue.counters[2] = total;
if (!transform)
return;
struct cgraph_edge *indirect_edge
= cgraph_node::get (current_function_decl)->get_edge (stmt);
struct cgraph_node *direct_call = cgraph_node::get_for_asmname (
get_identifier ((const char *) hist->hvalue.counters[0]));
if (direct_call == NULL || !check_ic_target (stmt, direct_call))
return;
if (DECL_STRUCT_FUNCTION (direct_call->decl) == NULL)
return;
struct cgraph_edge *new_edge
= indirect_edge->make_speculative (direct_call, 0, 0);
new_edge->redirect_call_stmt_to_callee ();
gimple_remove_histogram_value (cfun, stmt, hist);
inline_call (new_edge, true, NULL, NULL, false);
}
static void
convert_to_ssa (tree fndecl)
{
function *fun = DECL_STRUCT_FUNCTION (fndecl);
ASSERT_TRUE (fun != NULL);
ASSERT_EQ (fndecl, fun->decl);
gimple_opt_pass *build_ssa_pass = make_pass_build_ssa (g);
push_cfun (fun);
build_ssa_pass->execute (fun);
pop_cfun ();
}
symtab_node *
symtab_nonoverwritable_alias (symtab_node *node)
{
tree new_decl;
symtab_node *new_node = NULL;
/* First try to look up existing alias or base object
(if that is already non-overwritable). */
node = symtab_alias_ultimate_target (node, NULL);
gcc_assert (!node->alias && !node->weakref);
symtab_for_node_and_aliases (node, symtab_nonoverwritable_alias_1,
(void *)&new_node, true);
if (new_node)
return new_node;
#ifndef ASM_OUTPUT_DEF
/* If aliases aren't supported by the assembler, fail. */
return NULL;
#endif
/* Otherwise create a new one. */
new_decl = copy_node (node->decl);
DECL_DLLIMPORT_P (new_decl) = 0;
DECL_NAME (new_decl) = clone_function_name (node->decl, "localalias");
if (TREE_CODE (new_decl) == FUNCTION_DECL)
DECL_STRUCT_FUNCTION (new_decl) = NULL;
DECL_INITIAL (new_decl) = NULL;
SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
SET_DECL_RTL (new_decl, NULL);
/* Update the properties. */
DECL_EXTERNAL (new_decl) = 0;
if (DECL_ONE_ONLY (node->decl))
DECL_SECTION_NAME (new_decl) = NULL;
DECL_COMDAT_GROUP (new_decl) = 0;
TREE_PUBLIC (new_decl) = 0;
DECL_COMDAT (new_decl) = 0;
DECL_WEAK (new_decl) = 0;
DECL_VIRTUAL_P (new_decl) = 0;
if (TREE_CODE (new_decl) == FUNCTION_DECL)
{
DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
DECL_STATIC_DESTRUCTOR (new_decl) = 0;
new_node = cgraph_create_function_alias
(new_decl, node->decl);
}
else
new_node = varpool_create_variable_alias (new_decl,
node->decl);
symtab_resolve_alias (new_node, node);
gcc_assert (decl_binds_to_current_def_p (new_decl));
return new_node;
}
/* Check the consistency of profile information. We can't do that
in verify_flow_info, as the counts may get invalid for incompletely
solved graphs, later eliminating of conditionals or roundoff errors.
It is still practical to have them reported for debugging of simple
testcases. */
static void
check_bb_profile (basic_block bb, FILE * file, int indent, int flags)
{
edge e;
int sum = 0;
gcov_type lsum;
edge_iterator ei;
struct function *fun = DECL_STRUCT_FUNCTION (current_function_decl);
char *s_indent = (char *) alloca ((size_t) indent + 1);
memset ((void *) s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';
if (profile_status_for_function (fun) == PROFILE_ABSENT)
return;
if (bb != EXIT_BLOCK_PTR_FOR_FUNCTION (fun))
{
FOR_EACH_EDGE (e, ei, bb->succs)
sum += e->probability;
if (EDGE_COUNT (bb->succs) && abs (sum - REG_BR_PROB_BASE) > 100)
fprintf (file, "%s%sInvalid sum of outgoing probabilities %.1f%%\n",
(flags & TDF_COMMENT) ? ";; " : "", s_indent,
sum * 100.0 / REG_BR_PROB_BASE);
lsum = 0;
FOR_EACH_EDGE (e, ei, bb->succs)
lsum += e->count;
if (EDGE_COUNT (bb->succs)
&& (lsum - bb->count > 100 || lsum - bb->count < -100))
fprintf (file, "%s%sInvalid sum of outgoing counts %i, should be %i\n",
(flags & TDF_COMMENT) ? ";; " : "", s_indent,
(int) lsum, (int) bb->count);
}
if (bb != ENTRY_BLOCK_PTR_FOR_FUNCTION (fun))
{
sum = 0;
FOR_EACH_EDGE (e, ei, bb->preds)
sum += EDGE_FREQUENCY (e);
if (abs (sum - bb->frequency) > 100)
fprintf (file,
"%s%sInvalid sum of incoming frequencies %i, should be %i\n",
(flags & TDF_COMMENT) ? ";; " : "", s_indent,
sum, bb->frequency);
lsum = 0;
FOR_EACH_EDGE (e, ei, bb->preds)
lsum += e->count;
if (lsum - bb->count > 100 || lsum - bb->count < -100)
fprintf (file, "%s%sInvalid sum of incoming counts %i, should be %i\n",
(flags & TDF_COMMENT) ? ";; " : "", s_indent,
(int) lsum, (int) bb->count);
}
}
void xml_local_decls(int indent, FILE *out)
{
tree var;
fprintf(out, "%s<locals>\n", spc(indent));
indent += INDENT;
for (var = DECL_STRUCT_FUNCTION(current_function_decl)->local_decls;
var;
var = TREE_CHAIN(var))
xml_local_decl(TREE_VALUE(var), indent, out);
indent -= INDENT;
fprintf(out, "%s</locals>\n", spc(indent));
}
void
gimple_set_body (tree fndecl, gimple_seq seq)
{
struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
if (fn == NULL)
{
/* If FNDECL still does not have a function structure associated
with it, then it does not make sense for it to receive a
GIMPLE body. */
gcc_assert (seq == NULL);
}
else
fn->gimple_body = seq;
}
static funct_state
analyze_function (struct cgraph_node *fn, bool ipa)
{
tree decl = fn->decl;
funct_state l;
basic_block this_block;
l = XCNEW (struct funct_state_d);
l->pure_const_state = IPA_CONST;
l->state_previously_known = IPA_NEITHER;
l->looping_previously_known = true;
l->looping = false;
l->can_throw = false;
state_from_flags (&l->state_previously_known, &l->looping_previously_known,
flags_from_decl_or_type (fn->decl),
fn->cannot_return_p ());
if (fn->thunk.thunk_p || fn->alias)
{
/* Thunk gets propagated through, so nothing interesting happens. */
gcc_assert (ipa);
return l;
}
if (dump_file)
{
fprintf (dump_file, "\n\n local analysis of %s\n ",
fn->name ());
}
push_cfun (DECL_STRUCT_FUNCTION (decl));
FOR_EACH_BB_FN (this_block, cfun)
{
gimple_stmt_iterator gsi;
struct walk_stmt_info wi;
memset (&wi, 0, sizeof (wi));
for (gsi = gsi_start_bb (this_block);
!gsi_end_p (gsi);
gsi_next (&gsi))
{
check_stmt (&gsi, l, ipa);
if (l->pure_const_state == IPA_NEITHER && l->looping && l->can_throw)
goto end;
}
}
static void
test_building_cfg ()
{
/* Construct a trivial function, and gimplify it: */
tree fndecl = build_trivial_high_gimple_function ();
function *fun = DECL_STRUCT_FUNCTION (fndecl);
ASSERT_TRUE (fun != NULL);
/* Build a CFG. */
build_cfg (fndecl);
/* The CFG-building code constructs a 4-block cfg (with
ENTRY and EXIT):
test_fn ()
{
<bb 2>:
D.65 = 42;
<bb 3>:
return D.65;
}
and then ought to merge blocks 2 and 3 in cleanup_tree_cfg.
Hence we should end up with a simple 3-block cfg, the two "fake" ones,
and a "real" one:
[ENTRY] -> [block2] -> [EXIT]
with code like this:
test_fn ()
{
<bb 2>:
D.56 = 42;
return D.56;
}
*/
verify_three_block_gimple_cfg (fun);
/* Verify the statements within the "real" block. */
basic_block bb2 = get_real_block (fun);
gimple *stmt_a = gimple_seq_first_stmt (bb_seq (bb2));
ASSERT_EQ (GIMPLE_ASSIGN, gimple_code (stmt_a));
gimple *stmt_b = stmt_a->next;
ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt_b));
ASSERT_EQ (NULL, stmt_b->next);
}
void
tree_lowering_passes (tree fn)
{
tree saved_current_function_decl = current_function_decl;
current_function_decl = fn;
push_cfun (DECL_STRUCT_FUNCTION (fn));
gimple_register_cfg_hooks ();
bitmap_obstack_initialize (NULL);
execute_pass_list (all_lowering_passes);
if (optimize && cgraph_global_info_ready)
execute_pass_list (pass_early_local_passes.pass.sub);
free_dominance_info (CDI_POST_DOMINATORS);
free_dominance_info (CDI_DOMINATORS);
compact_blocks ();
current_function_decl = saved_current_function_decl;
bitmap_obstack_release (NULL);
pop_cfun ();
}
void
record_vars_into (tree vars, tree fn)
{
for (; vars; vars = DECL_CHAIN (vars))
{
tree var = vars;
/* BIND_EXPRs contains also function/type/constant declarations
we don't need to care about. */
if (TREE_CODE (var) != VAR_DECL)
continue;
/* Nothing to do in this case. */
if (DECL_EXTERNAL (var))
continue;
/* Record the variable. */
add_local_decl (DECL_STRUCT_FUNCTION (fn), var);
}
}
static void
test_gimplification ()
{
tree fndecl = build_trivial_generic_function ();
/* Convert to gimple: */
gimplify_function_tree (fndecl);
/* Verify that we got gimple out of it. */
/* The function is now in GIMPLE form but the CFG has not been
built yet. */
/* We should have a struct function for the decl. */
function *fun = DECL_STRUCT_FUNCTION (fndecl);
ASSERT_TRUE (fun != NULL);
ASSERT_EQ (fndecl, fun->decl);
/* We expect a GIMPLE_BIND, with two gimple statements within it:
tmp = 42;
return tmp; */
gimple_seq seq_fn_body = gimple_body (fndecl);
ASSERT_TRUE (seq_fn_body != NULL);
gimple *bind_stmt = gimple_seq_first_stmt (seq_fn_body);
ASSERT_EQ (GIMPLE_BIND, gimple_code (bind_stmt));
ASSERT_EQ (NULL, bind_stmt->next);
gimple_seq seq_bind_body = gimple_bind_body (as_a <gbind *> (bind_stmt));
/* Verify that we have the 2 statements we expect. */
ASSERT_TRUE (seq_bind_body != NULL);
gimple *stmt1 = gimple_seq_first_stmt (seq_bind_body);
ASSERT_TRUE (stmt1 != NULL);
ASSERT_EQ (GIMPLE_ASSIGN, gimple_code (stmt1));
gimple *stmt2 = stmt1->next;
ASSERT_TRUE (stmt2 != NULL);
ASSERT_EQ (stmt1, stmt2->prev);
ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt2));
}
symtab_node
symtab_nonoverwritable_alias (symtab_node node)
{
tree new_decl;
symtab_node new_node = NULL;
symtab_for_node_and_aliases (node, symtab_nonoverwritable_alias_1,
(void *)&new_node, true);
if (new_node)
return new_node;
new_decl = copy_node (node->symbol.decl);
DECL_NAME (new_decl) = clone_function_name (node->symbol.decl, "localalias");
if (TREE_CODE (new_decl) == FUNCTION_DECL)
DECL_STRUCT_FUNCTION (new_decl) = NULL;
DECL_INITIAL (new_decl) = NULL;
SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
SET_DECL_RTL (new_decl, NULL);
/* Update the properties. */
DECL_EXTERNAL (new_decl) = 0;
if (DECL_ONE_ONLY (node->symbol.decl))
DECL_SECTION_NAME (new_decl) = NULL;
DECL_COMDAT_GROUP (new_decl) = 0;
TREE_PUBLIC (new_decl) = 0;
DECL_COMDAT (new_decl) = 0;
DECL_WEAK (new_decl) = 0;
DECL_VIRTUAL_P (new_decl) = 0;
if (TREE_CODE (new_decl) == FUNCTION_DECL)
{
DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
DECL_STATIC_DESTRUCTOR (new_decl) = 0;
new_node = (symtab_node) cgraph_create_function_alias (new_decl, node->symbol.decl);
}
else
new_node = (symtab_node) varpool_create_variable_alias (new_decl, node->symbol.decl);
symtab_resolve_alias (new_node, node);
return new_node;
}
static bool
callees_functions_use_frame_header (function *fn)
{
basic_block bb;
gimple_stmt_iterator gsi;
gimple *stmt;
tree called_fn_tree;
function *called_fn;
if (fn->cfg == NULL)
return true;
FOR_EACH_BB_FN (bb, fn)
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
stmt = gsi_stmt (gsi);
if (is_gimple_call (stmt))
{
called_fn_tree = gimple_call_fndecl (stmt);
if (called_fn_tree != NULL)
{
called_fn = DECL_STRUCT_FUNCTION (called_fn_tree);
if (called_fn == NULL
|| DECL_WEAK (called_fn_tree)
|| has_inlined_assembly (called_fn)
|| !is_leaf_function (called_fn)
|| !called_fn->machine->does_not_use_frame_header)
return true;
}
else
return true;
}
}
}
return false;
}
void
cgraph_finalize_function (tree decl, bool nested)
{
struct cgraph_node *node = cgraph_node (decl);
if (node->local.finalized)
cgraph_reset_node (node);
node->pid = cgraph_max_pid ++;
notice_global_symbol (decl);
node->local.finalized = true;
node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
record_cdtor_fn (node->decl);
if (node->nested)
lower_nested_functions (decl);
gcc_assert (!node->nested);
if (decide_is_function_needed (node, decl))
cgraph_mark_needed_node (node);
/* 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)))
cgraph_mark_reachable_node (node);
/* If we've not yet emitted decl, tell the debug info about it. */
if (!TREE_ASM_WRITTEN (decl))
(*debug_hooks->deferred_inline_function) (decl);
/* Possibly warn about unused parameters. */
if (warn_unused_parameter)
do_warn_unused_parameter (decl);
if (!nested)
ggc_collect ();
}
static void
build_cfg (tree fndecl)
{
function *fun = DECL_STRUCT_FUNCTION (fndecl);
ASSERT_TRUE (fun != NULL);
ASSERT_EQ (fndecl, fun->decl);
/* We first have to lower control flow; for our trivial test function
this gives us:
test_fn ()
{
D.56 = 42;
goto <D.57>;
<D.57>:
return D.56;
}
*/
gimple_opt_pass *lower_cf_pass = make_pass_lower_cf (g);
push_cfun (fun);
lower_cf_pass->execute (fun);
pop_cfun ();
/* We can now convert to CFG form; for our trivial test function this
gives us:
test_fn ()
{
<bb 2>:
D.56 = 42;
return D.56;
}
*/
gimple_opt_pass *build_cfg_pass = make_pass_build_cfg (g);
push_cfun (fun);
build_cfg_pass->execute (fun);
pop_cfun ();
}
/* Return true when FNDECL has Gimple body either in unlowered
or CFG form. */
bool
gimple_has_body_p (tree fndecl)
{
struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
return (gimple_body (fndecl) || (fn && fn->cfg));
}
gimple_seq
gimple_body (tree fndecl)
{
struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
return fn ? fn->gimple_body : NULL;
}
void
print_node (FILE *file, const char *prefix, tree node, int indent)
{
int hash;
struct bucket *b;
machine_mode mode;
enum tree_code_class tclass;
int len;
int i;
expanded_location xloc;
enum tree_code code;
if (node == 0)
return;
code = TREE_CODE (node);
tclass = TREE_CODE_CLASS (code);
/* Don't get too deep in nesting. If the user wants to see deeper,
it is easy to use the address of a lowest-level node
as an argument in another call to debug_tree. */
if (indent > 24)
{
print_node_brief (file, prefix, node, indent);
return;
}
if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration))
{
print_node_brief (file, prefix, node, indent);
return;
}
/* It is unsafe to look at any other fields of an ERROR_MARK node. */
if (code == ERROR_MARK)
{
print_node_brief (file, prefix, node, indent);
return;
}
/* Allow this function to be called if the table is not there. */
if (table)
{
hash = ((uintptr_t) node) % HASH_SIZE;
/* If node is in the table, just mention its address. */
for (b = table[hash]; b; b = b->next)
if (b->node == node)
{
print_node_brief (file, prefix, node, indent);
return;
}
/* Add this node to the table. */
b = XNEW (struct bucket);
b->node = node;
b->next = table[hash];
table[hash] = b;
}
/* Indent to the specified column, since this is the long form. */
indent_to (file, indent);
/* Print the slot this node is in, and its code, and address. */
fprintf (file, "%s <%s", prefix, get_tree_code_name (code));
dump_addr (file, " ", node);
/* Print the name, if any. */
if (tclass == tcc_declaration)
{
if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
else if (code == LABEL_DECL
&& LABEL_DECL_UID (node) != -1)
{
if (dump_flags & TDF_NOUID)
fprintf (file, " L.xxxx");
else
fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
}
else
{
if (dump_flags & TDF_NOUID)
fprintf (file, " %c.xxxx", code == CONST_DECL ? 'C' : 'D');
else
fprintf (file, " %c.%u", code == CONST_DECL ? 'C' : 'D',
DECL_UID (node));
}
}
else if (tclass == tcc_type)
{
if (TYPE_NAME (node))
{
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
fprintf (file, " %s",
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
}
}
if (code == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (node));
if (code == INTEGER_CST)
{
if (indent <= 4)
print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
}
else if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
{
print_node (file, "type", TREE_TYPE (node), indent + 4);
if (TREE_TYPE (node))
indent_to (file, indent + 3);
}
if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
fputs (" side-effects", file);
if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
fputs (" readonly", file);
if (TYPE_P (node) && TYPE_ATOMIC (node))
fputs (" atomic", file);
if (!TYPE_P (node) && TREE_CONSTANT (node))
fputs (" constant", file);
else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node))
fputs (" sizes-gimplified", file);
if (TYPE_P (node) && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
if (TREE_ADDRESSABLE (node))
fputs (" addressable", file);
if (TREE_THIS_VOLATILE (node))
fputs (" volatile", file);
if (TREE_ASM_WRITTEN (node))
fputs (" asm_written", file);
if (TREE_USED (node))
fputs (" used", file);
if (TREE_NOTHROW (node))
fputs (" nothrow", file);
if (TREE_PUBLIC (node))
fputs (" public", file);
if (TREE_PRIVATE (node))
fputs (" private", file);
if (TREE_PROTECTED (node))
fputs (" protected", file);
if (TREE_STATIC (node))
fputs (code == CALL_EXPR ? " must-tail-call" : " static", file);
if (TREE_DEPRECATED (node))
fputs (" deprecated", file);
if (TREE_VISITED (node))
fputs (" visited", file);
if (code != TREE_VEC && code != INTEGER_CST && code != SSA_NAME)
{
if (TREE_LANG_FLAG_0 (node))
fputs (" tree_0", file);
if (TREE_LANG_FLAG_1 (node))
fputs (" tree_1", file);
if (TREE_LANG_FLAG_2 (node))
fputs (" tree_2", file);
if (TREE_LANG_FLAG_3 (node))
fputs (" tree_3", file);
if (TREE_LANG_FLAG_4 (node))
fputs (" tree_4", file);
if (TREE_LANG_FLAG_5 (node))
fputs (" tree_5", file);
if (TREE_LANG_FLAG_6 (node))
fputs (" tree_6", file);
}
/* DECL_ nodes have additional attributes. */
switch (TREE_CODE_CLASS (code))
{
case tcc_declaration:
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
if (DECL_UNSIGNED (node))
fputs (" unsigned", file);
if (DECL_IGNORED_P (node))
fputs (" ignored", file);
if (DECL_ABSTRACT_P (node))
fputs (" abstract", file);
if (DECL_EXTERNAL (node))
fputs (" external", file);
if (DECL_NONLOCAL (node))
fputs (" nonlocal", file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
{
if (DECL_WEAK (node))
fputs (" weak", file);
if (DECL_IN_SYSTEM_HEADER (node))
fputs (" in_system_header", file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)
&& code != LABEL_DECL
&& code != FUNCTION_DECL
&& DECL_REGISTER (node))
fputs (" regdecl", file);
if (code == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
fputs (" suppress-debug", file);
if (code == FUNCTION_DECL
&& DECL_FUNCTION_SPECIFIC_TARGET (node))
fputs (" function-specific-target", file);
if (code == FUNCTION_DECL
&& DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node))
fputs (" function-specific-opt", file);
if (code == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node))
fputs (" autoinline", file);
if (code == FUNCTION_DECL && DECL_BUILT_IN (node))
fputs (" built-in", file);
if (code == FUNCTION_DECL && DECL_STATIC_CHAIN (node))
fputs (" static-chain", file);
if (TREE_CODE (node) == FUNCTION_DECL && decl_is_tm_clone (node))
fputs (" tm-clone", file);
if (code == FIELD_DECL && DECL_PACKED (node))
fputs (" packed", file);
if (code == FIELD_DECL && DECL_BIT_FIELD (node))
fputs (" bit-field", file);
if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
fputs (" nonaddressable", file);
if (code == LABEL_DECL && EH_LANDING_PAD_NR (node))
fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node));
if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node))
fputs (" in-text-section", file);
if (code == VAR_DECL && DECL_IN_CONSTANT_POOL (node))
fputs (" in-constant-pool", file);
if (code == VAR_DECL && DECL_COMMON (node))
fputs (" common", file);
if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node))
{
fputs (" ", file);
fputs (tls_model_names[DECL_TLS_MODEL (node)], file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
if (DECL_VIRTUAL_P (node))
fputs (" virtual", file);
if (DECL_PRESERVE_P (node))
fputs (" preserve", file);
if (DECL_LANG_FLAG_0 (node))
fputs (" decl_0", file);
if (DECL_LANG_FLAG_1 (node))
fputs (" decl_1", file);
if (DECL_LANG_FLAG_2 (node))
fputs (" decl_2", file);
if (DECL_LANG_FLAG_3 (node))
fputs (" decl_3", file);
if (DECL_LANG_FLAG_4 (node))
fputs (" decl_4", file);
if (DECL_LANG_FLAG_5 (node))
fputs (" decl_5", file);
if (DECL_LANG_FLAG_6 (node))
fputs (" decl_6", file);
if (DECL_LANG_FLAG_7 (node))
fputs (" decl_7", file);
mode = DECL_MODE (node);
fprintf (file, " %s", GET_MODE_NAME (mode));
}
if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
&& DECL_BY_REFERENCE (node))
fputs (" passed-by-reference", file);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS) && DECL_DEFER_OUTPUT (node))
fputs (" defer-output", file);
xloc = expand_location (DECL_SOURCE_LOCATION (node));
fprintf (file, " file %s line %d col %d", xloc.file, xloc.line,
xloc.column);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
print_node (file, "size", DECL_SIZE (node), indent + 4);
print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4);
if (code != FUNCTION_DECL || DECL_BUILT_IN (node))
indent_to (file, indent + 3);
if (DECL_USER_ALIGN (node))
fprintf (file, " user");
fprintf (file, " align %d", DECL_ALIGN (node));
if (code == FIELD_DECL)
fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
DECL_OFFSET_ALIGN (node));
if (code == FUNCTION_DECL && DECL_BUILT_IN (node))
{
if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node));
else
fprintf (file, " built-in %s:%s",
built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
built_in_names[(int) DECL_FUNCTION_CODE (node)]);
}
}
if (code == FIELD_DECL)
{
print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node),
indent + 4);
if (DECL_BIT_FIELD_TYPE (node))
print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),
indent + 4);
}
print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
print_node_brief (file, "attributes",
DECL_ATTRIBUTES (node), indent + 4);
if (code != PARM_DECL)
print_node_brief (file, "initial", DECL_INITIAL (node),
indent + 4);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
{
print_node_brief (file, "abstract_origin",
DECL_ABSTRACT_ORIGIN (node), indent + 4);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
{
print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
}
lang_hooks.print_decl (file, node, indent);
if (DECL_RTL_SET_P (node))
{
indent_to (file, indent + 4);
print_rtl (file, DECL_RTL (node));
}
if (code == PARM_DECL)
{
print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
if (DECL_INCOMING_RTL (node) != 0)
{
indent_to (file, indent + 4);
fprintf (file, "incoming-rtl ");
print_rtl (file, DECL_INCOMING_RTL (node));
}
}
else if (code == FUNCTION_DECL
&& DECL_STRUCT_FUNCTION (node) != 0)
{
print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
indent_to (file, indent + 4);
dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node));
}
if ((code == VAR_DECL || code == PARM_DECL)
&& DECL_HAS_VALUE_EXPR_P (node))
print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4);
/* Print the decl chain only if decl is at second level. */
if (indent == 4)
print_node (file, "chain", TREE_CHAIN (node), indent + 4);
else
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case tcc_type:
if (TYPE_UNSIGNED (node))
fputs (" unsigned", file);
if (TYPE_NO_FORCE_BLK (node))
fputs (" no-force-blk", file);
if (TYPE_STRING_FLAG (node))
fputs (" string-flag", file);
if (TYPE_NEEDS_CONSTRUCTING (node))
fputs (" needs-constructing", file);
if ((code == RECORD_TYPE
|| code == UNION_TYPE
|| code == QUAL_UNION_TYPE
|| code == ARRAY_TYPE)
&& TYPE_REVERSE_STORAGE_ORDER (node))
fputs (" reverse-storage-order", file);
/* The transparent-union flag is used for different things in
different nodes. */
if ((code == UNION_TYPE || code == RECORD_TYPE)
&& TYPE_TRANSPARENT_AGGR (node))
fputs (" transparent-aggr", file);
else if (code == ARRAY_TYPE
&& TYPE_NONALIASED_COMPONENT (node))
fputs (" nonaliased-component", file);
if (TYPE_PACKED (node))
fputs (" packed", file);
if (TYPE_RESTRICT (node))
fputs (" restrict", file);
if (TYPE_LANG_FLAG_0 (node))
fputs (" type_0", file);
if (TYPE_LANG_FLAG_1 (node))
fputs (" type_1", file);
if (TYPE_LANG_FLAG_2 (node))
fputs (" type_2", file);
if (TYPE_LANG_FLAG_3 (node))
fputs (" type_3", file);
if (TYPE_LANG_FLAG_4 (node))
fputs (" type_4", file);
if (TYPE_LANG_FLAG_5 (node))
fputs (" type_5", file);
if (TYPE_LANG_FLAG_6 (node))
fputs (" type_6", file);
if (TYPE_LANG_FLAG_7 (node))
fputs (" type_7", file);
mode = TYPE_MODE (node);
fprintf (file, " %s", GET_MODE_NAME (mode));
print_node (file, "size", TYPE_SIZE (node), indent + 4);
print_node (file, "unit size", TYPE_SIZE_UNIT (node), indent + 4);
indent_to (file, indent + 3);
if (TYPE_USER_ALIGN (node))
fprintf (file, " user");
fprintf (file, " align %d symtab %d alias set " HOST_WIDE_INT_PRINT_DEC,
TYPE_ALIGN (node), TYPE_SYMTAB_ADDRESS (node),
(HOST_WIDE_INT) TYPE_ALIAS_SET (node));
if (TYPE_STRUCTURAL_EQUALITY_P (node))
fprintf (file, " structural equality");
else
dump_addr (file, " canonical type ", TYPE_CANONICAL (node));
print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE
|| code == FIXED_POINT_TYPE)
{
fprintf (file, " precision %d", TYPE_PRECISION (node));
print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4);
}
if (code == ENUMERAL_TYPE)
print_node (file, "values", TYPE_VALUES (node), indent + 4);
else if (code == ARRAY_TYPE)
print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
else if (code == VECTOR_TYPE)
fprintf (file, " nunits %d", (int) TYPE_VECTOR_SUBPARTS (node));
else if (code == RECORD_TYPE
|| code == UNION_TYPE
|| code == QUAL_UNION_TYPE)
print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
else if (code == FUNCTION_TYPE
|| code == METHOD_TYPE)
{
if (TYPE_METHOD_BASETYPE (node))
print_node_brief (file, "method basetype",
TYPE_METHOD_BASETYPE (node), indent + 4);
print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
}
else if (code == OFFSET_TYPE)
print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node),
indent + 4);
if (TYPE_CONTEXT (node))
print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
lang_hooks.print_type (file, node, indent);
if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
indent_to (file, indent + 3);
print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node),
indent + 4);
print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node),
indent + 4);
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case tcc_expression:
case tcc_comparison:
case tcc_unary:
case tcc_binary:
case tcc_reference:
case tcc_statement:
case tcc_vl_exp:
if (code == BIND_EXPR)
{
print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
break;
}
if (code == CALL_EXPR)
{
call_expr_arg_iterator iter;
tree arg;
print_node (file, "fn", CALL_EXPR_FN (node), indent + 4);
print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node),
indent + 4);
i = 0;
FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
{
char temp[10];
sprintf (temp, "arg %d", i);
print_node (file, temp, arg, indent + 4);
i++;
}
}
static funct_state
analyze_function (struct cgraph_node *fn, bool ipa)
{
tree decl = fn->symbol.decl;
funct_state l;
basic_block this_block;
l = XCNEW (struct funct_state_d);
l->pure_const_state = IPA_CONST;
l->state_previously_known = IPA_NEITHER;
l->looping_previously_known = true;
l->looping = false;
l->can_throw = false;
state_from_flags (&l->state_previously_known, &l->looping_previously_known,
flags_from_decl_or_type (fn->symbol.decl),
cgraph_node_cannot_return (fn));
if (fn->thunk.thunk_p || fn->symbol.alias)
{
/* Thunk gets propagated through, so nothing interesting happens. */
gcc_assert (ipa);
return l;
}
if (dump_file)
{
fprintf (dump_file, "\n\n local analysis of %s\n ",
cgraph_node_name (fn));
}
push_cfun (DECL_STRUCT_FUNCTION (decl));
FOR_EACH_BB (this_block)
{
gimple_stmt_iterator gsi;
struct walk_stmt_info wi;
memset (&wi, 0, sizeof(wi));
for (gsi = gsi_start_bb (this_block);
!gsi_end_p (gsi);
gsi_next (&gsi))
{
check_stmt (&gsi, l, ipa);
if (l->pure_const_state == IPA_NEITHER && l->looping && l->can_throw)
goto end;
}
}
end:
if (l->pure_const_state != IPA_NEITHER)
{
/* Const functions cannot have back edges (an
indication of possible infinite loop side
effect. */
if (mark_dfs_back_edges ())
{
/* Preheaders are needed for SCEV to work.
Simple latches and recorded exits improve chances that loop will
proved to be finite in testcases such as in loop-15.c
and loop-24.c */
loop_optimizer_init (LOOPS_HAVE_PREHEADERS
| LOOPS_HAVE_SIMPLE_LATCHES
| LOOPS_HAVE_RECORDED_EXITS);
if (dump_file && (dump_flags & TDF_DETAILS))
flow_loops_dump (dump_file, NULL, 0);
if (mark_irreducible_loops ())
{
if (dump_file)
fprintf (dump_file, " has irreducible loops\n");
l->looping = true;
}
else
{
loop_iterator li;
struct loop *loop;
scev_initialize ();
FOR_EACH_LOOP (li, loop, 0)
if (!finite_loop_p (loop))
{
if (dump_file)
fprintf (dump_file, " can not prove finiteness of "
"loop %i\n", loop->num);
l->looping =true;
FOR_EACH_LOOP_BREAK (li);
}
scev_finalize ();
}
loop_optimizer_finalize ();
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " checking previously known:");
better_state (&l->pure_const_state, &l->looping,
l->state_previously_known,
l->looping_previously_known);
if (TREE_NOTHROW (decl))
l->can_throw = false;
pop_cfun ();
if (dump_file)
{
if (l->looping)
fprintf (dump_file, "Function is locally looping.\n");
if (l->can_throw)
fprintf (dump_file, "Function is locally throwing.\n");
if (l->pure_const_state == IPA_CONST)
fprintf (dump_file, "Function is locally const.\n");
if (l->pure_const_state == IPA_PURE)
fprintf (dump_file, "Function is locally pure.\n");
}
return l;
}
static unsigned int
tree_profiling (void)
{
struct cgraph_node *node;
/* This is a small-ipa pass that gets called only once, from
cgraphunit.c:ipa_passes(). */
gcc_assert (symtab->state == IPA_SSA);
init_node_map (true);
FOR_EACH_DEFINED_FUNCTION (node)
{
if (!gimple_has_body_p (node->decl))
continue;
/* Don't profile functions produced for builtin stuff. */
if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
continue;
/* Do not instrument extern inline functions when testing coverage.
While this is not perfectly consistent (early inlined extern inlines
will get acocunted), testsuite expects that. */
if (DECL_EXTERNAL (node->decl)
&& flag_test_coverage)
continue;
push_cfun (DECL_STRUCT_FUNCTION (node->decl));
/* Local pure-const may imply need to fixup the cfg. */
if (execute_fixup_cfg () & TODO_cleanup_cfg)
cleanup_tree_cfg ();
branch_prob ();
if (! flag_branch_probabilities
&& flag_profile_values)
gimple_gen_ic_func_profiler ();
if (flag_branch_probabilities
&& flag_profile_values
&& flag_value_profile_transformations)
gimple_value_profile_transformations ();
/* The above could hose dominator info. Currently there is
none coming in, this is a safety valve. It should be
easy to adjust it, if and when there is some. */
free_dominance_info (CDI_DOMINATORS);
free_dominance_info (CDI_POST_DOMINATORS);
pop_cfun ();
}
/* Drop pure/const flags from instrumented functions. */
FOR_EACH_DEFINED_FUNCTION (node)
{
if (!gimple_has_body_p (node->decl)
|| !(!node->clone_of
|| node->decl != node->clone_of->decl))
continue;
/* Don't profile functions produced for builtin stuff. */
if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
continue;
node->set_const_flag (false, false);
node->set_pure_flag (false, false);
}
/* Update call statements and rebuild the cgraph. */
FOR_EACH_DEFINED_FUNCTION (node)
{
basic_block bb;
if (!gimple_has_body_p (node->decl)
|| !(!node->clone_of
|| node->decl != node->clone_of->decl))
continue;
/* Don't profile functions produced for builtin stuff. */
if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
continue;
push_cfun (DECL_STRUCT_FUNCTION (node->decl));
FOR_EACH_BB_FN (bb, cfun)
{
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
if (is_gimple_call (stmt))
update_stmt (stmt);
}
}
/* re-merge split blocks. */
cleanup_tree_cfg ();
update_ssa (TODO_update_ssa);
cgraph_edge::rebuild_edges ();
pop_cfun ();
}
void
tree_rest_of_compilation (tree fndecl)
{
location_t saved_loc;
timevar_push (TV_EXPAND);
gcc_assert (cgraph_global_info_ready);
/* Initialize the default bitmap obstack. */
bitmap_obstack_initialize (NULL);
/* Initialize the RTL code for the function. */
current_function_decl = fndecl;
saved_loc = input_location;
input_location = DECL_SOURCE_LOCATION (fndecl);
init_function_start (fndecl);
/* Even though we're inside a function body, we still don't want to
call expand_expr to calculate the size of a variable-sized array.
We haven't necessarily assigned RTL to all variables yet, so it's
not safe to try to expand expressions involving them. */
cfun->dont_save_pending_sizes_p = 1;
gimple_register_cfg_hooks ();
bitmap_obstack_initialize (®_obstack); /* FIXME, only at RTL generation*/
execute_all_ipa_transforms ();
/* Perform all tree transforms and optimizations. */
/* Signal the start of passes. */
invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START, NULL);
execute_pass_list (all_passes);
/* Signal the end of passes. */
invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END, NULL);
bitmap_obstack_release (®_obstack);
/* Release the default bitmap obstack. */
bitmap_obstack_release (NULL);
set_cfun (NULL);
/* If requested, warn about function definitions where the function will
return a value (usually of some struct or union type) which itself will
take up a lot of stack space. */
if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
{
tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
if (ret_type && TYPE_SIZE_UNIT (ret_type)
&& TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
&& 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
larger_than_size))
{
unsigned int size_as_int
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
warning (OPT_Wlarger_than_eq, "size of return value of %q+D is %u bytes",
fndecl, size_as_int);
else
warning (OPT_Wlarger_than_eq, "size of return value of %q+D is larger than %wd bytes",
fndecl, larger_than_size);
}
}
gimple_set_body (fndecl, NULL);
if (DECL_STRUCT_FUNCTION (fndecl) == 0
&& !cgraph_node (fndecl)->origin)
{
/* Stop pointing to the local nodes about to be freed.
But DECL_INITIAL must remain nonzero so we know this
was an actual function definition.
For a nested function, this is done in c_pop_function_context.
If rest_of_compilation set this to 0, leave it 0. */
if (DECL_INITIAL (fndecl) != 0)
DECL_INITIAL (fndecl) = error_mark_node;
}
input_location = saved_loc;
ggc_collect ();
timevar_pop (TV_EXPAND);
}
