#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "rtl.h"
#include "tm_p.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "output.h"
#include "expr.h"
#include "diagnostic.h"
#include "basic-block.h"
#include "flags.h"
#include "tree-flow.h"
#include "tree-dump.h"
#include "timevar.h"
#include "function.h"
#include "langhooks.h"
#include "toplev.h"
#include "flags.h"
#include "cgraph.h"
#include "tree-inline.h"
#include "tree-mudflap.h"
#include "tree-pass.h"
#include "ggc.h"
#include "cgraph.h"
#include "graph.h"
#include "cfgloop.h"
#include "except.h"
static bool
gate_all_optimizations (void)
{
return (optimize >= 1
&& !(errorcount || sorrycount));
}
struct tree_opt_pass pass_all_optimizations =
{
NULL,
gate_all_optimizations,
NULL,
NULL,
NULL,
0,
0,
0,
0,
0,
0,
0,
0
};
struct tree_opt_pass pass_early_local_passes =
{
NULL,
gate_all_optimizations,
NULL,
NULL,
NULL,
0,
0,
0,
0,
0,
0,
0,
0
};
static unsigned int
execute_cleanup_cfg_pre_ipa (void)
{
cleanup_tree_cfg ();
return 0;
}
struct tree_opt_pass pass_cleanup_cfg =
{
"cleanup_cfg",
NULL,
execute_cleanup_cfg_pre_ipa,
NULL,
NULL,
0,
0,
PROP_cfg,
0,
0,
0,
TODO_dump_func,
0
};
static unsigned int
execute_cleanup_cfg_post_optimizing (void)
{
fold_cond_expr_cond ();
cleanup_tree_cfg ();
cleanup_dead_labels ();
group_case_labels ();
return 0;
}
struct tree_opt_pass pass_cleanup_cfg_post_optimizing =
{
"final_cleanup",
NULL,
execute_cleanup_cfg_post_optimizing,
NULL,
NULL,
0,
0,
PROP_cfg,
0,
0,
0,
TODO_dump_func,
0
};
static unsigned int
execute_free_datastructures (void)
{
free_dominance_info (CDI_DOMINATORS);
free_dominance_info (CDI_POST_DOMINATORS);
delete_tree_ssa ();
return 0;
}
struct tree_opt_pass pass_free_datastructures =
{
NULL,
NULL,
execute_free_datastructures,
NULL,
NULL,
0,
0,
PROP_cfg,
0,
0,
0,
0,
0
};
static unsigned int
execute_free_cfg_annotations (void)
{
basic_block bb;
block_stmt_iterator bsi;
disband_implicit_edges ();
FOR_EACH_BB (bb)
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
ggc_free (stmt->common.ann);
stmt->common.ann = NULL;
}
delete_tree_cfg_annotations ();
#ifdef ENABLE_CHECKING
verify_eh_throw_table_statements ();
#endif
return 0;
}
struct tree_opt_pass pass_free_cfg_annotations =
{
NULL,
NULL,
execute_free_cfg_annotations,
NULL,
NULL,
0,
0,
PROP_cfg,
0,
0,
0,
0,
0
};
static inline bool
has_abnormal_outgoing_edge_p (basic_block bb)
{
edge e;
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->succs)
if (e->flags & EDGE_ABNORMAL)
return true;
return false;
}
static unsigned int
execute_fixup_cfg (void)
{
basic_block bb;
block_stmt_iterator bsi;
if (cfun->eh)
FOR_EACH_BB (bb)
{
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
tree call = get_call_expr_in (stmt);
if (call && call_expr_flags (call) & (ECF_CONST | ECF_PURE))
TREE_SIDE_EFFECTS (call) = 0;
if (!tree_could_throw_p (stmt) && lookup_stmt_eh_region (stmt))
remove_stmt_from_eh_region (stmt);
}
tree_purge_dead_eh_edges (bb);
}
if (current_function_has_nonlocal_label)
FOR_EACH_BB (bb)
{
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
if (tree_can_make_abnormal_goto (stmt))
{
if (stmt == bsi_stmt (bsi_last (bb)))
{
if (!has_abnormal_outgoing_edge_p (bb))
make_abnormal_goto_edges (bb, true);
}
else
{
edge e = split_block (bb, stmt);
bb = e->src;
make_abnormal_goto_edges (bb, true);
}
break;
}
}
}
cleanup_tree_cfg ();
if (dump_file)
dump_tree_cfg (dump_file, dump_flags);
return 0;
}
struct tree_opt_pass pass_fixup_cfg =
{
"fixupcfg",
NULL,
execute_fixup_cfg,
NULL,
NULL,
0,
0,
PROP_cfg,
0,
0,
0,
0,
0
};
static unsigned int
execute_init_datastructures (void)
{
init_tree_ssa ();
return 0;
}
struct tree_opt_pass pass_init_datastructures =
{
NULL,
NULL,
execute_init_datastructures,
NULL,
NULL,
0,
0,
PROP_cfg,
0,
0,
0,
0,
0
};
void
tree_lowering_passes (tree fn)
{
tree saved_current_function_decl = current_function_decl;
current_function_decl = fn;
push_cfun (DECL_STRUCT_FUNCTION (fn));
tree_register_cfg_hooks ();
bitmap_obstack_initialize (NULL);
execute_pass_list (all_lowering_passes);
free_dominance_info (CDI_POST_DOMINATORS);
compact_blocks ();
current_function_decl = saved_current_function_decl;
bitmap_obstack_release (NULL);
pop_cfun ();
}
static void
update_inlined_to_pointers (struct cgraph_node *node,
struct cgraph_node *inlined_to)
{
struct cgraph_edge *e;
for (e = node->callees; e; e = e->next_callee)
{
if (e->callee->global.inlined_to)
{
e->callee->global.inlined_to = inlined_to;
update_inlined_to_pointers (e->callee, inlined_to);
}
}
}
void
tree_rest_of_compilation (tree fndecl)
{
location_t saved_loc;
struct cgraph_node *node;
timevar_push (TV_EXPAND);
gcc_assert (!flag_unit_at_a_time || cgraph_global_info_ready);
node = cgraph_node (fndecl);
if (cgraph_preserve_function_body_p (fndecl))
save_inline_function_body (node);
current_function_decl = fndecl;
saved_loc = input_location;
input_location = DECL_SOURCE_LOCATION (fndecl);
init_function_start (fndecl);
cfun->x_dont_save_pending_sizes_p = 1;
cfun->after_inlining = true;
if (flag_inline_trees)
{
struct cgraph_edge *e;
for (e = node->callees; e; e = e->next_callee)
if (!e->inline_failed || warn_inline)
break;
if (e)
{
timevar_push (TV_INTEGRATION);
optimize_inline_calls (fndecl);
timevar_pop (TV_INTEGRATION);
}
}
if (!flag_unit_at_a_time)
{
struct cgraph_edge *e;
for (e = node->callees; e; e = e->next_callee)
if (e->callee->analyzed)
cgraph_mark_needed_node (e->callee);
}
cgraph_node_remove_callees (node);
bitmap_obstack_initialize (NULL);
bitmap_obstack_initialize (®_obstack);
tree_register_cfg_hooks ();
execute_pass_list (all_passes);
bitmap_obstack_release (®_obstack);
bitmap_obstack_release (NULL);
DECL_SAVED_TREE (fndecl) = NULL;
cfun = 0;
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 (0, "size of return value of %q+D is %u bytes",
fndecl, size_as_int);
else
warning (0, "size of return value of %q+D is larger than %wd bytes",
fndecl, larger_than_size);
}
}
if (!flag_inline_trees)
{
DECL_SAVED_TREE (fndecl) = NULL;
if (DECL_STRUCT_FUNCTION (fndecl) == 0
&& !cgraph_node (fndecl)->origin)
{
if (DECL_INITIAL (fndecl) != 0)
DECL_INITIAL (fndecl) = error_mark_node;
}
}
input_location = saved_loc;
ggc_collect ();
timevar_pop (TV_EXPAND);
}