Replace spaces with tabs and remove trailing whitespaces

	* tree-ssa-uninit.c: Fix whitespaces in the source file.
	The change is just automatical.

From-SVN: r230998

1 files changed, 502 insertions, 502 deletions

diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c
index 0709cce7561..50bfb0361f1 100644
--- a/gcc/tree-ssa-uninit.c
+++ b/gcc/tree-ssa-uninit.c
@@ -76,8 +76,8 @@ static bool
 has_undefined_value_p (tree t)
 {
   return (ssa_undefined_value_p (t)
-          || (possibly_undefined_names
-              && possibly_undefined_names->contains (t)));
+	  || (possibly_undefined_names
+	      && possibly_undefined_names->contains (t)));
 }
 
 
@@ -270,9 +270,9 @@ can_skip_redundant_opnd (tree opnd, gimple *phi)
     {
       tree op = gimple_phi_arg_def (op_def, i);
       if (TREE_CODE (op) != SSA_NAME)
-        continue;
+	continue;
       if (op != phi_def && uninit_undefined_value_p (op))
-        return false;
+	return false;
     }
 
   return true;
@@ -296,10 +296,10 @@ compute_uninit_opnds_pos (gphi *phi)
     {
       tree op = gimple_phi_arg_def (phi, i);
       if (TREE_CODE (op) == SSA_NAME
-          && uninit_undefined_value_p (op)
-          && !can_skip_redundant_opnd (op, phi))
+	  && uninit_undefined_value_p (op)
+	  && !can_skip_redundant_opnd (op, phi))
 	{
-          if (cfun->has_nonlocal_label || cfun->calls_setjmp)
+	  if (cfun->has_nonlocal_label || cfun->calls_setjmp)
 	    {
 	      /* Ignore SSA_NAMEs that appear on abnormal edges
 		 somewhere.  */
@@ -323,7 +323,7 @@ find_pdom (basic_block block)
    else
      {
        basic_block bb
-           = get_immediate_dominator (CDI_POST_DOMINATORS, block);
+	   = get_immediate_dominator (CDI_POST_DOMINATORS, block);
        if (! bb)
 	 return EXIT_BLOCK_PTR_FOR_FN (cfun);
        return bb;
@@ -398,8 +398,8 @@ find_control_equiv_block (basic_block bb)
 
 static bool
 compute_control_dep_chain (basic_block bb, basic_block dep_bb,
-                           vec<edge> *cd_chains,
-                           size_t *num_chains,
+			   vec<edge> *cd_chains,
+			   size_t *num_chains,
 			   vec<edge> *cur_cd_chain,
 			   int *num_calls)
 {
@@ -426,7 +426,7 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
       edge e = (*cur_cd_chain)[i];
       /* Cycle detected. */
       if (e->src == bb)
-        return false;
+	return false;
     }
 
   FOR_EACH_EDGE (e, ei, bb->succs)
@@ -434,39 +434,39 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
       basic_block cd_bb;
       int post_dom_check = 0;
       if (e->flags & (EDGE_FAKE | EDGE_ABNORMAL))
-        continue;
+	continue;
 
       cd_bb = e->dest;
       cur_cd_chain->safe_push (e);
       while (!is_non_loop_exit_postdominating (cd_bb, bb))
-        {
-          if (cd_bb == dep_bb)
-            {
-              /* Found a direct control dependence.  */
-              if (*num_chains < MAX_NUM_CHAINS)
-                {
-                  cd_chains[*num_chains] = cur_cd_chain->copy ();
-                  (*num_chains)++;
-                }
-              found_cd_chain = true;
-              /* Check path from next edge.  */
-              break;
-            }
-
-          /* Now check if DEP_BB is indirectly control dependent on BB.  */
-          if (compute_control_dep_chain (cd_bb, dep_bb, cd_chains,
+	{
+	  if (cd_bb == dep_bb)
+	    {
+	      /* Found a direct control dependence.  */
+	      if (*num_chains < MAX_NUM_CHAINS)
+		{
+		  cd_chains[*num_chains] = cur_cd_chain->copy ();
+		  (*num_chains)++;
+		}
+	      found_cd_chain = true;
+	      /* Check path from next edge.  */
+	      break;
+	    }
+
+	  /* Now check if DEP_BB is indirectly control dependent on BB.  */
+	  if (compute_control_dep_chain (cd_bb, dep_bb, cd_chains,
 					 num_chains, cur_cd_chain, num_calls))
-            {
-              found_cd_chain = true;
-              break;
-            }
+	    {
+	      found_cd_chain = true;
+	      break;
+	    }
 
-          cd_bb = find_pdom (cd_bb);
-          post_dom_check++;
+	  cd_bb = find_pdom (cd_bb);
+	  post_dom_check++;
 	  if (cd_bb == EXIT_BLOCK_PTR_FOR_FN (cfun) || post_dom_check >
 	      MAX_POSTDOM_CHECK)
-            break;
-        }
+	    break;
+	}
       cur_cd_chain->pop ();
       gcc_assert (cur_cd_chain->length () == cur_chain_len);
     }
@@ -508,8 +508,8 @@ typedef vec<pred_chain, va_heap, vl_ptr> pred_chain_union;
 
 static bool
 convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
-                                      size_t num_chains,
-                                      pred_chain_union *preds)
+				      size_t num_chains,
+				      pred_chain_union *preds)
 {
   bool has_valid_pred = false;
   size_t i, j;
@@ -527,48 +527,48 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
       has_valid_pred = false;
       pred_chain t_chain = vNULL;
       for (j = 0; j < one_cd_chain.length (); j++)
-        {
+	{
 	  gimple *cond_stmt;
-          gimple_stmt_iterator gsi;
-          basic_block guard_bb;
-          pred_info one_pred;
-          edge e;
-
-          e = one_cd_chain[j];
-          guard_bb = e->src;
-          gsi = gsi_last_bb (guard_bb);
-          if (gsi_end_p (gsi))
-            {
-              has_valid_pred = false;
-              break;
-            }
-          cond_stmt = gsi_stmt (gsi);
-          if (is_gimple_call (cond_stmt)
-              && EDGE_COUNT (e->src->succs) >= 2)
-            {
-              /* Ignore EH edge. Can add assertion
-                 on the other edge's flag.  */
-              continue;
-            }
-          /* Skip if there is essentially one succesor.  */
-          if (EDGE_COUNT (e->src->succs) == 2)
-            {
-              edge e1;
-              edge_iterator ei1;
-              bool skip = false;
-
-              FOR_EACH_EDGE (e1, ei1, e->src->succs)
-                {
-                  if (EDGE_COUNT (e1->dest->succs) == 0)
-                    {
-                      skip = true;
-                      break;
-                    }
-                }
-              if (skip)
-                continue;
-            }
-          if (gimple_code (cond_stmt) == GIMPLE_COND)
+	  gimple_stmt_iterator gsi;
+	  basic_block guard_bb;
+	  pred_info one_pred;
+	  edge e;
+
+	  e = one_cd_chain[j];
+	  guard_bb = e->src;
+	  gsi = gsi_last_bb (guard_bb);
+	  if (gsi_end_p (gsi))
+	    {
+	      has_valid_pred = false;
+	      break;
+	    }
+	  cond_stmt = gsi_stmt (gsi);
+	  if (is_gimple_call (cond_stmt)
+	      && EDGE_COUNT (e->src->succs) >= 2)
+	    {
+	      /* Ignore EH edge. Can add assertion
+		 on the other edge's flag.  */
+	      continue;
+	    }
+	  /* Skip if there is essentially one succesor.  */
+	  if (EDGE_COUNT (e->src->succs) == 2)
+	    {
+	      edge e1;
+	      edge_iterator ei1;
+	      bool skip = false;
+
+	      FOR_EACH_EDGE (e1, ei1, e->src->succs)
+		{
+		  if (EDGE_COUNT (e1->dest->succs) == 0)
+		    {
+		      skip = true;
+		      break;
+		    }
+		}
+	      if (skip)
+		continue;
+	    }
+	  if (gimple_code (cond_stmt) == GIMPLE_COND)
 	    {
 	      one_pred.pred_lhs = gimple_cond_lhs (cond_stmt);
 	      one_pred.pred_rhs = gimple_cond_rhs (cond_stmt);
@@ -603,7 +603,7 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
 		    }
 		}
 	      /* If more than one label reaches this block or the case
-	         label doesn't have a single value (like the default one)
+		 label doesn't have a single value (like the default one)
 		 fail.  */
 	      if (!l
 		  || !CASE_LOW (l)
@@ -621,11 +621,11 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
 	      has_valid_pred = true;
 	    }
 	  else
-            {
-              has_valid_pred = false;
-              break;
-            }
-        }
+	    {
+	      has_valid_pred = false;
+	      break;
+	    }
+	}
 
       if (!has_valid_pred)
 	break;
@@ -642,8 +642,8 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
 
 static bool
 find_predicates (pred_chain_union *preds,
-                 basic_block phi_bb,
-                 basic_block use_bb)
+		 basic_block phi_bb,
+		 basic_block use_bb)
 {
   size_t num_chains = 0, i;
   int num_calls = 0;
@@ -659,9 +659,9 @@ find_predicates (pred_chain_union *preds,
     {
       basic_block ctrl_eq_bb = find_control_equiv_block (cd_root);
       if (ctrl_eq_bb && dominated_by_p (CDI_DOMINATORS, use_bb, ctrl_eq_bb))
-        cd_root = ctrl_eq_bb;
+	cd_root = ctrl_eq_bb;
       else
-        break;
+	break;
     }
 
   compute_control_dep_chain (cd_root, use_bb, dep_chains, &num_chains,
@@ -699,33 +699,33 @@ collect_phi_def_edges (gphi *phi, basic_block cd_root,
       opnd = gimple_phi_arg_def (phi, i);
 
       if (TREE_CODE (opnd) != SSA_NAME)
-        {
-          if (dump_file && (dump_flags & TDF_DETAILS))
-            {
-              fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int)i);
-              print_gimple_stmt (dump_file, phi, 0, 0);
-            }
-          edges->safe_push (opnd_edge);
-        }
+	{
+	  if (dump_file && (dump_flags & TDF_DETAILS))
+	    {
+	      fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int)i);
+	      print_gimple_stmt (dump_file, phi, 0, 0);
+	    }
+	  edges->safe_push (opnd_edge);
+	}
       else
-        {
+	{
 	  gimple *def = SSA_NAME_DEF_STMT (opnd);
 
-          if (gimple_code (def) == GIMPLE_PHI
-              && dominated_by_p (CDI_DOMINATORS,
-                                 gimple_bb (def), cd_root))
-            collect_phi_def_edges (as_a <gphi *> (def), cd_root, edges,
-                                   visited_phis);
-          else if (!uninit_undefined_value_p (opnd))
-            {
-              if (dump_file && (dump_flags & TDF_DETAILS))
-                {
-                  fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int)i);
-                  print_gimple_stmt (dump_file, phi, 0, 0);
-                }
-              edges->safe_push (opnd_edge);
-            }
-        }
+	  if (gimple_code (def) == GIMPLE_PHI
+	      && dominated_by_p (CDI_DOMINATORS,
+				 gimple_bb (def), cd_root))
+	    collect_phi_def_edges (as_a <gphi *> (def), cd_root, edges,
+				   visited_phis);
+	  else if (!uninit_undefined_value_p (opnd))
+	    {
+	      if (dump_file && (dump_flags & TDF_DETAILS))
+		{
+		  fprintf (dump_file, "\n[CHECK] Found def edge %d in ", (int)i);
+		  print_gimple_stmt (dump_file, phi, 0, 0);
+		}
+	      edges->safe_push (opnd_edge);
+	    }
+	}
     }
 }
 
@@ -769,14 +769,14 @@ find_def_preds (pred_chain_union *preds, gphi *phi)
 				 &num_chains, &cur_chain, &num_calls);
 
       /* Now update the newly added chains with
-         the phi operand edge:  */
+	 the phi operand edge:  */
       if (EDGE_COUNT (opnd_edge->src->succs) > 1)
-        {
+	{
 	  if (prev_nc == num_chains && num_chains < MAX_NUM_CHAINS)
 	    dep_chains[num_chains++] = vNULL;
-          for (j = prev_nc; j < num_chains; j++)
+	  for (j = prev_nc; j < num_chains; j++)
 	    dep_chains[j].safe_push (opnd_edge);
-        }
+	}
     }
 
   has_valid_pred
@@ -790,7 +790,7 @@ find_def_preds (pred_chain_union *preds, gphi *phi)
 
 static void
 dump_predicates (gimple *usestmt, pred_chain_union preds,
-                 const char* msg)
+		 const char* msg)
 {
   size_t i, j;
   pred_chain one_pred_chain = vNULL;
@@ -807,22 +807,22 @@ dump_predicates (gimple *usestmt, pred_chain_union preds,
       np = one_pred_chain.length ();
 
       for (j = 0; j < np; j++)
-        {
-          pred_info one_pred = one_pred_chain[j];
-          if (one_pred.invert)
-            fprintf (dump_file, " (.NOT.) ");
-          print_generic_expr (dump_file, one_pred.pred_lhs, 0);
-          fprintf (dump_file, " %s ", op_symbol_code (one_pred.cond_code));
-          print_generic_expr (dump_file, one_pred.pred_rhs, 0);
-          if (j < np - 1)
-            fprintf (dump_file, " (.AND.) ");
-          else
-            fprintf (dump_file, "\n");
-        }
+	{
+	  pred_info one_pred = one_pred_chain[j];
+	  if (one_pred.invert)
+	    fprintf (dump_file, " (.NOT.) ");
+	  print_generic_expr (dump_file, one_pred.pred_lhs, 0);
+	  fprintf (dump_file, " %s ", op_symbol_code (one_pred.cond_code));
+	  print_generic_expr (dump_file, one_pred.pred_rhs, 0);
+	  if (j < np - 1)
+	    fprintf (dump_file, " (.AND.) ");
+	  else
+	    fprintf (dump_file, "\n");
+	}
       if (i < num_preds - 1)
-        fprintf (dump_file, "(.OR.)\n");
+	fprintf (dump_file, "(.OR.)\n");
       else
-        fprintf (dump_file, "\n\n");
+	fprintf (dump_file, "\n\n");
     }
 }
 
@@ -845,7 +845,7 @@ destroy_predicate_vecs (pred_chain_union *preds)
 
 static enum tree_code
 get_cmp_code (enum tree_code orig_cmp_code,
-              bool swap_cond, bool invert)
+	      bool swap_cond, bool invert)
 {
   enum tree_code tc = orig_cmp_code;
 
@@ -896,27 +896,27 @@ is_value_included_in (tree val, tree boundary, enum tree_code cmpc)
   if (is_unsigned)
     {
       if (cmpc == EQ_EXPR)
-        result = tree_int_cst_equal (val, boundary);
+	result = tree_int_cst_equal (val, boundary);
       else if (cmpc == LT_EXPR)
-        result = tree_int_cst_lt (val, boundary);
+	result = tree_int_cst_lt (val, boundary);
       else
-        {
-          gcc_assert (cmpc == LE_EXPR);
-          result = tree_int_cst_le (val, boundary);
-        }
+	{
+	  gcc_assert (cmpc == LE_EXPR);
+	  result = tree_int_cst_le (val, boundary);
+	}
     }
   else
     {
       if (cmpc == EQ_EXPR)
-        result = tree_int_cst_equal (val, boundary);
+	result = tree_int_cst_equal (val, boundary);
       else if (cmpc == LT_EXPR)
-        result = tree_int_cst_lt (val, boundary);
+	result = tree_int_cst_lt (val, boundary);
       else
-        {
-          gcc_assert (cmpc == LE_EXPR);
-          result = (tree_int_cst_equal (val, boundary)
-                    || tree_int_cst_lt (val, boundary));
-        }
+	{
+	  gcc_assert (cmpc == LE_EXPR);
+	  result = (tree_int_cst_equal (val, boundary)
+		    || tree_int_cst_lt (val, boundary));
+	}
     }
 
   if (inverted)
@@ -931,8 +931,8 @@ is_value_included_in (tree val, tree boundary, enum tree_code cmpc)
 
 static bool
 find_matching_predicate_in_rest_chains (pred_info pred,
-                                        pred_chain_union preds,
-                                        size_t num_pred_chains)
+					pred_chain_union preds,
+					size_t num_pred_chains)
 {
   size_t i, j, n;
 
@@ -946,24 +946,24 @@ find_matching_predicate_in_rest_chains (pred_info pred,
       pred_chain one_chain = preds[i];
       n = one_chain.length ();
       for (j = 0; j < n; j++)
-        {
-          pred_info pred2 = one_chain[j];
-          /* Can relax the condition comparison to not
-             use address comparison. However, the most common
-             case is that multiple control dependent paths share
-             a common path prefix, so address comparison should
-             be ok.  */
-
-          if (operand_equal_p (pred2.pred_lhs, pred.pred_lhs, 0)
-              && operand_equal_p (pred2.pred_rhs, pred.pred_rhs, 0)
-              && pred2.invert == pred.invert)
-            {
-              found = true;
-              break;
-            }
-        }
+	{
+	  pred_info pred2 = one_chain[j];
+	  /* Can relax the condition comparison to not
+	     use address comparison. However, the most common
+	     case is that multiple control dependent paths share
+	     a common path prefix, so address comparison should
+	     be ok.  */
+
+	  if (operand_equal_p (pred2.pred_lhs, pred.pred_lhs, 0)
+	      && operand_equal_p (pred2.pred_rhs, pred.pred_rhs, 0)
+	      && pred2.invert == pred.invert)
+	    {
+	      found = true;
+	      break;
+	    }
+	}
       if (!found)
-        return false;
+	return false;
     }
   return true;
 }
@@ -971,11 +971,11 @@ find_matching_predicate_in_rest_chains (pred_info pred,
 /* Forward declaration.  */
 static bool
 is_use_properly_guarded (gimple *use_stmt,
-                         basic_block use_bb,
-                         gphi *phi,
-                         unsigned uninit_opnds,
+			 basic_block use_bb,
+			 gphi *phi,
+			 unsigned uninit_opnds,
 			 pred_chain_union *def_preds,
-                         hash_set<gphi *> *visited_phis);
+			 hash_set<gphi *> *visited_phis);
 
 /* Returns true if all uninitialized opnds are pruned. Returns false
    otherwise. PHI is the phi node with uninitialized operands,
@@ -990,7 +990,7 @@ is_use_properly_guarded (gimple *use_stmt,
    Example scenario:
 
    BB1:
-   flag_1 = phi <0, 1>                  // (1)
+   flag_1 = phi <0, 1>		  // (1)
    var_1  = phi <undef, some_val>
 
 
@@ -1001,7 +1001,7 @@ is_use_properly_guarded (gimple *use_stmt,
       goto BB3;
 
    BB3:
-   use of var_2                         // (3)
+   use of var_2			 // (3)
 
    Because some flag arg in (1) is not constant, if we do not look into the
    flag phis recursively, it is conservatively treated as unknown and var_1
@@ -1027,77 +1027,77 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
       tree flag_arg;
 
       if (!MASK_TEST_BIT (uninit_opnds, i))
-        continue;
+	continue;
 
       flag_arg = gimple_phi_arg_def (flag_def, i);
       if (!is_gimple_constant (flag_arg))
-        {
-          gphi *flag_arg_def, *phi_arg_def;
-          tree phi_arg;
-          unsigned uninit_opnds_arg_phi;
-
-          if (TREE_CODE (flag_arg) != SSA_NAME)
-            return false;
-          flag_arg_def = dyn_cast <gphi *> (SSA_NAME_DEF_STMT (flag_arg));
+	{
+	  gphi *flag_arg_def, *phi_arg_def;
+	  tree phi_arg;
+	  unsigned uninit_opnds_arg_phi;
+
+	  if (TREE_CODE (flag_arg) != SSA_NAME)
+	    return false;
+	  flag_arg_def = dyn_cast <gphi *> (SSA_NAME_DEF_STMT (flag_arg));
 	  if (!flag_arg_def)
-            return false;
+	    return false;
 
-          phi_arg = gimple_phi_arg_def (phi, i);
-          if (TREE_CODE (phi_arg) != SSA_NAME)
-            return false;
+	  phi_arg = gimple_phi_arg_def (phi, i);
+	  if (TREE_CODE (phi_arg) != SSA_NAME)
+	    return false;
 
-          phi_arg_def = dyn_cast <gphi *> (SSA_NAME_DEF_STMT (phi_arg));
+	  phi_arg_def = dyn_cast <gphi *> (SSA_NAME_DEF_STMT (phi_arg));
 	  if (!phi_arg_def)
-            return false;
+	    return false;
 
-          if (gimple_bb (phi_arg_def) != gimple_bb (flag_arg_def))
-            return false;
+	  if (gimple_bb (phi_arg_def) != gimple_bb (flag_arg_def))
+	    return false;
 
-          if (!*visited_flag_phis)
-            *visited_flag_phis = BITMAP_ALLOC (NULL);
+	  if (!*visited_flag_phis)
+	    *visited_flag_phis = BITMAP_ALLOC (NULL);
 
-          if (bitmap_bit_p (*visited_flag_phis,
-                            SSA_NAME_VERSION (gimple_phi_result (flag_arg_def))))
-            return false;
+	  if (bitmap_bit_p (*visited_flag_phis,
+			    SSA_NAME_VERSION (gimple_phi_result (flag_arg_def))))
+	    return false;
 
-          bitmap_set_bit (*visited_flag_phis,
-                          SSA_NAME_VERSION (gimple_phi_result (flag_arg_def)));
+	  bitmap_set_bit (*visited_flag_phis,
+			  SSA_NAME_VERSION (gimple_phi_result (flag_arg_def)));
 
-          /* Now recursively prune the uninitialized phi args.  */
-          uninit_opnds_arg_phi = compute_uninit_opnds_pos (phi_arg_def);
-          if (!prune_uninit_phi_opnds_in_unrealizable_paths
+	  /* Now recursively prune the uninitialized phi args.  */
+	  uninit_opnds_arg_phi = compute_uninit_opnds_pos (phi_arg_def);
+	  if (!prune_uninit_phi_opnds_in_unrealizable_paths
 		 (phi_arg_def, uninit_opnds_arg_phi, flag_arg_def,
 		  boundary_cst, cmp_code, visited_phis, visited_flag_phis))
-            return false;
+	    return false;
 
-          bitmap_clear_bit (*visited_flag_phis,
-                            SSA_NAME_VERSION (gimple_phi_result (flag_arg_def)));
-          continue;
-        }
+	  bitmap_clear_bit (*visited_flag_phis,
+			    SSA_NAME_VERSION (gimple_phi_result (flag_arg_def)));
+	  continue;
+	}
 
       /* Now check if the constant is in the guarded range.  */
       if (is_value_included_in (flag_arg, boundary_cst, cmp_code))
-        {
-          tree opnd;
+	{
+	  tree opnd;
 	  gimple *opnd_def;
 
-          /* Now that we know that this undefined edge is not
-             pruned. If the operand is defined by another phi,
-             we can further prune the incoming edges of that
-             phi by checking the predicates of this operands.  */
-
-          opnd = gimple_phi_arg_def (phi, i);
-          opnd_def = SSA_NAME_DEF_STMT (opnd);
-          if (gphi *opnd_def_phi = dyn_cast <gphi *> (opnd_def))
-            {
-              edge opnd_edge;
-              unsigned uninit_opnds2
-                  = compute_uninit_opnds_pos (opnd_def_phi);
-              pred_chain_union def_preds = vNULL;
-              bool ok;
-              gcc_assert (!MASK_EMPTY (uninit_opnds2));
-              opnd_edge = gimple_phi_arg_edge (phi, i);
-              ok = is_use_properly_guarded (phi,
+	  /* Now that we know that this undefined edge is not
+	     pruned. If the operand is defined by another phi,
+	     we can further prune the incoming edges of that
+	     phi by checking the predicates of this operands.  */
+
+	  opnd = gimple_phi_arg_def (phi, i);
+	  opnd_def = SSA_NAME_DEF_STMT (opnd);
+	  if (gphi *opnd_def_phi = dyn_cast <gphi *> (opnd_def))
+	    {
+	      edge opnd_edge;
+	      unsigned uninit_opnds2
+		  = compute_uninit_opnds_pos (opnd_def_phi);
+	      pred_chain_union def_preds = vNULL;
+	      bool ok;
+	      gcc_assert (!MASK_EMPTY (uninit_opnds2));
+	      opnd_edge = gimple_phi_arg_edge (phi, i);
+	      ok = is_use_properly_guarded (phi,
 					    opnd_edge->src,
 					    opnd_def_phi,
 					    uninit_opnds2,
@@ -1106,10 +1106,10 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
 	      destroy_predicate_vecs (&def_preds);
 	      if (!ok)
 		return false;
-            }
-          else
-            return false;
-        }
+	    }
+	  else
+	    return false;
+	}
     }
 
   return true;
@@ -1119,50 +1119,50 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
    of the use is not overlapping with that of the uninit paths.
    The most common senario of guarded use is in Example 1:
      Example 1:
-           if (some_cond)
-           {
-              x = ...;
-              flag = true;
-           }
+	   if (some_cond)
+	   {
+	      x = ...;
+	      flag = true;
+	   }
 
-            ... some code ...
+	    ... some code ...
 
-           if (flag)
-              use (x);
+	   if (flag)
+	      use (x);
 
      The real world examples are usually more complicated, but similar
      and usually result from inlining:
 
-         bool init_func (int * x)
-         {
-             if (some_cond)
-                return false;
-             *x  =  ..
-             return true;
-         }
+	 bool init_func (int * x)
+	 {
+	     if (some_cond)
+		return false;
+	     *x  =  ..
+	     return true;
+	 }
 
-         void foo(..)
-         {
-             int x;
+	 void foo(..)
+	 {
+	     int x;
 
-             if (!init_func(&x))
-                return;
+	     if (!init_func(&x))
+		return;
 
-             .. some_code ...
-             use (x);
-         }
+	     .. some_code ...
+	     use (x);
+	 }
 
      Another possible use scenario is in the following trivial example:
 
      Example 2:
-          if (n > 0)
-             x = 1;
-          ...
-          if (n > 0)
-            {
-              if (m < 2)
-                 .. = x;
-            }
+	  if (n > 0)
+	     x = 1;
+	  ...
+	  if (n > 0)
+	    {
+	      if (m < 2)
+		 .. = x;
+	    }
 
      Predicate analysis needs to compute the composite predicate:
 
@@ -1173,8 +1173,8 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
        bb and is dominating the operand def.)
 
        and check overlapping:
-          (n > 0) .AND. (m < 2) .AND. (.NOT. (n > 0))
-        <==> false
+	  (n > 0) .AND. (m < 2) .AND. (.NOT. (n > 0))
+	<==> false
 
      This implementation provides framework that can handle
      scenarios. (Note that many simple cases are handled properly
@@ -1191,7 +1191,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gphi *phi,
 
 static bool
 use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds,
-				           gphi *phi, unsigned uninit_opnds,
+					   gphi *phi, unsigned uninit_opnds,
 					   hash_set<gphi *> *visited_phis)
 {
   unsigned int i, n;
@@ -1223,32 +1223,32 @@ use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds,
       cmp_code = the_pred.cond_code;
 
       if (cond_lhs != NULL_TREE && TREE_CODE (cond_lhs) == SSA_NAME
-          && cond_rhs != NULL_TREE && is_gimple_constant (cond_rhs))
-        {
-          boundary_cst = cond_rhs;
-          flag = cond_lhs;
-        }
+	  && cond_rhs != NULL_TREE && is_gimple_constant (cond_rhs))
+	{
+	  boundary_cst = cond_rhs;
+	  flag = cond_lhs;
+	}
       else if (cond_rhs != NULL_TREE && TREE_CODE (cond_rhs) == SSA_NAME
-               && cond_lhs != NULL_TREE && is_gimple_constant (cond_lhs))
-        {
-          boundary_cst = cond_lhs;
-          flag = cond_rhs;
-          swap_cond = true;
-        }
+	       && cond_lhs != NULL_TREE && is_gimple_constant (cond_lhs))
+	{
+	  boundary_cst = cond_lhs;
+	  flag = cond_rhs;
+	  swap_cond = true;
+	}
 
       if (!flag)
-        continue;
+	continue;
 
       flag_def = SSA_NAME_DEF_STMT (flag);
 
       if (!flag_def)
-        continue;
+	continue;
 
       if ((gimple_code (flag_def) == GIMPLE_PHI)
-          && (gimple_bb (flag_def) == gimple_bb (phi))
-          && find_matching_predicate_in_rest_chains (the_pred, preds,
+	  && (gimple_bb (flag_def) == gimple_bb (phi))
+	  && find_matching_predicate_in_rest_chains (the_pred, preds,
 						     num_preds))
-        break;
+	break;
 
       flag_def = 0;
     }
@@ -1264,12 +1264,12 @@ use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds,
     return false;
 
   all_pruned = prune_uninit_phi_opnds_in_unrealizable_paths (phi,
-                                                             uninit_opnds,
-                                                             as_a <gphi *> (flag_def),
-                                                             boundary_cst,
-                                                             cmp_code,
-                                                             visited_phis,
-                                                             &visited_flag_phis);
+							     uninit_opnds,
+							     as_a <gphi *> (flag_def),
+							     boundary_cst,
+							     cmp_code,
+							     visited_phis,
+							     &visited_flag_phis);
 
   if (visited_flag_phis)
     BITMAP_FREE (visited_flag_phis);
@@ -1305,13 +1305,13 @@ static inline bool
 is_neq_relop_p (pred_info pred)
 {
 
-  return (pred.cond_code == NE_EXPR && !pred.invert) 
-          || (pred.cond_code == EQ_EXPR && pred.invert);
+  return (pred.cond_code == NE_EXPR && !pred.invert)
+	  || (pred.cond_code == EQ_EXPR && pred.invert);
 }
 
 /* Returns true if pred is of the form X != 0.  */
 
-static inline bool 
+static inline bool
 is_neq_zero_form_p (pred_info pred)
 {
   if (!is_neq_relop_p (pred) || !integer_zerop (pred.pred_rhs)
@@ -1377,7 +1377,7 @@ is_pred_expr_subset_of (pred_info expr1, pred_info expr2)
 
 static bool
 is_pred_chain_subset_of (pred_chain pred1,
-                         pred_chain pred2)
+			 pred_chain pred2)
 {
   size_t np1, np2, i1, i2;
 
@@ -1389,16 +1389,16 @@ is_pred_chain_subset_of (pred_chain pred1,
       bool found = false;
       pred_info info2 = pred2[i2];
       for (i1 = 0; i1 < np1; i1++)
-        {
-          pred_info info1 = pred1[i1];
-          if (is_pred_expr_subset_of (info1, info2))
-            {
-              found = true;
-              break;
-            }
-        }
+	{
+	  pred_info info1 = pred1[i1];
+	  if (is_pred_expr_subset_of (info1, info2))
+	    {
+	      found = true;
+	      break;
+	    }
+	}
       if (!found)
-        return false;
+	return false;
     }
   return true;
 }
@@ -1421,7 +1421,7 @@ is_included_in (pred_chain one_pred, pred_chain_union preds)
   for (i = 0; i < n; i++)
     {
       if (is_pred_chain_subset_of (one_pred, preds[i]))
-        return true;
+	return true;
     }
 
   return false;
@@ -1452,7 +1452,7 @@ is_superset_of (pred_chain_union preds1, pred_chain_union preds2)
     {
       one_pred_chain = preds2[i];
       if (!is_included_in (one_pred_chain, preds1))
-        return false;
+	return false;
     }
 
   return true;
@@ -1464,8 +1464,8 @@ static inline bool
 is_and_or_or_p (enum tree_code tc, tree type)
 {
   return (tc == BIT_IOR_EXPR
-          || (tc == BIT_AND_EXPR
-              && (type == 0 || TREE_CODE (type) == BOOLEAN_TYPE)));
+	  || (tc == BIT_AND_EXPR
+	      && (type == 0 || TREE_CODE (type) == BOOLEAN_TYPE)));
 }
 
 /* Returns true if X1 is the negate of X2.  */
@@ -1477,7 +1477,7 @@ pred_neg_p (pred_info x1, pred_info x2)
   if (!operand_equal_p (x1.pred_lhs, x2.pred_lhs, 0)
       || !operand_equal_p (x1.pred_rhs, x2.pred_rhs, 0))
     return false;
-      
+
   c1 = x1.cond_code;
   if (x1.invert == x2.invert)
     c2 = invert_tree_comparison (x2.cond_code, false);
@@ -1493,7 +1493,7 @@ pred_neg_p (pred_info x1, pred_info x2)
    4) ((x IAND y) != 0) || (x != 0 AND y != 0)) is equivalent to
       (x != 0 AND y != 0)
    5) (X AND Y) OR (!X AND Z) OR (!Y AND Z) is equivalent to
-      (X AND Y) OR Z 
+      (X AND Y) OR Z
 
    PREDS is the predicate chains, and N is the number of chains.  */
 
@@ -1514,35 +1514,35 @@ simplify_pred (pred_chain *one_chain)
       pred_info *a_pred = &(*one_chain)[i];
 
       if (!a_pred->pred_lhs)
-        continue;
+	continue;
       if (!is_neq_zero_form_p (*a_pred))
-        continue;
+	continue;
 
       gimple *def_stmt = SSA_NAME_DEF_STMT (a_pred->pred_lhs);
       if (gimple_code (def_stmt) != GIMPLE_ASSIGN)
-        continue;
+	continue;
       if (gimple_assign_rhs_code (def_stmt) == BIT_IOR_EXPR)
-        {
-          for (j = 0; j < n; j++)
-            {
-              pred_info *b_pred = &(*one_chain)[j];
-
-              if (!b_pred->pred_lhs)
-                continue;
-              if (!is_neq_zero_form_p (*b_pred))
-                continue;
-
-              if (pred_expr_equal_p (*b_pred, gimple_assign_rhs1 (def_stmt))
-                  || pred_expr_equal_p (*b_pred, gimple_assign_rhs2 (def_stmt)))
-                 {
-                   /* Mark a_pred for removal.  */
-                   a_pred->pred_lhs = NULL;
-                   a_pred->pred_rhs = NULL;
-                   simplified = true;
-                   break;
-                 }
-            }
-        }
+	{
+	  for (j = 0; j < n; j++)
+	    {
+	      pred_info *b_pred = &(*one_chain)[j];
+
+	      if (!b_pred->pred_lhs)
+		continue;
+	      if (!is_neq_zero_form_p (*b_pred))
+		continue;
+
+	      if (pred_expr_equal_p (*b_pred, gimple_assign_rhs1 (def_stmt))
+		  || pred_expr_equal_p (*b_pred, gimple_assign_rhs2 (def_stmt)))
+		 {
+		   /* Mark a_pred for removal.  */
+		   a_pred->pred_lhs = NULL;
+		   a_pred->pred_rhs = NULL;
+		   simplified = true;
+		   break;
+		 }
+	    }
+	}
     }
 
   if (!simplified)
@@ -1552,7 +1552,7 @@ simplify_pred (pred_chain *one_chain)
     {
       pred_info *a_pred = &(*one_chain)[i];
       if (!a_pred->pred_lhs)
-        continue;
+	continue;
       s_chain.safe_push (*a_pred);
     }
 
@@ -1572,7 +1572,7 @@ simplify_preds_2 (pred_chain_union *preds)
   bool simplified = false;
   pred_chain_union s_preds = vNULL;
 
-  /* (X AND Y) OR (!X AND Y) is equivalent to Y.  
+  /* (X AND Y) OR (!X AND Y) is equivalent to Y.
      (X AND Y) OR (X AND !Y) is equivalent to X.  */
 
   n = preds->length ();
@@ -1582,55 +1582,55 @@ simplify_preds_2 (pred_chain_union *preds)
       pred_chain *a_chain = &(*preds)[i];
 
       if (a_chain->length () != 2)
-        continue;
+	continue;
 
       x = (*a_chain)[0];
       y = (*a_chain)[1];
 
       for (j = 0; j < n; j++)
-        {
-          pred_chain *b_chain;
-          pred_info x2, y2;
-
-          if (j == i)
-            continue;
-
-          b_chain = &(*preds)[j];
-          if (b_chain->length () != 2)
-            continue;
-
-          x2 = (*b_chain)[0];
-          y2 = (*b_chain)[1];
-
-          if (pred_equal_p (x, x2) && pred_neg_p (y, y2))
-            {
-              /* Kill a_chain.  */
-              a_chain->release ();
-              b_chain->release ();
-              b_chain->safe_push (x);
-              simplified = true;
-              break;
-            }
-          if (pred_neg_p (x, x2) && pred_equal_p (y, y2))
-            {
-              /* Kill a_chain.  */
-              a_chain->release ();
-              b_chain->release ();
-              b_chain->safe_push (y);
-              simplified = true;
-              break;
-            }
-        }
+	{
+	  pred_chain *b_chain;
+	  pred_info x2, y2;
+
+	  if (j == i)
+	    continue;
+
+	  b_chain = &(*preds)[j];
+	  if (b_chain->length () != 2)
+	    continue;
+
+	  x2 = (*b_chain)[0];
+	  y2 = (*b_chain)[1];
+
+	  if (pred_equal_p (x, x2) && pred_neg_p (y, y2))
+	    {
+	      /* Kill a_chain.  */
+	      a_chain->release ();
+	      b_chain->release ();
+	      b_chain->safe_push (x);
+	      simplified = true;
+	      break;
+	    }
+	  if (pred_neg_p (x, x2) && pred_equal_p (y, y2))
+	    {
+	      /* Kill a_chain.  */
+	      a_chain->release ();
+	      b_chain->release ();
+	      b_chain->safe_push (y);
+	      simplified = true;
+	      break;
+	    }
+	}
     }
   /* Now clean up the chain.  */
   if (simplified)
     {
       for (i = 0; i < n; i++)
-        {
-          if ((*preds)[i].is_empty ())
-            continue;
-          s_preds.safe_push ((*preds)[i]);
-        }
+	{
+	  if ((*preds)[i].is_empty ())
+	    continue;
+	  s_preds.safe_push ((*preds)[i]);
+	}
       preds->release ();
       (*preds) = s_preds;
       s_preds = vNULL;
@@ -1663,34 +1663,34 @@ simplify_preds_3 (pred_chain_union *preds)
       pred_chain *a_chain = &(*preds)[i];
 
       if (a_chain->length () != 1)
-        continue;
+	continue;
 
       x = (*a_chain)[0];
 
       for (j = 0; j < n; j++)
-        {
-          pred_chain *b_chain;
-          pred_info x2;
-          size_t k;
-
-          if (j == i)
-            continue;
-
-          b_chain = &(*preds)[j];
-          if (b_chain->length () < 2)
-            continue;
-
-          for (k = 0; k < b_chain->length (); k++)
-            {
-              x2 = (*b_chain)[k];
-              if (pred_neg_p (x, x2))
-                {
-                  b_chain->unordered_remove (k);
-                  simplified = true;
-                  break;
-                }
-            }
-        }
+	{
+	  pred_chain *b_chain;
+	  pred_info x2;
+	  size_t k;
+
+	  if (j == i)
+	    continue;
+
+	  b_chain = &(*preds)[j];
+	  if (b_chain->length () < 2)
+	    continue;
+
+	  for (k = 0; k < b_chain->length (); k++)
+	    {
+	      x2 = (*b_chain)[k];
+	      if (pred_neg_p (x, x2))
+		{
+		  b_chain->unordered_remove (k);
+		  simplified = true;
+		  break;
+		}
+	    }
+	}
     }
   return simplified;
 }
@@ -1716,59 +1716,59 @@ simplify_preds_4 (pred_chain_union *preds)
       pred_chain *a_chain = &(*preds)[i];
 
       if (a_chain->length () != 1)
-        continue;
+	continue;
 
       z = (*a_chain)[0];
 
       if (!is_neq_zero_form_p (z))
-        continue;
+	continue;
 
       def_stmt = SSA_NAME_DEF_STMT (z.pred_lhs);
       if (gimple_code (def_stmt) != GIMPLE_ASSIGN)
-        continue;
+	continue;
 
       if (gimple_assign_rhs_code (def_stmt) != BIT_AND_EXPR)
-        continue;
+	continue;
 
       for (j = 0; j < n; j++)
-        {
-          pred_chain *b_chain;
-          pred_info x2, y2;
-
-          if (j == i)
-            continue;
-
-          b_chain = &(*preds)[j];
-          if (b_chain->length () != 2)
-            continue;
-
-          x2 = (*b_chain)[0];
-          y2 = (*b_chain)[1];
-          if (!is_neq_zero_form_p (x2)
-              || !is_neq_zero_form_p (y2))
-            continue;
-
-          if ((pred_expr_equal_p (x2, gimple_assign_rhs1 (def_stmt))
-               && pred_expr_equal_p (y2, gimple_assign_rhs2 (def_stmt)))
-              || (pred_expr_equal_p (x2, gimple_assign_rhs2 (def_stmt))
-                  && pred_expr_equal_p (y2, gimple_assign_rhs1 (def_stmt))))
-            {
-              /* Kill a_chain.  */
-              a_chain->release ();
-              simplified = true;
-              break;
-            }
-        }
+	{
+	  pred_chain *b_chain;
+	  pred_info x2, y2;
+
+	  if (j == i)
+	    continue;
+
+	  b_chain = &(*preds)[j];
+	  if (b_chain->length () != 2)
+	    continue;
+
+	  x2 = (*b_chain)[0];
+	  y2 = (*b_chain)[1];
+	  if (!is_neq_zero_form_p (x2)
+	      || !is_neq_zero_form_p (y2))
+	    continue;
+
+	  if ((pred_expr_equal_p (x2, gimple_assign_rhs1 (def_stmt))
+	       && pred_expr_equal_p (y2, gimple_assign_rhs2 (def_stmt)))
+	      || (pred_expr_equal_p (x2, gimple_assign_rhs2 (def_stmt))
+		  && pred_expr_equal_p (y2, gimple_assign_rhs1 (def_stmt))))
+	    {
+	      /* Kill a_chain.  */
+	      a_chain->release ();
+	      simplified = true;
+	      break;
+	    }
+	}
     }
   /* Now clean up the chain.  */
   if (simplified)
     {
       for (i = 0; i < n; i++)
-        {
-          if ((*preds)[i].is_empty ())
-            continue;
-          s_preds.safe_push ((*preds)[i]);
-        }
+	{
+	  if ((*preds)[i].is_empty ())
+	    continue;
+	  s_preds.safe_push ((*preds)[i]);
+	}
 
       destroy_predicate_vecs (preds);
       (*preds) = s_preds;
@@ -1804,15 +1804,15 @@ simplify_preds (pred_chain_union *preds, gimple *use_or_def, bool is_use)
     {
       changed = false;
       if (simplify_preds_2 (preds))
-        changed = true;
+	changed = true;
 
       /* Now iteratively simplify X OR (!X AND Z ..)
        into X OR (Z ...).  */
       if (simplify_preds_3 (preds))
-        changed = true;
+	changed = true;
 
       if (simplify_preds_4 (preds))
-        changed = true;
+	changed = true;
 
     } while (changed);
 
@@ -1821,7 +1821,7 @@ simplify_preds (pred_chain_union *preds, gimple *use_or_def, bool is_use)
 
 /* This is a helper function which attempts to normalize predicate chains
   by following UD chains. It basically builds up a big tree of either IOR
-  operations or AND operations, and convert the IOR tree into a 
+  operations or AND operations, and convert the IOR tree into a
   pred_chain_union or BIT_AND tree into a pred_chain.
   Example:
 
@@ -1846,7 +1846,7 @@ simplify_preds (pred_chain_union *preds, gimple *use_or_def, bool is_use)
 
  then _t != 0 will be normalized into a pred_chain:
    (_2 RELOP1 _1) AND (_5 RELOP2 _4) AND (_8 RELOP3 _7) AND (_0 != 0)
-   
+
   */
 
 /* This is a helper function that stores a PRED into NORM_PREDS.  */
@@ -1864,7 +1864,7 @@ push_pred (pred_chain_union *norm_preds, pred_info pred)
 
 inline static void
 push_to_worklist (tree op, vec<pred_info, va_heap, vl_ptr> *work_list,
-                  hash_set<tree> *mark_set)
+		  hash_set<tree> *mark_set)
 {
   if (mark_set->contains (op))
     return;
@@ -1925,52 +1925,52 @@ is_degenerated_phi (gimple *phi, pred_info *pred_p)
       tree op = gimple_phi_arg_def (phi, i);
 
       if (TREE_CODE (op) != SSA_NAME)
-        return false;
+	return false;
 
       def = SSA_NAME_DEF_STMT (op);
       if (gimple_code (def) != GIMPLE_ASSIGN)
-        return false;
+	return false;
       if (TREE_CODE_CLASS (gimple_assign_rhs_code (def))
-          != tcc_comparison)
-        return false;
+	  != tcc_comparison)
+	return false;
       pred = get_pred_info_from_cmp (def);
       if (!pred_equal_p (pred, pred0))
-        return false;
+	return false;
     }
 
   *pred_p = pred0;
   return true;
 }
 
-/* Normalize one predicate PRED  
+/* Normalize one predicate PRED
    1) if PRED can no longer be normlized, put it into NORM_PREDS.
    2) otherwise if PRED is of the form x != 0, follow x's definition
       and put normalized predicates into WORK_LIST.  */
- 
+
 static void
-normalize_one_pred_1 (pred_chain_union *norm_preds, 
-                      pred_chain *norm_chain,
-                      pred_info pred,
-                      enum tree_code and_or_code,
-                      vec<pred_info, va_heap, vl_ptr> *work_list,
+normalize_one_pred_1 (pred_chain_union *norm_preds,
+		      pred_chain *norm_chain,
+		      pred_info pred,
+		      enum tree_code and_or_code,
+		      vec<pred_info, va_heap, vl_ptr> *work_list,
 		      hash_set<tree> *mark_set)
 {
   if (!is_neq_zero_form_p (pred))
     {
       if (and_or_code == BIT_IOR_EXPR)
-        push_pred (norm_preds, pred);
+	push_pred (norm_preds, pred);
       else
-        norm_chain->safe_push (pred);
+	norm_chain->safe_push (pred);
       return;
     }
 
   gimple *def_stmt = SSA_NAME_DEF_STMT (pred.pred_lhs);
- 
+
   if (gimple_code (def_stmt) == GIMPLE_PHI
       && is_degenerated_phi (def_stmt, &pred))
     work_list->safe_push (pred);
   else if (gimple_code (def_stmt) == GIMPLE_PHI
-           && and_or_code == BIT_IOR_EXPR)
+	   && and_or_code == BIT_IOR_EXPR)
     {
       int i, n;
       n = gimple_phi_num_args (def_stmt);
@@ -1978,23 +1978,23 @@ normalize_one_pred_1 (pred_chain_union *norm_preds,
       /* If we see non zero constant, we should punt. The predicate
        * should be one guarding the phi edge.  */
       for (i = 0; i < n; ++i)
-        {
-          tree op = gimple_phi_arg_def (def_stmt, i);
-          if (TREE_CODE (op) == INTEGER_CST && !integer_zerop (op))
-            {
-              push_pred (norm_preds, pred);
-              return;
-            }
-        }
+	{
+	  tree op = gimple_phi_arg_def (def_stmt, i);
+	  if (TREE_CODE (op) == INTEGER_CST && !integer_zerop (op))
+	    {
+	      push_pred (norm_preds, pred);
+	      return;
+	    }
+	}
 
       for (i = 0; i < n; ++i)
-        {
-          tree op = gimple_phi_arg_def (def_stmt, i);
-          if (integer_zerop (op))
-            continue;
+	{
+	  tree op = gimple_phi_arg_def (def_stmt, i);
+	  if (integer_zerop (op))
+	    continue;
 
-          push_to_worklist (op, work_list, mark_set);
-        }
+	  push_to_worklist (op, work_list, mark_set);
+	}
     }
   else if (gimple_code (def_stmt) != GIMPLE_ASSIGN)
     {
@@ -2047,7 +2047,7 @@ normalize_one_pred_1 (pred_chain_union *norm_preds,
 
 static void
 normalize_one_pred (pred_chain_union *norm_preds,
-                    pred_info pred)
+		    pred_info pred)
 {
   vec<pred_info, va_heap, vl_ptr> work_list = vNULL;
   enum tree_code and_or_code = ERROR_MARK;
@@ -2066,13 +2066,13 @@ normalize_one_pred (pred_chain_union *norm_preds,
       && and_or_code != BIT_AND_EXPR)
     {
       if (TREE_CODE_CLASS (and_or_code)
-          == tcc_comparison)
-        {
-          pred_info n_pred = get_pred_info_from_cmp (def_stmt);
-          push_pred (norm_preds, n_pred);
-        } 
+	  == tcc_comparison)
+	{
+	  pred_info n_pred = get_pred_info_from_cmp (def_stmt);
+	  push_pred (norm_preds, n_pred);
+	}
        else
-          push_pred (norm_preds, pred);
+	  push_pred (norm_preds, pred);
       return;
     }
 
@@ -2083,7 +2083,7 @@ normalize_one_pred (pred_chain_union *norm_preds,
     {
       pred_info a_pred = work_list.pop ();
       normalize_one_pred_1 (norm_preds, &norm_chain, a_pred,
-                            and_or_code, &work_list, &mark_set);
+			    and_or_code, &work_list, &mark_set);
     }
   if (and_or_code == BIT_AND_EXPR)
     norm_preds->safe_push (norm_chain);
@@ -2093,7 +2093,7 @@ normalize_one_pred (pred_chain_union *norm_preds,
 
 static void
 normalize_one_pred_chain (pred_chain_union *norm_preds,
-                          pred_chain one_chain)
+			  pred_chain one_chain)
 {
   vec<pred_info, va_heap, vl_ptr> work_list = vNULL;
   hash_set<tree> mark_set;
@@ -2110,7 +2110,7 @@ normalize_one_pred_chain (pred_chain_union *norm_preds,
     {
       pred_info a_pred = work_list.pop ();
       normalize_one_pred_1 (0, &norm_chain, a_pred,
-                            BIT_AND_EXPR, &work_list, &mark_set);
+			    BIT_AND_EXPR, &work_list, &mark_set);
     }
 
   norm_preds->safe_push (norm_chain);
@@ -2135,12 +2135,12 @@ normalize_preds (pred_chain_union preds, gimple *use_or_def, bool is_use)
   for (i = 0; i < n; i++)
     {
       if (preds[i].length () != 1)
-        normalize_one_pred_chain (&norm_preds, preds[i]);
+	normalize_one_pred_chain (&norm_preds, preds[i]);
       else
-        {
-          normalize_one_pred (&norm_preds, preds[i][0]);
-          preds[i].release ();
-        }
+	{
+	  normalize_one_pred (&norm_preds, preds[i][0]);
+	  preds[i].release ();
+	}
     }
 
   if (dump_file)
@@ -2177,11 +2177,11 @@ normalize_preds (pred_chain_union preds, gimple *use_or_def, bool is_use)
 
 static bool
 is_use_properly_guarded (gimple *use_stmt,
-                         basic_block use_bb,
-                         gphi *phi,
-                         unsigned uninit_opnds,
+			 basic_block use_bb,
+			 gphi *phi,
+			 unsigned uninit_opnds,
 			 pred_chain_union *def_preds,
-                         hash_set<gphi *> *visited_phis)
+			 hash_set<gphi *> *visited_phis)
 {
   basic_block phi_bb;
   pred_chain_union preds = vNULL;
@@ -2249,7 +2249,7 @@ is_use_properly_guarded (gimple *use_stmt,
 
 static gimple *
 find_uninit_use (gphi *phi, unsigned uninit_opnds,
-                 vec<gphi *> *worklist,
+		 vec<gphi *> *worklist,
 		 hash_set<gphi *> *added_to_worklist)
 {
   tree phi_result;
@@ -2281,10 +2281,10 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds,
 	continue;
 
       if (dump_file && (dump_flags & TDF_DETAILS))
-        {
-          fprintf (dump_file, "[CHECK]: Found unguarded use: ");
-          print_gimple_stmt (dump_file, use_stmt, 0, 0);
-        }
+	{
+	  fprintf (dump_file, "[CHECK]: Found unguarded use: ");
+	  print_gimple_stmt (dump_file, use_stmt, 0, 0);
+	}
       /* Found one real use, return.  */
       if (gimple_code (use_stmt) != GIMPLE_PHI)
 	{
@@ -2293,18 +2293,18 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds,
 	}
 
       /* Found a phi use that is not guarded,
-         add the phi to the worklist.  */
+	 add the phi to the worklist.  */
       if (!added_to_worklist->add (as_a <gphi *> (use_stmt)))
-        {
-          if (dump_file && (dump_flags & TDF_DETAILS))
-            {
-              fprintf (dump_file, "[WORKLIST]: Update worklist with phi: ");
-              print_gimple_stmt (dump_file, use_stmt, 0, 0);
-            }
-
-          worklist->safe_push (as_a <gphi *> (use_stmt));
-          possibly_undefined_names->add (phi_result);
-        }
+	{
+	  if (dump_file && (dump_flags & TDF_DETAILS))
+	    {
+	      fprintf (dump_file, "[WORKLIST]: Update worklist with phi: ");
+	      print_gimple_stmt (dump_file, use_stmt, 0, 0);
+	    }
+
+	  worklist->safe_push (as_a <gphi *> (use_stmt));
+	  possibly_undefined_names->add (phi_result);
+	}
     }
 
   destroy_predicate_vecs (&def_preds);
@@ -2321,7 +2321,7 @@ find_uninit_use (gphi *phi, unsigned uninit_opnds,
 
 static void
 warn_uninitialized_phi (gphi *phi, vec<gphi *> *worklist,
-                        hash_set<gphi *> *added_to_worklist)
+			hash_set<gphi *> *added_to_worklist)
 {
   unsigned uninit_opnds;
   gimple *uninit_use_stmt = 0;
@@ -2346,7 +2346,7 @@ warn_uninitialized_phi (gphi *phi, vec<gphi *> *worklist,
 
   /* Now check if we have any use of the value without proper guard.  */
   uninit_use_stmt = find_uninit_use (phi, uninit_opnds,
-                                     worklist, added_to_worklist);
+				     worklist, added_to_worklist);
 
   /* All uses are properly guarded.  */
   if (!uninit_use_stmt)
@@ -2362,8 +2362,8 @@ warn_uninitialized_phi (gphi *phi, vec<gphi *> *worklist,
     loc = UNKNOWN_LOCATION;
   warn_uninit (OPT_Wmaybe_uninitialized, uninit_op, SSA_NAME_VAR (uninit_op),
 	       SSA_NAME_VAR (uninit_op),
-               "%qD may be used uninitialized in this function",
-               uninit_use_stmt, loc);
+	       "%qD may be used uninitialized in this function",
+	       uninit_use_stmt, loc);
 
 }