* tree-ssa-phiopt.c: Fix various formatting issues.

From-SVN: r81995

gcc/ChangeLog

+2004-05-18  Jeff Law  <law@redhat.com>
+
+	* tree-ssa-phiopt.c: Fix various formatting issues.
+
 2004-05-18  Steven Bosscher  <stevenb@suse.de>
 
 	* config/s390/s390.c (s390_expand_movstr, s390_expand_clrstr,

gcc/tree-ssa-phiopt.c

@@ -37,8 +37,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 static void tree_ssa_phiopt (void);
 static bool conditional_replacement (basic_block bb, tree phi, tree arg0,
-                                     tree arg1);                            
-                                  
+				     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:
@@ -49,16 +49,16 @@ static bool conditional_replacement (basic_block bb, tree phi, tree arg0,
      bb2:
       x = PHI (0 (bb1), 1 (bb0)
 
-    We can rewrite that as:
+   We can rewrite that as:
     
-    bb0:
-    bb1:
-    bb2:
+     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.  */
+   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)
@@ -77,19 +77,18 @@ tree_ssa_phiopt (void)
       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;
-              }
-        }
+	{
+	  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
@@ -98,10 +97,11 @@ tree_ssa_phiopt (void)
     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.   */
+/*  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)
@@ -116,7 +116,7 @@ conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
   tree new_var = NULL;
 
   /* The PHI arguments have the constants 0 and 1, then convert
-    it to the conditional.  */
+     it to the conditional.  */
   if ((integer_zerop (arg0) && integer_onep (arg1))
       || (integer_zerop (arg1) && integer_onep (arg0)))
     ;
@@ -124,8 +124,8 @@ conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
     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.  */
+     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)
@@ -142,7 +142,7 @@ conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
     return false;
   
   /* COND_BLOCK must have precisely two successors.  We indirectly
-      verify that those successors are BB and OTHER_BLOCK.  */
+     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
@@ -151,8 +151,8 @@ conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
     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.  */
+     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
@@ -165,19 +165,18 @@ conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
   /* 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))))
+	  && (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.  */
-
+     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
@@ -189,13 +188,13 @@ conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
     }
   
   /* 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.  */
+     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.  */
+     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.  */
@@ -205,43 +204,41 @@ conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
     {
       tree new1;
       if (TREE_CODE_CLASS (TREE_CODE (old_result)) != '<')
-        return false;
+	return false;
       
       new1 = build (TREE_CODE (old_result), TREE_TYPE (result),
-                    TREE_OPERAND (old_result, 0),
-                    TREE_OPERAND (old_result, 1));
+		    TREE_OPERAND (old_result, 0),
+		    TREE_OPERAND (old_result, 1));
       
       new1 = build (MODIFY_EXPR, TREE_TYPE (result),
-                    new_var, new1);
+		    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).
+     One successor is BB, the other successor is an empty block which
+     falls through into BB.
   
-      So, given the condition COND, and the two PHI arguments, we can
-      rewrite this PHI into non-branching code: 
+     There is a single PHI node at the join point (BB) and its arguments
+     are constants (0, 1).
   
-        dest = (COND) or dest = COND'
+     So, given the condition COND, and the two PHI arguments, we can
+     rewrite this PHI into non-branching code: 
   
-      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.  */
+       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);
+		    PHI_RESULT (phi), cond);
     }
   else
     {
@@ -254,35 +251,35 @@ conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
 	return false; 
 
       /* If what we get back is not gimple try to create it as gimple by
-         using a temporary variable.   */
+	 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);
-        }
+	{
+	  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;
+	  &&  !is_gimple_val (TREE_OPERAND (cond, 0)))
+	return false;
 
       new = build (MODIFY_EXPR, TREE_TYPE (PHI_RESULT (phi)),
-                    PHI_RESULT (phi), cond);
+		    PHI_RESULT (phi), cond);
     }
   
   bsi_insert_after (&bsi, new, BSI_NEW_STMT);
   
   /* Register our new statement as the defining statement for
-      the result.  */
+     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.  */
+     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;
   
@@ -308,10 +305,10 @@ conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
   
   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);
-            
+	      "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;
 }