0 /* letter */
};
-/* Search the CFG for any computed gotos. If found, factor them to a
+/* Search the CFG for any computed gotos. If found, factor them to a
common computed goto site. Also record the location of that site so
- that we can un-factor the gotos after we have converted back to
+ that we can un-factor the gotos after we have converted back to
normal form. */
static void
/* We know there are one or more computed gotos in this function.
Examine the last statement in each basic block to see if the block
ends with a computed goto. */
-
+
FOR_EACH_BB (bb)
{
block_stmt_iterator bsi = bsi_last (bb);
}
}
break;
-
+
default:
gcc_unreachable ();
}
/* Called for each element in the hash table (P) as we delete the
edge to cases hash table.
- Clear all the TREE_CHAINs to prevent problems with copying of
+ Clear all the TREE_CHAINs to prevent problems with copying of
SWITCH_EXPRs and structure sharing rules, then free the hash table
element. */
chains available. Return NULL so the caller can detect this case. */
if (!recording_case_labels_p ())
return NULL;
-
+
restart:
elt.e = e;
elt.case_labels = NULL;
and undefined variable warnings quite right. */
if ((errorcount || sorrycount) && uid < 0)
{
- block_stmt_iterator bsi =
+ block_stmt_iterator bsi =
bsi_start (BASIC_BLOCK (NUM_FIXED_BLOCKS));
tree stmt;
break;
}
-
+
case SWITCH_EXPR:
{
size_t i;
tree vec = SWITCH_LABELS (stmt);
size_t n = TREE_VEC_LENGTH (vec);
-
+
/* Replace all destination labels. */
for (i = 0; i < n; ++i)
{
int old_size = TREE_VEC_LENGTH (labels);
int i, j, new_size = old_size;
tree default_case = TREE_VEC_ELT (labels, old_size - 1);
- tree default_label;
+ tree default_label;
/* The default label is always the last case in a switch
statement after gimplification. */
if (b == EXIT_BLOCK_PTR)
return false;
-
+
/* If A ends by a statement causing exceptions or something similar, we
cannot merge the blocks. */
stmt = last_stmt (a);
mark_new_vars_to_rename (stmt);
}
}
-
+
gcc_assert (num_imm_uses (name) == 0);
/* Also update the trees stored in loop structures. */
reached by a complex edge, if there is one. Else, return BB. We use
this in optimizations that use post-dominators for their heuristics,
to catch the cases in C++ where function calls are involved. */
-
+
basic_block
-single_noncomplex_succ (basic_block bb)
+single_noncomplex_succ (basic_block bb)
{
edge e0, e1;
if (EDGE_COUNT (bb->succs) != 2)
return bb;
-
+
e0 = EDGE_SUCC (bb, 0);
e1 = EDGE_SUCC (bb, 1);
if (e0->flags & EDGE_COMPLEX)
return e1->dest;
if (e1->flags & EDGE_COMPLEX)
return e0->dest;
-
+
return bb;
-}
-
+}
/* Walk the function tree removing unnecessary statements.
/* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
decl. This allows us to eliminate redundant or useless
- calls to "const" functions.
+ calls to "const" functions.
Gimplifier already does the same operation, but we may notice functions
being const and pure once their calls has been gimplified, so we need
tsi_delink (&i);
continue;
}
-
+
remove_useless_stmts_1 (tsi_stmt_ptr (i), data);
t = tsi_stmt (i);
}
-struct tree_opt_pass pass_remove_useless_stmts =
+struct tree_opt_pass pass_remove_useless_stmts =
{
"useless", /* name */
NULL, /* gate */
DECL_NONLOCAL (LABEL_EXPR_LABEL (stmt)) = 0;
FORCED_LABEL (LABEL_EXPR_LABEL (stmt)) = 1;
}
-
+
new_bb = bb->prev_bb;
new_bsi = bsi_start (new_bb);
bsi_remove (&i, false);
edge true_edge, false_edge;
extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
-
+
gcc_assert (TREE_CODE (val) == INTEGER_CST);
return (zero_p (val) ? false_edge : true_edge);
}
{
debug_tree_bb (BASIC_BLOCK (n));
return BASIC_BLOCK (n);
-}
+}
/* Dump the CFG on stderr.
FLAGS are the same used by the tree dumping functions
- (see TDF_* in tree.h). */
+ (see TDF_* in tree-pass.h). */
void
debug_tree_cfg (int flags)
/* Remove the statement pointed to by iterator I. The iterator is updated
- to the next statement.
+ to the next statement.
When REMOVE_EH_INFO is true we remove the statement pointed to by
iterator I from the EH tables. Otherwise we do not modify the EH
/* Move the statement at FROM so it comes right after the statement at TO. */
-void
+void
bsi_move_after (block_stmt_iterator *from, block_stmt_iterator *to)
{
tree stmt = bsi_stmt (*from);
bsi_remove (from, false);
bsi_insert_after (to, stmt, BSI_SAME_STMT);
-}
+}
/* Move the statement at FROM so it comes right before the statement at TO. */
-void
+void
bsi_move_before (block_stmt_iterator *from, block_stmt_iterator *to)
{
tree stmt = bsi_stmt (*from);
bsi_move_to_bb_end (block_stmt_iterator *from, basic_block bb)
{
block_stmt_iterator last = bsi_last (bb);
-
+
/* Have to check bsi_end_p because it could be an empty block. */
if (!bsi_end_p (last) && is_ctrl_stmt (bsi_stmt (last)))
bsi_move_before (from, &last);
/* Replace the contents of the statement pointed to by iterator BSI
with STMT. If UPDATE_EH_INFO is true, the exception handling
information of the original statement is moved to the new statement. */
-
void
bsi_replace (const block_stmt_iterator *bsi, tree stmt, bool update_eh_info)
restart:
/* If the destination has one predecessor which has no PHI nodes,
- insert there. Except for the exit block.
+ insert there. Except for the exit block.
The requirement for no PHI nodes could be relaxed. Basically we
would have to examine the PHIs to prove that none of them used
if (!PENDING_STMT (old_edge))
return;
-
+
for (var = PENDING_STMT (old_edge), phi = phi_nodes (new_edge->dest);
var && phi;
var = TREE_CHAIN (var), phi = PHI_CHAIN (phi))
if (TYPE_P (t))
*walk_subtrees = 0;
-
+
/* Check operand N for being valid GIMPLE and give error MSG if not. */
#define CHECK_OP(N, MSG) \
do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
if (simple_goto_p (stmt))
{
error ("explicit goto at end of bb %d", bb->index);
- err = 1;
+ err = 1;
}
else
{
- /* FIXME. We should double check that the labels in the
+ /* FIXME. We should double check that the labels in the
destination blocks have their address taken. */
FOR_EACH_EDGE (e, ei, bb->succs)
if ((e->flags & (EDGE_FALLTHRU | EDGE_TRUE_VALUE
if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
return NULL;
- if (e->src != ENTRY_BLOCK_PTR
+ if (e->src != ENTRY_BLOCK_PTR
&& (ret = tree_try_redirect_by_replacing_jump (e, dest)))
return ret;
edge e, e_copy;
edge_iterator ei;
tree phi, phi_copy, phi_next, def;
-
+
bb = get_bb_original (bb_copy);
FOR_EACH_EDGE (e_copy, ei, bb_copy->succs)
total_count - entry_count,
total_count);
scale_bbs_frequencies_gcov_type (region_copy, n_region, entry_count,
- total_count);
+ total_count);
}
else
{
original array of blocks and placed in DEST_FN's array of blocks.
If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
updated to reflect the moved edges.
-
+
On exit, local variables that need to be removed from
CFUN->UNEXPANDED_VAR_LIST will have been added to VARS_TO_REMOVE. */
basic_block bb, int region)
{
block_stmt_iterator si;
-
+
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
{
tree stmt = bsi_stmt (si);
basic_block bb;
tree chain;
struct function *saved_cfun;
-
+
fprintf (file, "%s (", lang_hooks.decl_printable_name (fn, 2));
arg = DECL_ARGUMENTS (fn);
FOR_EACH_BB (bb)
dump_generic_bb (file, bb, 2, flags);
-
+
fprintf (file, "}\n");
check_bb_profile (EXIT_BLOCK_PTR, file);
}
{
char *s_indent;
basic_block bb;
-
+
if (loop == NULL)
return;
/* Print the loop's header. */
fprintf (file, "%sloop_%d\n", s_indent, loop->num);
-
+
/* Print the loop's body. */
fprintf (file, "%s{\n", s_indent);
FOR_EACH_BB (bb)
fprintf (file, "}, succs = {");
print_succ_bbs (file, bb);
fprintf (file, "})\n");
-
+
/* Print the basic_block's body. */
fprintf (file, "%s {\n", s_indent);
tree_dump_bb (bb, file, indent + 4);
fprintf (file, "%s }\n", s_indent);
}
-
+
print_loop (file, loop->inner, indent + 2);
fprintf (file, "%s}\n", s_indent);
print_loop (file, loop->next, indent);
/* Follow a CFG edge from the entry point of the program, and on entry
of a loop, pretty print the loop structure on FILE. */
-void
+void
print_loop_ir (FILE *file)
{
basic_block bb;
-
+
bb = BASIC_BLOCK (NUM_FIXED_BLOCKS);
if (bb && bb->loop_father)
print_loop (file, bb->loop_father, 0);
/* Debugging loops structure at tree level. */
-void
+void
debug_loop_ir (void)
{
print_loop_ir (stderr);
of 'first'. Both of them are dominated by 'new_head' basic block. When
'new_head' was created by 'second's incoming edge it received phi arguments
on the edge by split_edge(). Later, additional edge 'e' was created to
- connect 'new_head' and 'first'. Now this routine adds phi args on this
- additional edge 'e' that new_head to second edge received as part of edge
+ connect 'new_head' and 'first'. Now this routine adds phi args on this
+ additional edge 'e' that new_head to second edge received as part of edge
splitting.
*/
/* Browse all 'second' basic block phi nodes and add phi args to
edge 'e' for 'first' head. PHI args are always in correct order. */
- for (phi2 = phi_nodes (second), phi1 = phi_nodes (first);
- phi2 && phi1;
+ for (phi2 = phi_nodes (second), phi1 = phi_nodes (first);
+ phi2 && phi1;
phi2 = PHI_CHAIN (phi2), phi1 = PHI_CHAIN (phi1))
{
tree def = PHI_ARG_DEF (phi2, e2->dest_idx);
}
}
-/* Adds a if else statement to COND_BB with condition COND_EXPR.
- SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
+/* Adds a if else statement to COND_BB with condition COND_EXPR.
+ SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
the destination of the ELSE part. */
static void
tree_lv_add_condition_to_bb (basic_block first_head, basic_block second_head,
goto2 = build1 (GOTO_EXPR, void_type_node, tree_block_label (second_head));
new_cond_expr = build3 (COND_EXPR, void_type_node, cond_expr, goto1, goto2);
- /* Add new cond in cond_bb. */
- bsi = bsi_start (cond_bb);
+ /* Add new cond in cond_bb. */
+ bsi = bsi_start (cond_bb);
bsi_insert_after (&bsi, new_cond_expr, BSI_NEW_STMT);
/* Adjust edges appropriately to connect new head with first head
as well as second head. */
tree_lv_add_condition_to_bb, /* lv_add_condition_to_bb */
tree_lv_adjust_loop_header_phi, /* lv_adjust_loop_header_phi*/
extract_true_false_edges_from_block, /* extract_cond_bb_edges */
- flush_pending_stmts /* flush_pending_stmts */
+ flush_pending_stmts /* flush_pending_stmts */
};
return 0;
}
-struct tree_opt_pass pass_split_crit_edges =
+struct tree_opt_pass pass_split_crit_edges =
{
"crited", /* name */
NULL, /* gate */
OSDN Git Service
