type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | void
clear_special_calls (void)
{
cfun->calls_alloca = false;
cfun->calls_setjmp = false;
} |
functions | void
remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb)
{
/* Since this block is no longer reachable, we can just delete all
of its PHI nodes. */
remove_phi_nodes (bb);
/* Remove edges to BB's successors. */
while (EDGE_COUNT (bb->succs) > 0)
remove_edge (EDGE_SUCC (bb, 0));
} |
functions | void
remove_bb (basic_block bb)
{
gimple_stmt_iterator i;
if (dump_file)
{
fprintf (dump_file, "Removing basic block %d\n", bb->index);
if (dump_flags & TDF_DETAILS)
{
dump_bb (dump_file, bb, 0, TDF_BLOCKS);
fprintf (dump_file, "\n");
} |
functions | edge
find_taken_edge (basic_block bb, tree val)
{
gimple stmt;
stmt = last_stmt (bb);
gcc_assert (stmt);
gcc_assert (is_ctrl_stmt (stmt));
if (val == NULL)
return NULL;
if (!is_gimple_min_invariant (val))
return NULL;
if (gimple_code (stmt) == GIMPLE_COND)
return find_taken_edge_cond_expr... |
functions | edge
find_taken_edge_computed_goto (basic_block bb, tree val)
{
basic_block dest;
edge e = NULL;
dest = label_to_block (val);
if (dest)
{
e = find_edge (bb, dest);
gcc_assert (e != NULL);
} |
functions | edge
find_taken_edge_cond_expr (basic_block bb, tree val)
{
edge true_edge, false_edge;
extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
gcc_assert (TREE_CODE (val) == INTEGER_CST);
return (integer_zerop (val) ? false_edge : true_edge);
} |
functions | edge
find_taken_edge_switch_expr (gswitch *switch_stmt, basic_block bb,
tree val)
{
basic_block dest_bb;
edge e;
tree taken_case;
taken_case = find_case_label_for_value (switch_stmt, val);
dest_bb = label_to_block (CASE_LABEL (taken_case));
e = find_edge (bb, dest_bb);
gcc_assert (e);
return e... |
functions | tree
find_case_label_for_value (gswitch *switch_stmt, tree val)
{
size_t low, high, n = gimple_switch_num_labels (switch_stmt);
tree default_case = gimple_switch_default_label (switch_stmt);
for (low = 0, high = n; high - low > 1; )
{
size_t i = (high + low) / 2;
tree t = gimple_switch_label (swi... |
functions | void
gimple_debug_bb (basic_block bb)
{
dump_bb (stderr, bb, 0, TDF_VOPS|TDF_MEMSYMS|TDF_BLOCKS);
} |
functions | basic_block
gimple_debug_bb_n (int n)
{
gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun, n));
return BASIC_BLOCK_FOR_FN (cfun, n);
} |
functions | void
gimple_debug_cfg (int flags)
{
gimple_dump_cfg (stderr, flags);
} |
functions | void
gimple_dump_cfg (FILE *file, int flags)
{
if (flags & TDF_DETAILS)
{
dump_function_header (file, current_function_decl, flags);
fprintf (file, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
n_basic_blocks_for_fn (cfun), n_edges_for_fn (cfun),
last_basic_block_for_fn (... |
functions | void
dump_cfg_stats (FILE *file)
{
static long max_num_merged_labels = 0;
unsigned long size, total = 0;
long num_edges;
basic_block bb;
const char * const fmt_str = "%-30s%-13s%12s\n";
const char * const fmt_str_1 = "%-30s%13d%11lu%c\n";
const char * const fmt_str_2 = "%-30s%13ld%11lu%c\n";
const cha... |
functions | void
debug_cfg_stats (void)
{
dump_cfg_stats (stderr);
} |
functions | bool
call_can_make_abnormal_goto (gimple t)
{
/* If the function has no non-local labels, then a call cannot make an
abnormal transfer of control. */
if (!cfun->has_nonlocal_label
&& !cfun->calls_setjmp)
return false;
/* Likewise if the call has no side effects. */
if (!gimple_has_side_effects ... |
functions | bool
stmt_can_make_abnormal_goto (gimple t)
{
if (computed_goto_p (t))
return true;
if (is_gimple_call (t))
return call_can_make_abnormal_goto (t);
return false;
} |
functions | bool
is_ctrl_stmt (gimple t)
{
switch (gimple_code (t))
{
case GIMPLE_COND:
case GIMPLE_SWITCH:
case GIMPLE_GOTO:
case GIMPLE_RETURN:
case GIMPLE_RESX:
return true;
default:
return false;
} |
functions | bool
is_ctrl_altering_stmt (gimple t)
{
gcc_assert (t);
switch (gimple_code (t))
{
case GIMPLE_CALL:
/* Per stmt call flag indicates whether the call could alter
controlflow. */
if (gimple_call_ctrl_altering_p (t))
return true;
break;
case GIMPLE_EH_DISPATCH:
/* EH_DISPATCH... |
functions | bool
simple_goto_p (gimple t)
{
return (gimple_code (t) == GIMPLE_GOTO
&& TREE_CODE (gimple_goto_dest (t)) == LABEL_DECL);
} |
functions | bool
stmt_starts_bb_p (gimple stmt, gimple prev_stmt)
{
if (stmt == NULL)
return false;
/* Labels start a new basic block only if the preceding statement
wasn't a label of the same type. This prevents the creation of
consecutive blocks that have nothing but a single label. */
if (glabel *label_st... |
functions | bool
stmt_ends_bb_p (gimple t)
{
return is_ctrl_stmt (t) || is_ctrl_altering_stmt (t);
} |
functions | void
delete_tree_cfg_annotations (void)
{
vec_free (label_to_block_map_for_fn (cfun));
} |
functions | gimple
first_stmt (basic_block bb)
{
gimple_stmt_iterator i = gsi_start_bb (bb);
gimple stmt = NULL;
while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
{
gsi_next (&i);
stmt = NULL;
} |
functions | gimple
first_non_label_stmt (basic_block bb)
{
gimple_stmt_iterator i = gsi_start_bb (bb);
while (!gsi_end_p (i) && gimple_code (gsi_stmt (i)) == GIMPLE_LABEL)
gsi_next (&i);
return !gsi_end_p (i) ? gsi_stmt (i) : NULL;
} |
functions | gimple
last_stmt (basic_block bb)
{
gimple_stmt_iterator i = gsi_last_bb (bb);
gimple stmt = NULL;
while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
{
gsi_prev (&i);
stmt = NULL;
} |
functions | gimple
last_and_only_stmt (basic_block bb)
{
gimple_stmt_iterator i = gsi_last_nondebug_bb (bb);
gimple last, prev;
if (gsi_end_p (i))
return NULL;
last = gsi_stmt (i);
gsi_prev_nondebug (&i);
if (gsi_end_p (i))
return last;
/* Empty statements should no longer appear in the instruction stream.... |
functions | void
reinstall_phi_args (edge new_edge, edge old_edge)
{
edge_var_map *vm;
int i;
gphi_iterator phis;
vec<edge_var_map> *v = redirect_edge_var_map_vector (old_edge);
if (!v)
return;
for (i = 0, phis = gsi_start_phis (new_edge->dest);
v->iterate (i, &vm) && !gsi_end_p (phis);
i++, gsi_nex... |
functions | basic_block
split_edge_bb_loc (edge edge_in)
{
basic_block dest = edge_in->dest;
basic_block dest_prev = dest->prev_bb;
if (dest_prev)
{
edge e = find_edge (dest_prev, dest);
if (e && !(e->flags & EDGE_COMPLEX))
return edge_in->src;
} |
functions | basic_block
gimple_split_edge (edge edge_in)
{
basic_block new_bb, after_bb, dest;
edge new_edge, e;
/* Abnormal edges cannot be split. */
gcc_assert (!(edge_in->flags & EDGE_ABNORMAL));
dest = edge_in->dest;
after_bb = split_edge_bb_loc (edge_in);
new_bb = create_empty_bb (after_bb);
new_bb->frequ... |
functions | tree
verify_address (tree t, tree base)
{
bool old_constant;
bool old_side_effects;
bool new_constant;
bool new_side_effects;
old_constant = TREE_CONSTANT (t);
old_side_effects = TREE_SIDE_EFFECTS (t);
recompute_tree_invariant_for_addr_expr (t);
new_side_effects = TREE_SIDE_EFFECTS (t);
new_constant... |
functions | tree
verify_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
{
tree t = *tp, x;
if (TYPE_P (t))
*walk_subtrees = 0;
/* Check operand N for being valid GIMPLE and give error MSG if not. */
do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
{ error (MSG); return TREE_OPERAND (t, N); ... |
functions | bool
verify_types_in_gimple_min_lval (tree expr)
{
tree op;
if (is_gimple_id (expr))
return false;
if (TREE_CODE (expr) != TARGET_MEM_REF
&& TREE_CODE (expr) != MEM_REF)
{
error ("invalid expression for min lvalue");
return true;
} |
functions | bool
verify_types_in_gimple_reference (tree expr, bool require_lvalue)
{
while (handled_component_p (expr))
{
tree op = TREE_OPERAND (expr, 0);
if (TREE_CODE (expr) == ARRAY_REF
|| TREE_CODE (expr) == ARRAY_RANGE_REF)
{
if (!is_gimple_val (TREE_OPERAND (expr, 1))
|| (TREE_OPERAND (expr,... |
functions | bool
one_pointer_to_useless_type_conversion_p (tree dest, tree src_obj)
{
tree src;
if (!TYPE_POINTER_TO (src_obj))
return true;
for (src = TYPE_POINTER_TO (src_obj); src; src = TYPE_NEXT_PTR_TO (src))
if (useless_type_conversion_p (dest, src))
return true;
return false;
} |
functions | bool
valid_fixed_convert_types_p (tree type1, tree type2)
{
return (FIXED_POINT_TYPE_P (type1)
&& (INTEGRAL_TYPE_P (type2)
|| SCALAR_FLOAT_TYPE_P (type2)
|| FIXED_POINT_TYPE_P (type2)));
} |
functions | bool
verify_gimple_call (gcall *stmt)
{
tree fn = gimple_call_fn (stmt);
tree fntype, fndecl;
unsigned i;
if (gimple_call_internal_p (stmt))
{
if (fn)
{
error ("gimple call has two targets");
debug_generic_stmt (fn);
return true;
} |
functions | bool
verify_gimple_comparison (tree type, tree op0, tree op1)
{
tree op0_type = TREE_TYPE (op0);
tree op1_type = TREE_TYPE (op1);
if (!is_gimple_val (op0) || !is_gimple_val (op1))
{
error ("invalid operands in gimple comparison");
return true;
} |
functions | bool
verify_gimple_assign_unary (gassign *stmt)
{
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
tree lhs = gimple_assign_lhs (stmt);
tree lhs_type = TREE_TYPE (lhs);
tree rhs1 = gimple_assign_rhs1 (stmt);
tree rhs1_type = TREE_TYPE (rhs1);
if (!is_gimple_reg (lhs))
{
error ("non-regist... |
functions | bool
verify_gimple_assign_binary (gassign *stmt)
{
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
tree lhs = gimple_assign_lhs (stmt);
tree lhs_type = TREE_TYPE (lhs);
tree rhs1 = gimple_assign_rhs1 (stmt);
tree rhs1_type = TREE_TYPE (rhs1);
tree rhs2 = gimple_assign_rhs2 (stmt);
tree rhs2_type ... |
functions | bool
verify_gimple_assign_ternary (gassign *stmt)
{
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
tree lhs = gimple_assign_lhs (stmt);
tree lhs_type = TREE_TYPE (lhs);
tree rhs1 = gimple_assign_rhs1 (stmt);
tree rhs1_type = TREE_TYPE (rhs1);
tree rhs2 = gimple_assign_rhs2 (stmt);
tree rhs2_type... |
functions | bool
verify_gimple_assign_single (gassign *stmt)
{
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
tree lhs = gimple_assign_lhs (stmt);
tree lhs_type = TREE_TYPE (lhs);
tree rhs1 = gimple_assign_rhs1 (stmt);
tree rhs1_type = TREE_TYPE (rhs1);
bool res = false;
if (!useless_type_conversion_p (lhs... |
functions | bool
verify_gimple_assign (gassign *stmt)
{
switch (gimple_assign_rhs_class (stmt))
{
case GIMPLE_SINGLE_RHS:
return verify_gimple_assign_single (stmt);
case GIMPLE_UNARY_RHS:
return verify_gimple_assign_unary (stmt);
case GIMPLE_BINARY_RHS:
return verify_gimple_assign_binary (stmt... |
functions | bool
verify_gimple_return (greturn *stmt)
{
tree op = gimple_return_retval (stmt);
tree restype = TREE_TYPE (TREE_TYPE (cfun->decl));
/* We cannot test for present return values as we do not fix up missing
return values from the original source. */
if (op == NULL)
return false;
if (!is_gimple_val ... |
functions | bool
verify_gimple_goto (ggoto *stmt)
{
tree dest = gimple_goto_dest (stmt);
/* ??? We have two canonical forms of direct goto destinations, a
bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
if (TREE_CODE (dest) != LABEL_DECL
&& (!is_gimple_val (dest)
|| !POINTER_TYPE_P (TREE_TYPE (dest))))
... |
functions | bool
verify_gimple_switch (gswitch *stmt)
{
unsigned int i, n;
tree elt, prev_upper_bound = NULL_TREE;
tree index_type, elt_type = NULL_TREE;
if (!is_gimple_val (gimple_switch_index (stmt)))
{
error ("invalid operand to switch statement");
debug_generic_stmt (gimple_switch_index (stmt));
... |
functions | bool
verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED)
{
/* There isn't much that could be wrong in a gimple debug stmt. A
gimple debug bind stmt, for example, maps a tree, that's usually
a VAR_DECL or a PARM_DECL, but that could also be some scalarized
component or member of an aggregate type, to an... |
functions | bool
verify_gimple_label (glabel *stmt)
{
tree decl = gimple_label_label (stmt);
int uid;
bool err = false;
if (TREE_CODE (decl) != LABEL_DECL)
return true;
if (!DECL_NONLOCAL (decl) && !FORCED_LABEL (decl)
&& DECL_CONTEXT (decl) != current_function_decl)
{
error ("label's context is not ... |
functions | bool
verify_gimple_cond (gcond *stmt)
{
if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison)
{
error ("invalid comparison code in gimple cond");
return true;
} |
functions | bool
verify_gimple_stmt (gimple stmt)
{
switch (gimple_code (stmt))
{
case GIMPLE_ASSIGN:
return verify_gimple_assign (as_a <gassign *> (stmt));
case GIMPLE_LABEL:
return verify_gimple_label (as_a <glabel *> (stmt));
case GIMPLE_CALL:
return verify_gimple_call (as_a <gcall *> (stmt... |
functions | bool
verify_gimple_phi (gimple phi)
{
bool err = false;
unsigned i;
tree phi_result = gimple_phi_result (phi);
bool virtual_p;
if (!phi_result)
{
error ("invalid PHI result");
return true;
} |
functions | bool
verify_gimple_in_seq_2 (gimple_seq stmts)
{
gimple_stmt_iterator ittr;
bool err = false;
for (ittr = gsi_start (stmts); !gsi_end_p (ittr); gsi_next (&ittr))
{
gimple stmt = gsi_stmt (ittr);
switch (gimple_code (stmt))
{
case GIMPLE_BIND:
err |= verify_gimple_in_seq_2 (
... |
functions | bool
verify_gimple_transaction (gtransaction *stmt)
{
tree lab = gimple_transaction_label (stmt);
if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
return true;
return verify_gimple_in_seq_2 (gimple_transaction_body (stmt));
} |
functions | void
verify_gimple_in_seq (gimple_seq stmts)
{
timevar_push (TV_TREE_STMT_VERIFY);
if (verify_gimple_in_seq_2 (stmts))
internal_error ("verify_gimple failed");
timevar_pop (TV_TREE_STMT_VERIFY);
} |
functions | bool
tree_node_can_be_shared (tree t)
{
if (IS_TYPE_OR_DECL_P (t)
|| is_gimple_min_invariant (t)
|| TREE_CODE (t) == SSA_NAME
|| t == error_mark_node
|| TREE_CODE (t) == IDENTIFIER_NODE)
return true;
if (TREE_CODE (t) == CASE_LABEL_EXPR)
return true;
if (DECL_P (t))
return tr... |
functions | tree
verify_node_sharing_1 (tree *tp, int *walk_subtrees, void *data)
{
hash_set<void *> *visited = (hash_set<void *> *) data;
if (tree_node_can_be_shared (*tp))
{
*walk_subtrees = false;
return NULL;
} |
functions | tree
verify_node_sharing (tree *tp, int *walk_subtrees, void *data)
{
struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
return verify_node_sharing_1 (tp, walk_subtrees, wi->info);
} |
functions | bool
verify_eh_throw_stmt_node (const gimple &stmt, const int &,
hash_set<gimple> *visited)
{
if (!visited->contains (stmt))
{
error ("dead STMT in EH table");
debug_gimple_stmt (stmt);
eh_error_found = true;
} |
functions | bool
verify_location (hash_set<tree> *blocks, location_t loc)
{
tree block = LOCATION_BLOCK (loc);
if (block != NULL_TREE
&& !blocks->contains (block))
{
error ("location references block not in block tree");
return true;
} |
functions | tree
verify_expr_no_block (tree *tp, int *walk_subtrees, void *)
{
if (!EXPR_P (*tp))
{
*walk_subtrees = false;
return NULL;
} |
functions | tree
verify_expr_location_1 (tree *tp, int *walk_subtrees, void *data)
{
hash_set<tree> *blocks = (hash_set<tree> *) data;
if (TREE_CODE (*tp) == VAR_DECL
&& DECL_HAS_DEBUG_EXPR_P (*tp))
{
tree t = DECL_DEBUG_EXPR (*tp);
tree addr = walk_tree (&t, verify_expr_no_block, NULL, NULL);
if (... |
functions | tree
verify_expr_location (tree *tp, int *walk_subtrees, void *data)
{
struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
return verify_expr_location_1 (tp, walk_subtrees, wi->info);
} |
functions | void
collect_subblocks (hash_set<tree> *blocks, tree block)
{
tree t;
for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
{
blocks->add (t);
collect_subblocks (blocks, t);
} |
functions | void
verify_gimple_in_cfg (struct function *fn, bool verify_nothrow)
{
basic_block bb;
bool err = false;
timevar_push (TV_TREE_STMT_VERIFY);
hash_set<void *> visited;
hash_set<gimple> visited_stmts;
/* Collect all BLOCKs referenced by the BLOCK tree of FN. */
hash_set<tree> blocks;
if (DECL_INITIAL (... |
functions | int
gimple_verify_flow_info (void)
{
int err = 0;
basic_block bb;
gimple_stmt_iterator gsi;
gimple stmt;
edge e;
edge_iterator ei;
if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->il.gimple.seq
|| ENTRY_BLOCK_PTR_FOR_FN (cfun)->il.gimple.phi_nodes)
{
error ("ENTRY_BLOCK has IL associated with it");
... |
functions | void
gimple_make_forwarder_block (edge fallthru)
{
edge e;
edge_iterator ei;
basic_block dummy, bb;
tree var;
gphi_iterator gsi;
dummy = fallthru->src;
bb = fallthru->dest;
if (single_pred_p (bb))
return;
/* If we redirected a branch we must create new PHI nodes at the
start of BB. */
f... |
functions | tree
gimple_block_label (basic_block bb)
{
gimple_stmt_iterator i, s = gsi_start_bb (bb);
bool first = true;
tree label;
glabel *stmt;
for (i = s; !gsi_end_p (i); first = false, gsi_next (&i))
{
stmt = dyn_cast <glabel *> (gsi_stmt (i));
if (!stmt)
break;
label = gimple_label_label (st... |
functions | edge
gimple_try_redirect_by_replacing_jump (edge e, basic_block target)
{
basic_block src = e->src;
gimple_stmt_iterator i;
gimple stmt;
/* We can replace or remove a complex jump only when we have exactly
two edges. */
if (EDGE_COUNT (src->succs) != 2
/* Verify that all targets will be TARGET. ... |
functions | edge
gimple_redirect_edge_and_branch (edge e, basic_block dest)
{
basic_block bb = e->src;
gimple_stmt_iterator gsi;
edge ret;
gimple stmt;
if (e->flags & EDGE_ABNORMAL)
return NULL;
if (e->dest == dest)
return NULL;
if (e->flags & EDGE_EH)
return redirect_eh_edge (e, dest);
if (e->src !... |
functions | bool
gimple_can_remove_branch_p (const_edge e)
{
if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
return false;
return true;
} |
functions | basic_block
gimple_redirect_edge_and_branch_force (edge e, basic_block dest)
{
e = gimple_redirect_edge_and_branch (e, dest);
gcc_assert (e);
return NULL;
} |
functions | basic_block
gimple_split_block (basic_block bb, void *stmt)
{
gimple_stmt_iterator gsi;
gimple_stmt_iterator gsi_tgt;
gimple_seq list;
basic_block new_bb;
edge e;
edge_iterator ei;
new_bb = create_empty_bb (bb);
/* Redirect the outgoing edges. */
new_bb->succs = bb->succs;
bb->succs = NULL;
FOR... |
functions | bool
gimple_move_block_after (basic_block bb, basic_block after)
{
if (bb->prev_bb == after)
return true;
unlink_block (bb);
link_block (bb, after);
return true;
} |
functions | bool
gimple_empty_block_p (basic_block bb)
{
/* BB must have no executable statements. */
gimple_stmt_iterator gsi = gsi_after_labels (bb);
if (phi_nodes (bb))
return false;
if (gsi_end_p (gsi))
return true;
if (is_gimple_debug (gsi_stmt (gsi)))
gsi_next_nondebug (&gsi);
return gsi_end_p (gsi);... |
functions | basic_block
gimple_split_block_before_cond_jump (basic_block bb)
{
gimple last, split_point;
gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
if (gsi_end_p (gsi))
return NULL;
last = gsi_stmt (gsi);
if (gimple_code (last) != GIMPLE_COND
&& gimple_code (last) != GIMPLE_SWITCH)
return NULL;
... |
functions | bool
gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED)
{
return true;
} |
functions | basic_block
gimple_duplicate_bb (basic_block bb)
{
basic_block new_bb;
gimple_stmt_iterator gsi_tgt;
new_bb = create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb);
/* Copy the PHI nodes. We ignore PHI node arguments here because
the incoming edges have not been setup yet. */
for (gphi_iterator gpi... |
functions | void
add_phi_args_after_copy_edge (edge e_copy)
{
basic_block bb, bb_copy = e_copy->src, dest;
edge e;
edge_iterator ei;
gphi *phi, *phi_copy;
tree def;
gphi_iterator psi, psi_copy;
if (gimple_seq_empty_p (phi_nodes (e_copy->dest)))
return;
bb = bb_copy->flags & BB_DUPLICATED ? get_bb_original (bb... |
functions | void
add_phi_args_after_copy_bb (basic_block bb_copy)
{
edge e_copy;
edge_iterator ei;
FOR_EACH_EDGE (e_copy, ei, bb_copy->succs)
{
add_phi_args_after_copy_edge (e_copy);
} |
functions | void
add_phi_args_after_copy (basic_block *region_copy, unsigned n_region,
edge e_copy)
{
unsigned i;
for (i = 0; i < n_region; i++)
region_copy[i]->flags |= BB_DUPLICATED;
for (i = 0; i < n_region; i++)
add_phi_args_after_copy_bb (region_copy[i]);
if (e_copy)
add_phi_args_after_copy_edge (e_c... |
functions | bool
gimple_duplicate_sese_region (edge entry, edge exit,
basic_block *region, unsigned n_region,
basic_block *region_copy,
bool update_dominance)
{
unsigned i;
bool free_region_copy = false, copying_header = false;
struct loop *loop = entry->dest->loop_father;
edge exit_copy;
vec<basic_b... |
functions | bool
bb_part_of_region_p (basic_block bb, basic_block* bbs, unsigned n_region)
{
unsigned int n;
for (n = 0; n < n_region; n++)
{
if (bb == bbs[n])
return true;
} |
functions | to
if (cond)
{
some_code;
A;
} |
functions | bool
gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED, edge exit ATTRIBUTE_UNUSED,
basic_block *region ATTRIBUTE_UNUSED, unsigned n_region ATTRIBUTE_UNUSED,
basic_block *region_copy ATTRIBUTE_UNUSED)
{
unsigned i;
bool free_region_copy = false;
struct loop *loop = exit->dest->loop_father;
struc... |
functions | void
gather_blocks_in_sese_region (basic_block entry, basic_block exit,
vec<basic_block> *bbs_p)
{
basic_block son;
for (son = first_dom_son (CDI_DOMINATORS, entry);
son;
son = next_dom_son (CDI_DOMINATORS, son))
{
bbs_p->safe_push (son);
if (son != exit)
gather_blocks_in_se... |
functions | void
replace_by_duplicate_decl (tree *tp, hash_map<tree, tree> *vars_map,
tree to_context)
{
tree t = *tp, new_t;
struct function *f = DECL_STRUCT_FUNCTION (to_context);
if (DECL_CONTEXT (t) == to_context)
return;
bool existed;
tree &loc = vars_map->get_or_insert (t, &existed);
if (!existed)
... |
functions | tree
replace_ssa_name (tree name, hash_map<tree, tree> *vars_map,
tree to_context)
{
tree new_name;
gcc_assert (!virtual_operand_p (name));
tree *loc = vars_map->get (name);
if (!loc)
{
tree decl = SSA_NAME_VAR (name);
if (decl)
{
gcc_assert (!SSA_NAME_IS_DEFAULT_DEF (name));
repla... |
functions | tree
move_stmt_op (tree *tp, int *walk_subtrees, void *data)
{
struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
tree t = *tp;
if (EXPR_P (t))
{
tree block = TREE_BLOCK (t);
if (block == p->orig_block
|| (p->orig_block == NUL... |
functions | else if (p->remap_decls_p)
{
/* Replace T with its duplicate. T should no longer appear in the
parent function, so this looks wasteful; however, it may appear
in referenced_vars, and more importantly, as virtual operands of
statements, and in alias lists of other variables. It would be
qui... |
functions | int
move_stmt_eh_region_nr (int old_nr, struct move_stmt_d *p)
{
eh_region old_r, new_r;
old_r = get_eh_region_from_number (old_nr);
new_r = static_cast<eh_region> (*p->eh_map->get (old_r));
return new_r->index;
} |
functions | tree
move_stmt_eh_region_tree_nr (tree old_t_nr, struct move_stmt_d *p)
{
int old_nr, new_nr;
old_nr = tree_to_shwi (old_t_nr);
new_nr = move_stmt_eh_region_nr (old_nr, p);
return build_int_cst (integer_type_node, new_nr);
} |
functions | tree
move_stmt_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
struct walk_stmt_info *wi)
{
struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
gimple stmt = gsi_stmt (*gsi_p);
tree block = gimple_block (stmt);
if (block == p->orig_block
|| (p->orig_block == NULL_TREE
&& block != NULL_... |
functions | void
move_block_to_fn (struct function *dest_cfun, basic_block bb,
basic_block after, bool update_edge_count_p,
struct move_stmt_d *d)
{
struct control_flow_graph *cfg;
edge_iterator ei;
edge e;
gimple_stmt_iterator si;
unsigned old_len, new_len;
/* Remove BB from dominance structures. */
delete... |
functions | eh_region
find_outermost_region_in_block (struct function *src_cfun,
basic_block bb, eh_region region)
{
gimple_stmt_iterator si;
for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
{
gimple stmt = gsi_stmt (si);
eh_region stmt_region;
int lp_nr;
lp_nr = lookup_stmt_eh_lp... |
functions | tree
new_label_mapper (tree decl, void *data)
{
htab_t hash = (htab_t) data;
struct tree_map *m;
void **slot;
gcc_assert (TREE_CODE (decl) == LABEL_DECL);
m = XNEW (struct tree_map);
m->hash = DECL_UID (decl);
m->base.from = decl;
m->to = create_artificial_label (UNKNOWN_LOCATION);
LABEL_DECL_UID (m... |
functions | tree
replace_block_vars_by_duplicates_1 (tree *tp, int *walk_subtrees, void *data)
{
struct replace_decls_d *rd = (struct replace_decls_d *)data;
switch (TREE_CODE (*tp))
{
case VAR_DECL:
case PARM_DECL:
case RESULT_DECL:
replace_by_duplicate_decl (tp, rd->vars_map, rd->to_context);
bre... |
functions | void
replace_block_vars_by_duplicates (tree block, hash_map<tree, tree> *vars_map,
tree to_context)
{
tree *tp, t;
for (tp = &BLOCK_VARS (block); *tp; tp = &DECL_CHAIN (*tp))
{
t = *tp;
if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != CONST_DECL)
continue;
replace_by_duplicate_decl (&... |
functions | void
fixup_loop_arrays_after_move (struct function *fn1, struct function *fn2,
struct loop *loop)
{
/* Discard it from the old loop array. */
(*get_loops (fn1))[loop->num] = NULL;
/* Place it in the new loop array, assigning it a new number. */
loop->num = number_of_loops (fn2);
vec_safe_push (loo... |
functions | void
verify_sese (basic_block entry, basic_block exit, vec<basic_block> *bbs_p)
{
basic_block bb;
edge_iterator ei;
edge e;
bitmap bbs = BITMAP_ALLOC (NULL);
int i;
gcc_assert (entry != NULL);
gcc_assert (entry != exit);
gcc_assert (bbs_p != NULL);
gcc_assert (bbs_p->length () > 0);
FOR_EACH_VEC_... |
functions | bool
gather_ssa_name_hash_map_from (tree const &from, tree const &, void *data)
{
bitmap release_names = (bitmap)data;
if (TREE_CODE (from) != SSA_NAME)
return true;
bitmap_set_bit (release_names, SSA_NAME_VERSION (from));
return true;
} |
functions | basic_block
move_sese_region_to_fn (struct function *dest_cfun, basic_block entry_bb,
basic_block exit_bb, tree orig_block)
{
vec<basic_block> bbs, dom_bbs;
basic_block dom_entry = get_immediate_dominator (CDI_DOMINATORS, entry_bb);
basic_block after, bb, *entry_pred, *exit_succ, abb;
struct function ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.