This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
tree-ssa-phiopt.c -- fix formatting problems
- From: law at redhat dot com
- To: gcc-patches at gcc dot gnu dot org
- Date: Tue, 18 May 2004 10:12:18 -0600
- Subject: tree-ssa-phiopt.c -- fix formatting problems
- Reply-to: law at redhat dot com
I was in the process of reviewing one of Andrew's tree-ssa-phiopt.c changes
when I decided that we really need to fix the various formatting goobers
before extending the code further.
This patch fixes the formatting problem I found with a quick scan over the
code -- it has absolutely no functional changes. The next step will be to
factor some hunks of common code...
* tree-ssa-phiopt.c: Fix various formatting issues.
Index: tree-ssa-phiopt.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-phiopt.c,v
retrieving revision 2.2
diff -c -p -r2.2 tree-ssa-phiopt.c
*** tree-ssa-phiopt.c 14 May 2004 15:27:36 -0000 2.2
--- tree-ssa-phiopt.c 18 May 2004 16:09:27 -0000
*************** Software Foundation, 59 Temple Place - S
*** 37,44 ****
static void tree_ssa_phiopt (void);
static bool conditional_replacement (basic_block bb, tree phi, tree arg0,
! tree arg1);
!
/* This pass eliminates PHI nodes which can be trivially implemented as
an assignment from a conditional expression. ie if we have something
like:
--- 37,44 ----
static void tree_ssa_phiopt (void);
static bool conditional_replacement (basic_block bb, tree phi, tree arg0,
! tree arg1);
!
/* This pass eliminates PHI nodes which can be trivially implemented as
an assignment from a conditional expression. ie if we have something
like:
*************** static bool conditional_replacement (bas
*** 49,64 ****
bb2:
x = PHI (0 (bb1), 1 (bb0)
! We can rewrite that as:
! bb0:
! bb1:
! bb2:
x = cond;
! bb1 will become unreachable and bb0 and bb2 will almost always
! be merged into a single block. This occurs often due to gimplification
! of conditionals. */
static void
tree_ssa_phiopt (void)
--- 49,64 ----
bb2:
x = PHI (0 (bb1), 1 (bb0)
! We can rewrite that as:
! bb0:
! bb1:
! bb2:
x = cond;
! bb1 will become unreachable and bb0 and bb2 will almost always
! be merged into a single block. This occurs often due to gimplification
! of conditionals. */
static void
tree_ssa_phiopt (void)
*************** tree_ssa_phiopt (void)
*** 77,95 ****
phi = phi_nodes (bb);
if (phi && TREE_CHAIN (phi) == NULL
&& PHI_NUM_ARGS (phi) == 2)
! {
!
! arg0 = PHI_ARG_DEF (phi, 0);
! arg1 = PHI_ARG_DEF (phi, 1);
!
! /* Do the replacement of conditional if it can be done. */
! if (conditional_replacement (bb, phi, arg0, arg1))
! {
! /* We have done the replacement so we need to rebuild the cfg. */
! removed_phis = true;
! continue;
! }
! }
}
/* If we removed any PHIs, then we have unreachable blocks and blocks
--- 77,94 ----
phi = phi_nodes (bb);
if (phi && TREE_CHAIN (phi) == NULL
&& PHI_NUM_ARGS (phi) == 2)
! {
! arg0 = PHI_ARG_DEF (phi, 0);
! arg1 = PHI_ARG_DEF (phi, 1);
!
! /* Do the replacement of conditional if it can be done. */
! if (conditional_replacement (bb, phi, arg0, arg1))
! {
! /* We have done the replacement so we need to rebuild the cfg. */
! removed_phis = true;
! continue;
! }
! }
}
/* If we removed any PHIs, then we have unreachable blocks and blocks
*************** tree_ssa_phiopt (void)
*** 98,107 ****
cleanup_tree_cfg ();
}
! /* The function conditional_replacement does the main work of doing the conditional
! replacement. Return true if the replacement is done. Otherwise return false.
! bb is the basic block where the replacement is going to be done on. arg0
! is argument 0 from the phi. Likewise for arg1. */
static bool
conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
--- 97,107 ----
cleanup_tree_cfg ();
}
! /* The function conditional_replacement does the main work of doing the
! conditional replacement. Return true if the replacement is done.
! Otherwise return false.
! BB is the basic block where the replacement is going to be done on. ARG0
! is argument 0 from PHI. Likewise for ARG1. */
static bool
conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
*************** conditional_replacement (basic_block bb,
*** 116,122 ****
tree new_var = NULL;
/* The PHI arguments have the constants 0 and 1, then convert
! it to the conditional. */
if ((integer_zerop (arg0) && integer_onep (arg1))
|| (integer_zerop (arg1) && integer_onep (arg0)))
;
--- 116,122 ----
tree new_var = NULL;
/* The PHI arguments have the constants 0 and 1, then convert
! it to the conditional. */
if ((integer_zerop (arg0) && integer_onep (arg1))
|| (integer_zerop (arg1) && integer_onep (arg0)))
;
*************** conditional_replacement (basic_block bb,
*** 124,131 ****
return false;
/* One of the alternatives must come from a block ending with
! a COND_EXPR. The other block must be entirely empty, except
! for labels. */
last0 = last_stmt (bb->pred->src);
last1 = last_stmt (bb->pred->pred_next->src);
if (last0 && TREE_CODE (last0) == COND_EXPR)
--- 124,131 ----
return false;
/* One of the alternatives must come from a block ending with
! a COND_EXPR. The other block must be entirely empty, except
! for labels. */
last0 = last_stmt (bb->pred->src);
last1 = last_stmt (bb->pred->pred_next->src);
if (last0 && TREE_CODE (last0) == COND_EXPR)
*************** conditional_replacement (basic_block bb,
*** 142,148 ****
return false;
/* COND_BLOCK must have precisely two successors. We indirectly
! verify that those successors are BB and OTHER_BLOCK. */
if (!cond_block->succ
|| !cond_block->succ->succ_next
|| cond_block->succ->succ_next->succ_next
--- 142,148 ----
return false;
/* COND_BLOCK must have precisely two successors. We indirectly
! verify that those successors are BB and OTHER_BLOCK. */
if (!cond_block->succ
|| !cond_block->succ->succ_next
|| cond_block->succ->succ_next->succ_next
*************** conditional_replacement (basic_block bb,
*** 151,158 ****
return false;
/* OTHER_BLOCK must have a single predecessor which is COND_BLOCK,
! OTHER_BLOCK must have a single successor which is BB and
! OTHER_BLOCK must have no PHI nodes. */
if (!other_block->pred
|| other_block->pred->src != cond_block
|| other_block->pred->pred_next
--- 151,158 ----
return false;
/* OTHER_BLOCK must have a single predecessor which is COND_BLOCK,
! OTHER_BLOCK must have a single successor which is BB and
! OTHER_BLOCK must have no PHI nodes. */
if (!other_block->pred
|| other_block->pred->src != cond_block
|| other_block->pred->pred_next
*************** conditional_replacement (basic_block bb,
*** 165,183 ****
/* OTHER_BLOCK must have no executable statements. */
bsi = bsi_start (other_block);
while (!bsi_end_p (bsi)
! && (TREE_CODE (bsi_stmt (bsi)) == LABEL_EXPR
! || IS_EMPTY_STMT (bsi_stmt (bsi))))
bsi_next (&bsi);
if (!bsi_end_p (bsi))
return false;
/* If the condition is not a naked SSA_NAME and its type does not
! match the type of the result, then we have to create a new
! variable to optimize this case as it would likely create
! non-gimple code when the condition was converted to the
! result's type. */
!
cond = COND_EXPR_COND (last_stmt (cond_block));
result = PHI_RESULT (phi);
if (TREE_CODE (cond) != SSA_NAME
--- 165,182 ----
/* OTHER_BLOCK must have no executable statements. */
bsi = bsi_start (other_block);
while (!bsi_end_p (bsi)
! && (TREE_CODE (bsi_stmt (bsi)) == LABEL_EXPR
! || IS_EMPTY_STMT (bsi_stmt (bsi))))
bsi_next (&bsi);
if (!bsi_end_p (bsi))
return false;
/* If the condition is not a naked SSA_NAME and its type does not
! match the type of the result, then we have to create a new
! variable to optimize this case as it would likely create
! non-gimple code when the condition was converted to the
! result's type. */
cond = COND_EXPR_COND (last_stmt (cond_block));
result = PHI_RESULT (phi);
if (TREE_CODE (cond) != SSA_NAME
*************** conditional_replacement (basic_block bb,
*** 189,201 ****
}
/* If the condition was a naked SSA_NAME and the type is not the
! same as the type of the result, then convert the type of the
! condition. */
if (!lang_hooks.types_compatible_p (TREE_TYPE (cond), TREE_TYPE (result)))
cond = fold_convert (TREE_TYPE (result), cond);
/* We need to know which is the true edge and which is the false
! edge so that we know when to invert the condition below. */
extract_true_false_edges_from_block (cond_block, &true_edge, &false_edge);
/* Insert our new statement at the head of our block. */
--- 188,200 ----
}
/* If the condition was a naked SSA_NAME and the type is not the
! same as the type of the result, then convert the type of the
! condition. */
if (!lang_hooks.types_compatible_p (TREE_TYPE (cond), TREE_TYPE (result)))
cond = fold_convert (TREE_TYPE (result), cond);
/* We need to know which is the true edge and which is the false
! edge so that we know when to invert the condition below. */
extract_true_false_edges_from_block (cond_block, &true_edge, &false_edge);
/* Insert our new statement at the head of our block. */
*************** conditional_replacement (basic_block bb,
*** 205,247 ****
{
tree new1;
if (TREE_CODE_CLASS (TREE_CODE (old_result)) != '<')
! return false;
new1 = build (TREE_CODE (old_result), TREE_TYPE (result),
! TREE_OPERAND (old_result, 0),
! TREE_OPERAND (old_result, 1));
new1 = build (MODIFY_EXPR, TREE_TYPE (result),
! new_var, new1);
bsi_insert_after (&bsi, new1, BSI_NEW_STMT);
}
-
/* At this point we know we have a COND_EXPR with two successors.
! One successor is BB, the other successor is an empty block which
! falls through into BB.
!
! There is a single PHI node at the join point (BB) and its arguments
! are constants (0, 1).
! So, given the condition COND, and the two PHI arguments, we can
! rewrite this PHI into non-branching code:
! dest = (COND) or dest = COND'
!
! We use the condition as-is if the argument associated with the
! true edge has the value one or the argument associated with the
! false edge as the value zero. Note that those conditions are not
! the same since only one of the outgoing edges from the COND_EXPR
! will directly reach BB and thus be associated with an argument. */
if ((PHI_ARG_EDGE (phi, 0) == true_edge && integer_onep (arg0))
|| (PHI_ARG_EDGE (phi, 0) == false_edge && integer_zerop (arg0))
|| (PHI_ARG_EDGE (phi, 1) == true_edge && integer_onep (arg1))
|| (PHI_ARG_EDGE (phi, 1) == false_edge && integer_zerop (arg1)))
{
new = build (MODIFY_EXPR, TREE_TYPE (PHI_RESULT (phi)),
! PHI_RESULT (phi), cond);
}
else
{
--- 204,244 ----
{
tree new1;
if (TREE_CODE_CLASS (TREE_CODE (old_result)) != '<')
! return false;
new1 = build (TREE_CODE (old_result), TREE_TYPE (result),
! TREE_OPERAND (old_result, 0),
! TREE_OPERAND (old_result, 1));
new1 = build (MODIFY_EXPR, TREE_TYPE (result),
! new_var, new1);
bsi_insert_after (&bsi, new1, BSI_NEW_STMT);
}
/* At this point we know we have a COND_EXPR with two successors.
! One successor is BB, the other successor is an empty block which
! falls through into BB.
! There is a single PHI node at the join point (BB) and its arguments
! are constants (0, 1).
! So, given the condition COND, and the two PHI arguments, we can
! rewrite this PHI into non-branching code:
+ dest = (COND) or dest = COND'
+
+ We use the condition as-is if the argument associated with the
+ true edge has the value one or the argument associated with the
+ false edge as the value zero. Note that those conditions are not
+ the same since only one of the outgoing edges from the COND_EXPR
+ will directly reach BB and thus be associated with an argument. */
if ((PHI_ARG_EDGE (phi, 0) == true_edge && integer_onep (arg0))
|| (PHI_ARG_EDGE (phi, 0) == false_edge && integer_zerop (arg0))
|| (PHI_ARG_EDGE (phi, 1) == true_edge && integer_onep (arg1))
|| (PHI_ARG_EDGE (phi, 1) == false_edge && integer_zerop (arg1)))
{
new = build (MODIFY_EXPR, TREE_TYPE (PHI_RESULT (phi)),
! PHI_RESULT (phi), cond);
}
else
{
*************** conditional_replacement (basic_block bb,
*** 254,288 ****
return false;
/* If what we get back is not gimple try to create it as gimple by
! using a temporary variable. */
if (is_gimple_cast (cond)
&& !is_gimple_val (TREE_OPERAND (cond, 0)))
! {
! tree temp = TREE_OPERAND (cond, 0);
! tree new_var_1 = make_rename_temp (TREE_TYPE (temp), NULL);
! new = build (MODIFY_EXPR, TREE_TYPE (new_var_1), new_var_1, temp);
! bsi_insert_after (&bsi, new, BSI_NEW_STMT);
! cond = fold_convert (TREE_TYPE (result), new_var_1);
! }
if (TREE_CODE (cond) == TRUTH_NOT_EXPR
! && !is_gimple_val (TREE_OPERAND (cond, 0)))
! return false;
new = build (MODIFY_EXPR, TREE_TYPE (PHI_RESULT (phi)),
! PHI_RESULT (phi), cond);
}
bsi_insert_after (&bsi, new, BSI_NEW_STMT);
/* Register our new statement as the defining statement for
! the result. */
SSA_NAME_DEF_STMT (PHI_RESULT (phi)) = new;
/* Remove the now useless PHI node.
! We do not want to use remove_phi_node since that releases the
! SSA_NAME as well and the SSA_NAME is still being used. */
release_phi_node (phi);
bb_ann (bb)->phi_nodes = NULL;
--- 251,285 ----
return false;
/* If what we get back is not gimple try to create it as gimple by
! using a temporary variable. */
if (is_gimple_cast (cond)
&& !is_gimple_val (TREE_OPERAND (cond, 0)))
! {
! tree temp = TREE_OPERAND (cond, 0);
! tree new_var_1 = make_rename_temp (TREE_TYPE (temp), NULL);
! new = build (MODIFY_EXPR, TREE_TYPE (new_var_1), new_var_1, temp);
! bsi_insert_after (&bsi, new, BSI_NEW_STMT);
! cond = fold_convert (TREE_TYPE (result), new_var_1);
! }
if (TREE_CODE (cond) == TRUTH_NOT_EXPR
! && !is_gimple_val (TREE_OPERAND (cond, 0)))
! return false;
new = build (MODIFY_EXPR, TREE_TYPE (PHI_RESULT (phi)),
! PHI_RESULT (phi), cond);
}
bsi_insert_after (&bsi, new, BSI_NEW_STMT);
/* Register our new statement as the defining statement for
! the result. */
SSA_NAME_DEF_STMT (PHI_RESULT (phi)) = new;
/* Remove the now useless PHI node.
! We do not want to use remove_phi_node since that releases the
! SSA_NAME as well and the SSA_NAME is still being used. */
release_phi_node (phi);
bb_ann (bb)->phi_nodes = NULL;
*************** conditional_replacement (basic_block bb,
*** 308,317 ****
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
! "COND_EXPR in block %d and PHI in block %d converted to straightline code.\n",
! cond_block->index,
! bb->index);
!
/* Note that we optimized this PHI. */
return true;
}
--- 305,314 ----
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
! "COND_EXPR in block %d and PHI in block %d converted to straightline code.\n",
! cond_block->index,
! bb->index);
!
/* Note that we optimized this PHI. */
return true;
}