Fix whitespace.

From-SVN: r115190

gcc/tree-ssa-pre.c

 /* SSA-PRE for trees.
    Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
    Contributed by Daniel Berlin <dan@dberlin.org> and Steven Bosscher
-   <stevenb@suse.de> 
+   <stevenb@suse.de>
 
 This file is part of GCC.
 
@@ -45,7 +45,7 @@ Boston, MA 02110-1301, USA.  */
 #include "cfgloop.h"
 
 /* TODO:
-   
+
    1. Avail sets can be shared by making an avail_find_leader that
       walks up the dominator tree and looks in those avail sets.
       This might affect code optimality, it's unclear right now.
@@ -58,7 +58,7 @@ Boston, MA 02110-1301, USA.  */
       any store in a block, instead of loads that occur before
       stores that affect them.  This is relatively more expensive, and
       it's not clear how much more it will buy us.
-*/   
+*/
 
 /* For ease of terminology, "expression node" in the below refers to
    every expression node but MODIFY_EXPR, because MODIFY_EXPR's represent
@@ -66,7 +66,7 @@ Boston, MA 02110-1301, USA.  */
    we cache the value number by putting it in the expression.  */
 
 /* Basic algorithm
-   
+
    First we walk the statements to generate the AVAIL sets, the
    EXP_GEN sets, and the tmp_gen sets.  EXP_GEN sets represent the
    generation of values/expressions by a given block.  We use them
@@ -77,7 +77,7 @@ Boston, MA 02110-1301, USA.  */
    fixpoint iteration, in order to calculate the AVAIL sets.  In
    traditional parlance, AVAIL sets tell us the downsafety of the
    expressions/values.
-   
+
    Next, we generate the ANTIC sets.  These sets represent the
    anticipatable expressions.  ANTIC is a backwards dataflow
    problem.An expression is anticipatable in a given block if it could
@@ -124,7 +124,7 @@ Boston, MA 02110-1301, USA.  */
    unique number for each value number in use.  This allows
    expressions with SSA_NAMES replaced by value handles to still be
    pretty printed in a sane way.  They simply print as "value.3 *
-   value.5", etc.  
+   value.5", etc.
 
    Expression nodes have value handles associated with them as a
    cache.  Otherwise, we'd have to look them up again in the hash
@@ -132,20 +132,20 @@ Boston, MA 02110-1301, USA.  */
    some test cases.  They can be thrown away after the pass is
    finished.  */
 
-/* Representation of expressions on value numbers: 
+/* Representation of expressions on value numbers:
 
    In some portions of this code, you will notice we allocate "fake"
    analogues to the expression we are value numbering, and replace the
    operands with the values of the expression.  Since we work on
    values, and not just names, we canonicalize expressions to value
-   expressions for use in the ANTIC sets, the EXP_GEN set, etc.  
+   expressions for use in the ANTIC sets, the EXP_GEN set, etc.
 
    This is theoretically unnecessary, it just saves a bunch of
    repeated get_value_handle and find_leader calls in the remainder of
    the code, trading off temporary memory usage for speed.  The tree
    nodes aren't actually creating more garbage, since they are
    allocated in a special pools which are thrown away at the end of
-   this pass.  
+   this pass.
 
    All of this also means that if you print the EXP_GEN or ANTIC sets,
    you will see "value.5 + value.7" in the set, instead of "a_55 +
@@ -163,7 +163,7 @@ Boston, MA 02110-1301, USA.  */
    and thus, are simply represented as two bitmaps, one that keeps
    track of values present in the set, and one that keeps track of
    expressions present in the set.
-   
+
    The other sets are represented as doubly linked lists kept in topological
    order, with an optional supporting bitmap of values present in the
    set.  The sets represent values, and the elements can be values or
@@ -205,19 +205,19 @@ typedef struct value_set
      necessary to keep the set in topologically sorted order because
      of how the set is built.  */
   value_set_node_t tail;
-  
+
   /* The length of the list.  */
   size_t length;
-  
+
   /* True if the set is indexed, which means it contains a backing
      bitmap for quick determination of whether certain values exist in the
      set.  */
   bool indexed;
-  
+
   /* The bitmap of values that exist in the set.  May be NULL in an
      empty or non-indexed set.  */
   bitmap values;
-  
+
 } *value_set_t;
 
 
@@ -294,10 +294,10 @@ static struct
 
   /* The number of new PHI nodes added by PRE.  */
   int phis;
-  
+
   /* The number of values found constant.  */
   int constified;
-  
+
 } pre_stats;
 
 
@@ -393,7 +393,7 @@ expr_pred_trans_eq (const void *p1, const void *p2)
   basic_block b2 = ve2->pred;
   int i;
   tree vuse1;
-  
+
   /* If they are not translations for the same basic block, they can't
      be equal.  */
   if (b1 != b2)
@@ -401,14 +401,14 @@ expr_pred_trans_eq (const void *p1, const void *p2)
 
 
   /* If they are for the same basic block, determine if the
-     expressions are equal.  */  
+     expressions are equal.  */
   if (!expressions_equal_p (ve1->e, ve2->e))
     return false;
 
   /* Make sure the vuses are equivalent.  */
   if (ve1->vuses == ve2->vuses)
     return true;
-  
+
   if (VEC_length (tree, ve1->vuses) != VEC_length (tree, ve2->vuses))
     return false;
 
@@ -524,7 +524,7 @@ value_insert_into_set_bitmap (value_set_t set, tree v)
 
 /* Create a new bitmap set and return it.  */
 
-static bitmap_set_t 
+static bitmap_set_t
 bitmap_set_new (void)
 {
   bitmap_set_t ret = (bitmap_set_t) pool_alloc (bitmap_set_pool);
@@ -556,7 +556,7 @@ bitmap_insert_into_set (bitmap_set_t set, tree expr)
   /* XXX: For now, we only let SSA_NAMES into the bitmap sets.  */
   gcc_assert (TREE_CODE (expr) == SSA_NAME);
   val = get_value_handle (expr);
-  
+
   gcc_assert (val);
   if (!is_gimple_min_invariant (val))
   {
@@ -573,7 +573,7 @@ insert_into_set (value_set_t set, tree expr)
   value_set_node_t newnode = (value_set_node_t) pool_alloc (value_set_node_pool);
   tree val = get_value_handle (expr);
   gcc_assert (val);
-  
+
   if (is_gimple_min_invariant (val))
     return;
 
@@ -661,7 +661,7 @@ static void
 set_copy (value_set_t dest, value_set_t orig)
 {
   value_set_node_t node;
- 
+
   if (!orig || !orig->head)
     return;
 
@@ -681,12 +681,12 @@ set_remove (value_set_t set, tree expr)
   value_set_node_t node, prev;
 
   /* Remove the value of EXPR from the bitmap, decrement the set
-     length, and remove it from the actual double linked list.  */ 
+     length, and remove it from the actual double linked list.  */
   value_remove_from_set_bitmap (set, get_value_handle (expr));
   set->length--;
   prev = NULL;
-  for (node = set->head; 
-       node != NULL; 
+  for (node = set->head;
+       node != NULL;
        prev = node, node = node->next)
     {
       if (node->expr == expr)
@@ -695,7 +695,7 @@ set_remove (value_set_t set, tree expr)
 	    set->head = node->next;
 	  else
 	    prev->next= node->next;
- 
+
 	  if (node == set->tail)
 	    set->tail = prev;
 	  pool_free (value_set_node_pool, node);
@@ -712,10 +712,10 @@ set_contains_value (value_set_t set, tree val)
   /* All constants are in every set.  */
   if (is_gimple_min_invariant (val))
     return true;
-  
+
   if (!set || set->length == 0)
     return false;
-  
+
   return value_exists_in_set_bitmap (set, val);
 }
 
@@ -733,7 +733,7 @@ bitmap_set_contains (bitmap_set_t set, tree expr)
   return bitmap_bit_p (set->expressions, SSA_NAME_VERSION (expr));
 }
 
-  
+
 /* Return true if bitmapped set SET contains the value VAL.  */
 
 static bool
@@ -840,7 +840,7 @@ bitmap_value_insert_into_set (bitmap_set_t set, tree expr)
 
   if (is_gimple_min_invariant (val))
     return;
-  
+
   if (!bitmap_set_contains_value (set, val))
     bitmap_insert_into_set (set, expr);
 }
@@ -881,7 +881,7 @@ bitmap_print_value_set (FILE *outfile, bitmap_set_t set,
 	    fprintf (outfile, ", ");
 	  first = false;
 	  print_generic_expr (outfile, ssa_name (i), 0);
-	
+
 	  fprintf (outfile, " (");
 	  print_generic_expr (outfile, get_value_handle (ssa_name (i)), 0);
 	  fprintf (outfile, ") ");
@@ -904,11 +904,11 @@ print_value_set (FILE *outfile, value_set_t set,
 	   node = node->next)
 	{
 	  print_generic_expr (outfile, node->expr, 0);
-	  
+
 	  fprintf (outfile, " (");
 	  print_generic_expr (outfile, get_value_handle (node->expr), 0);
 	  fprintf (outfile, ") ");
-		     
+
 	  if (node->next)
 	    fprintf (outfile, ", ");
 	}
@@ -937,7 +937,7 @@ debug_value_expressions (tree val)
   print_value_expressions (stderr, val);
 }
 
-  
+
 void debug_value_set (value_set_t, const char *, int);
 
 void
@@ -947,11 +947,11 @@ debug_value_set (value_set_t set, const char *setname, int blockindex)
 }
 
 /* Return the folded version of T if T, when folded, is a gimple
-   min_invariant.  Otherwise, return T.  */ 
+   min_invariant.  Otherwise, return T.  */
 
 static tree
 fully_constant_expression (tree t)
-{  
+{
   tree folded;
   folded = fold (t);
   if (folded && is_gimple_min_invariant (folded))
@@ -960,7 +960,7 @@ fully_constant_expression (tree t)
 }
 
 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
-   For example, this can copy a list made of TREE_LIST nodes.  
+   For example, this can copy a list made of TREE_LIST nodes.
    Allocates the nodes in list_node_pool*/
 
 static tree
@@ -972,10 +972,10 @@ pool_copy_list (tree list)
   if (list == 0)
     return 0;
   head = (tree) pool_alloc (list_node_pool);
-  
+
   memcpy (head, list, tree_size (list));
   prev = head;
-  
+
   next = TREE_CHAIN (list);
   while (next)
     {
@@ -1055,7 +1055,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 
   if (phitrans)
     return phitrans;
-  
+
   switch (TREE_CODE_CLASS (TREE_CODE (expr)))
     {
     case tcc_expression:
@@ -1083,8 +1083,8 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	       as one value number, because that doesn't make much
 	       sense, and just breaks the support functions we call,
 	       which expect TREE_OPERAND (call_expr, 2) to be a
-	       TREE_LIST. */	      
-	    
+	       TREE_LIST. */
+
 	    newop0 = phi_translate (find_leader (set, oldop0),
 				    set, pred, phiblock);
 	    if (newop0 == NULL)
@@ -1098,7 +1098,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	      }
 
 	    /* phi translate the argument list piece by piece.
-	       
+
 	      We could actually build the list piece by piece here,
 	      but it's likely to not be worth the memory we will save,
 	      unless you have millions of call arguments.  */
@@ -1106,10 +1106,10 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	    newarglist = pool_copy_list (oldarglist);
 	    for (oldwalker = oldarglist, newwalker = newarglist;
 		 oldwalker && newwalker;
-		 oldwalker = TREE_CHAIN (oldwalker), 
+		 oldwalker = TREE_CHAIN (oldwalker),
 		   newwalker = TREE_CHAIN (newwalker))
 	      {
-		
+
 		tree oldval = TREE_VALUE (oldwalker);
 		tree newval;
 		if (oldval)
@@ -1139,7 +1139,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	      }
 	    if (listchanged)
 	      vn_lookup_or_add (newarglist, NULL);
-	    
+
 	    tvuses = translate_vuses_through_block (vuses, pred);
 
 	    if (listchanged || (newop0 != oldop0) || (oldop2 != newop2)
@@ -1150,7 +1150,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 		TREE_OPERAND (newexpr, 0) = newop0 == oldop0 ? oldop0 : get_value_handle (newop0);
 		TREE_OPERAND (newexpr, 1) = listchanged ? newarglist : oldarglist;
 		TREE_OPERAND (newexpr, 2) = newop2 == oldop2 ? oldop2 : get_value_handle (newop2);
-		create_tree_ann (newexpr);	 
+		create_tree_ann (newexpr);
 		vn_lookup_or_add_with_vuses (newexpr, tvuses);
 		expr = newexpr;
 		phi_trans_add (oldexpr, newexpr, pred, tvuses);
@@ -1198,13 +1198,13 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 				set, pred, phiblock);
 	if (newop0 == NULL)
 	  return NULL;
-	
+
 	if (TREE_CODE (expr) == ARRAY_REF)
 	  {
 	    oldop1 = TREE_OPERAND (expr, 1);
 	    newop1 = phi_translate (find_leader (set, oldop1),
 				    set, pred, phiblock);
-	
+
 	    if (newop1 == NULL)
 	      return NULL;
 	    oldop2 = TREE_OPERAND (expr, 2);
@@ -1212,7 +1212,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	      {
 		newop2 = phi_translate (find_leader (set, oldop2),
 					set, pred, phiblock);
-	    
+
 		if (newop2 == NULL)
 		  return NULL;
 	      }
@@ -1221,7 +1221,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	      {
 		newop3 = phi_translate (find_leader (set, oldop3),
 					set, pred, phiblock);
-		
+
 		if (newop3 == NULL)
 		  return NULL;
 	      }
@@ -1230,10 +1230,10 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	oldvuses = VALUE_HANDLE_VUSES (get_value_handle (expr));
 	if (oldvuses)
 	  newvuses = translate_vuses_through_block (oldvuses, pred);
-	
+
 	if (newop0 != oldop0 || newvuses != oldvuses
-	    || newop1 != oldop1 
-	    || newop2 != oldop2 
+	    || newop1 != oldop1
+	    || newop2 != oldop2
 	    || newop3 != oldop3)
 	  {
 	    tree t;
@@ -1277,7 +1277,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	tree newop1;
 	tree newop2;
 	tree newexpr;
-	
+
 	newop1 = phi_translate (find_leader (set, oldop1),
 				set, pred, phiblock);
 	if (newop1 == NULL)
@@ -1301,7 +1301,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	      }
 	    else
 	      {
-		create_tree_ann (newexpr);	 
+		create_tree_ann (newexpr);
 		vn_lookup_or_add (newexpr, NULL);
 	      }
 	    expr = newexpr;
@@ -1334,7 +1334,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	      }
 	    else
 	      {
-		create_tree_ann (newexpr);	 
+		create_tree_ann (newexpr);
 		vn_lookup_or_add (newexpr, NULL);
 	      }
 	    expr = newexpr;
@@ -1352,7 +1352,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
 	  phi = SSA_NAME_DEF_STMT (expr);
 	else
 	  return expr;
-	
+
 	e = find_edge (pred, bb_for_stmt (phi));
 	if (e)
 	  {
@@ -1383,7 +1383,7 @@ phi_translate_set (value_set_t dest, value_set_t set, basic_block pred,
        node = node->next)
     {
       tree translated;
-      
+
       translated = phi_translate (node->expr, set, pred, phiblock);
 
       /* Don't add constants or empty translations to the cache, since
@@ -1392,7 +1392,7 @@ phi_translate_set (value_set_t dest, value_set_t set, basic_block pred,
 	{
 	  tree vh = get_value_handle (translated);
 	  VEC (tree, gc) *vuses;
-	  
+
 	  /* The value handle itself may also be an invariant, in
 	     which case, it has no vuses.  */
 	  vuses = !is_gimple_min_invariant (vh)
@@ -1402,7 +1402,7 @@ phi_translate_set (value_set_t dest, value_set_t set, basic_block pred,
 
       if (translated != NULL)
 	value_insert_into_set (dest, translated);
-    } 
+    }
 }
 
 /* Find the leader for a value (i.e., the name representing that
@@ -1414,7 +1414,7 @@ bitmap_find_leader (bitmap_set_t set, tree val)
 {
   if (val == NULL)
     return NULL;
-  
+
   if (is_gimple_min_invariant (val))
     return val;
   if (bitmap_set_contains_value (set, val))
@@ -1429,7 +1429,7 @@ bitmap_find_leader (bitmap_set_t set, tree val)
 	 large testcases, doing it this way is roughly 5-10x faster
 	 than walking the bitmap.
 	 If this is somehow a significant lose for some cases, we can
-	 choose which set to walk based on which set is smaller.  */	 
+	 choose which set to walk based on which set is smaller.  */
       value_set_t exprset;
       value_set_node_t node;
       exprset = VALUE_HANDLE_EXPR_SET (val);
@@ -1437,7 +1437,7 @@ bitmap_find_leader (bitmap_set_t set, tree val)
 	{
 	  if (TREE_CODE (node->expr) == SSA_NAME)
 	    {
-	      if (bitmap_bit_p (set->expressions, 
+	      if (bitmap_bit_p (set->expressions,
 				SSA_NAME_VERSION (node->expr)))
 		return node->expr;
 	    }
@@ -1446,7 +1446,7 @@ bitmap_find_leader (bitmap_set_t set, tree val)
   return NULL;
 }
 
-	
+
 /* Find the leader for a value (i.e., the name representing that
    value) in a given set, and return it.  Return NULL if no leader is
    found.  */
@@ -1465,7 +1465,7 @@ find_leader (value_set_t set, tree val)
 
   if (set->length == 0)
     return NULL;
-  
+
   if (value_exists_in_set_bitmap (set, val))
     {
       for (node = set->head;
@@ -1517,7 +1517,7 @@ vuses_dies_in_block_x (VEC (tree, gc) *vuses, basic_block block)
 
 /* Determine if the expression EXPR is valid in SET.  This means that
    we have a leader for each part of the expression (if it consists of
-   values), or the expression is an SSA_NAME.  
+   values), or the expression is an SSA_NAME.
 
    NB: We never should run into a case where we have SSA_NAME +
    SSA_NAME or SSA_NAME + value.  The sets valid_in_set is called on,
@@ -1543,7 +1543,7 @@ valid_in_set (value_set_t set, tree expr, basic_block block)
 	tree op1 = TREE_OPERAND (expr, 0);
 	return set_contains_value (set, op1);
       }
-      
+
     case tcc_expression:
       {
 	if (TREE_CODE (expr) == CALL_EXPR)
@@ -1567,10 +1567,10 @@ valid_in_set (value_set_t set, tree expr, basic_block block)
 	  }
 	return false;
       }
-      
+
     case tcc_reference:
       {
-	if (TREE_CODE (expr) == INDIRECT_REF 
+	if (TREE_CODE (expr) == INDIRECT_REF
 	    || TREE_CODE (expr) == COMPONENT_REF
             || TREE_CODE (expr) == ARRAY_REF)
 	  {
@@ -1616,7 +1616,7 @@ valid_in_set (value_set_t set, tree expr, basic_block block)
 
     default:
       /* No other cases should be encountered.  */
-      gcc_unreachable (); 
+      gcc_unreachable ();
    }
 }
 
@@ -1633,7 +1633,7 @@ clean (value_set_t set, basic_block block)
   while (node)
     {
       next = node->next;
-      if (!valid_in_set (set, node->expr, block))	
+      if (!valid_in_set (set, node->expr, block))
 	set_remove (set, node->expr);
       node = next;
     }
@@ -1721,7 +1721,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
   S = bitmap_set_subtract_from_value_set (ANTIC_OUT, TMP_GEN (block), false);
 
   /* Start ANTIC_IN with EXP_GEN - TMP_GEN */
-  ANTIC_IN (block) = bitmap_set_subtract_from_value_set (EXP_GEN (block), 
+  ANTIC_IN (block) = bitmap_set_subtract_from_value_set (EXP_GEN (block),
 							 TMP_GEN (block),
 							 true);
 
@@ -1741,7 +1741,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
 	print_value_set (dump_file, ANTIC_OUT, "ANTIC_OUT", block->index);
 
       if (ANTIC_SAFE_LOADS (block))
-	print_value_set (dump_file, ANTIC_SAFE_LOADS (block), 
+	print_value_set (dump_file, ANTIC_SAFE_LOADS (block),
 			 "ANTIC_SAFE_LOADS", block->index);
       print_value_set (dump_file, ANTIC_IN (block), "ANTIC_IN", block->index);
 
@@ -1904,11 +1904,11 @@ compute_vuse_representatives (void)
    uses, and virtual uses *do* actually die, this ends up being faster
    in most cases than continually walking the virtual use/def chains
    to determine whether we are inside a block where a given virtual is
-   still available to be used.  
+   still available to be used.
 
    ANTIC_SAFE_LOADS are those loads that actually occur before any kill to
    their vuses in the block,and thus, are safe at the top of the
-   block.  
+   block.
 
    An example:
 
@@ -1916,7 +1916,7 @@ compute_vuse_representatives (void)
    b = *a
    *a = 9
    <block end>
-   
+
    b = *a is an antic safe load because it still safe to consider it
    ANTIC at the top of the block.
 
@@ -1939,7 +1939,7 @@ compute_rvuse_and_antic_safe (void)
   unsigned int *first_store_uid;
 
   first_store_uid = xcalloc (n_basic_blocks, sizeof (unsigned int));
-  
+
   compute_vuse_representatives ();
 
   FOR_ALL_BB (bb)
@@ -1976,14 +1976,14 @@ compute_rvuse_and_antic_safe (void)
       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
 	{
 	  tree stmt = bsi_stmt (bsi);
-	  
-	  if (first_store_uid[bb->index] == 0 
-	      && !ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYUSE | SSA_OP_VMAYDEF 
+
+	  if (first_store_uid[bb->index] == 0
+	      && !ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYUSE | SSA_OP_VMAYDEF
 				     | SSA_OP_VMUSTDEF | SSA_OP_VMUSTKILL))
 	    {
 	      first_store_uid[bb->index] = stmt_ann (stmt)->uid;
 	    }
-	  
+
 
 	  FOR_EACH_SSA_USE_OPERAND (usep, stmt, iter, SSA_OP_VIRTUAL_KILLS
 				    | SSA_OP_VMAYUSE)
@@ -2079,31 +2079,31 @@ compute_rvuse_and_antic_safe (void)
     }
 
   FOR_EACH_BB (bb)
-    {      
+    {
       value_set_node_t node;
       if (bitmap_empty_p (RVUSE_KILL (bb)))
 	continue;
-      
+
       for (node = EXP_GEN (bb)->head; node; node = node->next)
 	{
 	  if (REFERENCE_CLASS_P (node->expr))
 	    {
 	      tree vh = get_value_handle (node->expr);
 	      tree maybe = bitmap_find_leader (AVAIL_OUT (bb), vh);
-	      
+
 	      if (maybe)
 		{
 		  tree def = SSA_NAME_DEF_STMT (maybe);
 
 		  if (bb_for_stmt (def) != bb)
 		    continue;
-		  
+
 		  if (TREE_CODE (def) == PHI_NODE
 		      || stmt_ann (def)->uid < first_store_uid[bb->index])
 		    {
 		      if (ANTIC_SAFE_LOADS (bb) == NULL)
 			ANTIC_SAFE_LOADS (bb) = set_new (true);
-		      value_insert_into_set (ANTIC_SAFE_LOADS (bb), 
+		      value_insert_into_set (ANTIC_SAFE_LOADS (bb),
 					     node->expr);
 		    }
 		}
@@ -2176,7 +2176,7 @@ static VEC(tree, heap) *need_creation;
    Thus, this routine doesn't create temporaries, it just builds a
    single access expression for the array, calling
    find_or_generate_expression to build the innermost pieces.
-   
+
    This function is a subroutine of create_expression_by_pieces, and
    should not be called on it's own unless you really know what you
    are doing.
@@ -2193,7 +2193,7 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
       if (found)
 	return found;
     }
-  
+
   if (TREE_CODE (genop) == VALUE_HANDLE)
     genop = VALUE_HANDLE_EXPR_SET (expr)->head->expr;
 
@@ -2203,7 +2203,7 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
       {
 	tree op0;
 	tree op1, op2, op3;
-	op0 = create_component_ref_by_pieces (block, 
+	op0 = create_component_ref_by_pieces (block,
 					      TREE_OPERAND (genop, 0),
 					      stmts);
 	op1 = TREE_OPERAND (genop, 1);
@@ -2215,7 +2215,7 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
 	op3 = TREE_OPERAND (genop, 3);
 	if (op3 && TREE_CODE (op3) == VALUE_HANDLE)
 	  op3 = find_or_generate_expression (block, op3, stmts);
-	folded = build4 (ARRAY_REF, TREE_TYPE (genop), op0, op1, 
+	folded = build4 (ARRAY_REF, TREE_TYPE (genop), op0, op1,
 			      op2, op3);
 	return folded;
       }
@@ -2223,11 +2223,11 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
       {
 	tree op0;
 	tree op1;
-	op0 = create_component_ref_by_pieces (block, 
+	op0 = create_component_ref_by_pieces (block,
 					      TREE_OPERAND (genop, 0),
 					      stmts);
 	op1 = VALUE_HANDLE_EXPR_SET (TREE_OPERAND (genop, 1))->head->expr;
-	folded = fold_build3 (COMPONENT_REF, TREE_TYPE (genop), op0, op1, 
+	folded = fold_build3 (COMPONENT_REF, TREE_TYPE (genop), op0, op1,
 			      NULL_TREE);
 	return folded;
       }
@@ -2236,7 +2236,7 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
       {
 	tree op1 = TREE_OPERAND (genop, 0);
 	tree genop1 = find_or_generate_expression (block, op1, stmts);
-	
+
 	folded = fold_build1 (TREE_CODE (genop), TREE_TYPE (genop),
 			      genop1);
 	return folded;
@@ -2249,7 +2249,7 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
     case STRING_CST:
       return genop;
     default:
-      gcc_unreachable ();      
+      gcc_unreachable ();
     }
 
   return NULL_TREE;
@@ -2257,9 +2257,9 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
 
 /* Find a leader for an expression, or generate one using
    create_expression_by_pieces if it's ANTIC but
-   complex.  
+   complex.
    BLOCK is the basic_block we are looking for leaders in.
-   EXPR is the expression to find a leader or generate for. 
+   EXPR is the expression to find a leader or generate for.
    STMTS is the statement list to put the inserted expressions on.
    Returns the SSA_NAME of the LHS of the generated expression or the
    leader.  */
@@ -2281,9 +2281,9 @@ find_or_generate_expression (basic_block block, tree expr, tree stmts)
   return genop;
 }
 
-#define NECESSARY(stmt)		stmt->common.asm_written_flag  
+#define NECESSARY(stmt)		stmt->common.asm_written_flag
 /* Create an expression in pieces, so that we can handle very complex
-   expressions that may be ANTIC, but not necessary GIMPLE.  
+   expressions that may be ANTIC, but not necessary GIMPLE.
    BLOCK is the basic block the expression will be inserted into,
    EXPR is the expression to insert (in value form)
    STMTS is a statement list to append the necessary insertions into.
@@ -2313,14 +2313,14 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
 	tree genop0, genop2;
 	tree genarglist;
 	tree walker, genwalker;
-	
+
 	gcc_assert (TREE_CODE (expr) == CALL_EXPR);
 	genop2 = NULL;
-	
+
 	op0 = TREE_OPERAND (expr, 0);
 	arglist = TREE_OPERAND (expr, 1);
 	op2 = TREE_OPERAND (expr, 2);
-	
+
 	genop0 = find_or_generate_expression (block, op0, stmts);
 	genarglist = copy_list (arglist);
 	for (walker = arglist, genwalker = genarglist;
@@ -2332,13 +2332,13 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
 					     stmts);
 	  }
 
-	if (op2)	  
+	if (op2)
 	  genop2 = find_or_generate_expression (block, op2, stmts);
 	folded = fold_build3 (TREE_CODE (expr), TREE_TYPE (expr),
 			      genop0, genarglist, genop2);
 	break;
-	
-	
+
+
       }
       break;
     case tcc_reference:
@@ -2352,13 +2352,13 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
 	  {
 	    tree op1 = TREE_OPERAND (expr, 0);
 	    tree genop1 = find_or_generate_expression (block, op1, stmts);
-	    
+
 	    folded = fold_build1 (TREE_CODE (expr), TREE_TYPE (expr),
 				  genop1);
 	  }
 	break;
       }
-      
+
     case tcc_binary:
     case tcc_comparison:
       {
@@ -2366,7 +2366,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
 	tree op2 = TREE_OPERAND (expr, 1);
 	tree genop1 = find_or_generate_expression (block, op1, stmts);
 	tree genop2 = find_or_generate_expression (block, op2, stmts);
-	folded = fold_build2 (TREE_CODE (expr), TREE_TYPE (expr), 
+	folded = fold_build2 (TREE_CODE (expr), TREE_TYPE (expr),
 			      genop1, genop2);
 	break;
       }
@@ -2375,7 +2375,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
       {
 	tree op1 = TREE_OPERAND (expr, 0);
 	tree genop1 = find_or_generate_expression (block, op1, stmts);
-	folded = fold_build1 (TREE_CODE (expr), TREE_TYPE (expr), 
+	folded = fold_build1 (TREE_CODE (expr), TREE_TYPE (expr),
 			      genop1);
 	break;
       }
@@ -2388,7 +2388,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
      statements.
      We have to call unshare_expr because force_gimple_operand may
      modify the tree we pass to it.  */
-  newexpr = force_gimple_operand (unshare_expr (folded), &forced_stmts, 
+  newexpr = force_gimple_operand (unshare_expr (folded), &forced_stmts,
                                   false, NULL);
 
   /* If we have any intermediate expressions to the value sets, add them
@@ -2402,7 +2402,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
 	  tree forcedname = TREE_OPERAND (stmt, 0);
 	  tree forcedexpr = TREE_OPERAND (stmt, 1);
 	  tree val = vn_lookup_or_add (forcedexpr, NULL);
-	  
+
 	  VEC_safe_push (tree, heap, inserted_exprs, stmt);
 	  vn_add (forcedname, val);
 	  bitmap_value_replace_in_set (NEW_SETS (block), forcedname);
@@ -2444,12 +2444,12 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
      here.  */
   v = get_value_handle (expr);
   vn_add (name, v);
-  bitmap_value_replace_in_set (NEW_SETS (block), name); 
+  bitmap_value_replace_in_set (NEW_SETS (block), name);
   bitmap_value_replace_in_set (AVAIL_OUT (block), name);
 
   pre_stats.insertions++;
   if (dump_file && (dump_flags & TDF_DETAILS))
-    {				    
+    {
       fprintf (dump_file, "Inserted ");
       print_generic_expr (dump_file, newexpr, 0);
       fprintf (dump_file, " in predecessor %d\n", block->index);
@@ -2476,7 +2476,7 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
   edge_iterator ei;
   tree type = TREE_TYPE (avail[EDGE_PRED (block, 0)->src->index]);
   tree temp;
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "Found partial redundancy for expression ");
@@ -2493,7 +2493,7 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
     {
       bool firstinsideloop = false;
       bool secondinsideloop = false;
-      firstinsideloop = flow_bb_inside_loop_p (block->loop_father, 
+      firstinsideloop = flow_bb_inside_loop_p (block->loop_father,
 					       EDGE_PRED (block, 0)->src);
       secondinsideloop = flow_bb_inside_loop_p (block->loop_father,
 						EDGE_PRED (block, 1)->src);
@@ -2505,7 +2505,7 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
 	  nophi = true;
 	}
     }
-	  
+
 
   /* Make the necessary insertions.  */
   FOR_EACH_EDGE (pred, ei, block->preds)
@@ -2521,7 +2521,7 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
 	  tree vh;
 
 	  /* eprime may be an invariant.  */
-	  vh = TREE_CODE (eprime) == VALUE_HANDLE 
+	  vh = TREE_CODE (eprime) == VALUE_HANDLE
 	    ? eprime
 	    : get_value_handle (eprime);
 
@@ -2546,7 +2546,7 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
 	  bsi_insert_on_edge (pred, stmts);
 	  avail[bprime->index] = builtexpr;
 	  insertions = true;
-	}			      
+	}
     }
   /* If we didn't want a phi node, and we made insertions, we still have
      inserted new stuff, and thus return true.  If we didn't want a phi node,
@@ -2571,22 +2571,22 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
     DECL_COMPLEX_GIMPLE_REG_P (temp) = 1;
   temp = create_phi_node (temp, block);
 
-  NECESSARY (temp) = 0; 
+  NECESSARY (temp) = 0;
   VEC_safe_push (tree, heap, inserted_exprs, temp);
   FOR_EACH_EDGE (pred, ei, block->preds)
     add_phi_arg (temp, avail[pred->src->index], pred);
-  
+
   vn_add (PHI_RESULT (temp), val);
-  
+
   /* The value should *not* exist in PHI_GEN, or else we wouldn't be doing
      this insertion, since we test for the existence of this value in PHI_GEN
      before proceeding with the partial redundancy checks in insert_aux.
-     
+
      The value may exist in AVAIL_OUT, in particular, it could be represented
      by the expression we are trying to eliminate, in which case we want the
      replacement to occur.  If it's not existing in AVAIL_OUT, we want it
      inserted there.
-     
+
      Similarly, to the PHI_GEN case, the value should not exist in NEW_SETS of
      this block, because if it did, it would have existed in our dominator's
      AVAIL_OUT, and would have been skipped due to the full redundancy check.
@@ -2594,11 +2594,11 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
 
   bitmap_insert_into_set (PHI_GEN (block),
 			  PHI_RESULT (temp));
-  bitmap_value_replace_in_set (AVAIL_OUT (block), 
+  bitmap_value_replace_in_set (AVAIL_OUT (block),
 			       PHI_RESULT (temp));
   bitmap_insert_into_set (NEW_SETS (block),
 			  PHI_RESULT (temp));
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "Created phi ");
@@ -2610,18 +2610,18 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
 }
 
 
-      
+
 /* Perform insertion of partially redundant values.
    For BLOCK, do the following:
    1.  Propagate the NEW_SETS of the dominator into the current block.
-   If the block has multiple predecessors, 
+   If the block has multiple predecessors,
        2a. Iterate over the ANTIC expressions for the block to see if
            any of them are partially redundant.
        2b. If so, insert them into the necessary predecessors to make
            the expression fully redundant.
        2c. Insert a new PHI merging the values of the predecessors.
        2d. Insert the new PHI, and the new expressions, into the
-           NEW_SETS set.  
+           NEW_SETS set.
    3. Recursively call ourselves on the dominator children of BLOCK.
 
 */
@@ -2676,14 +2676,14 @@ insert_aux (basic_block block)
 
 		      val = get_value_handle (node->expr);
 		      if (bitmap_set_contains_value (PHI_GEN (block), val))
-			continue; 
+			continue;
 		      if (bitmap_set_contains_value (AVAIL_OUT (dom), val))
 			{
 			  if (dump_file && (dump_flags & TDF_DETAILS))
 			    fprintf (dump_file, "Found fully redundant value\n");
 			  continue;
 			}
-					      
+
 		      avail = XCNEWVEC (tree, last_basic_block);
 		      FOR_EACH_EDGE (pred, ei, block->preds)
 			{
@@ -2731,7 +2731,7 @@ insert_aux (basic_block block)
 			  else
 			    {
 			      avail[bprime->index] = edoubleprime;
-			      by_some = true; 
+			      by_some = true;
 			      if (first_s == NULL)
 				first_s = edoubleprime;
 			      else if (!operand_equal_p (first_s, edoubleprime,
@@ -2751,7 +2751,7 @@ insert_aux (basic_block block)
 		      /* If all edges produce the same value and that value is
 			 an invariant, then the PHI has the same value on all
 			 edges.  Note this.  */
-		      else if (!cant_insert && all_same && eprime 
+		      else if (!cant_insert && all_same && eprime
 			       && is_gimple_min_invariant (eprime)
 			       && !is_gimple_min_invariant (val))
 			{
@@ -2761,7 +2761,7 @@ insert_aux (basic_block block)
 			  for (node = exprset->head; node; node = node->next)
  			    {
 			      if (TREE_CODE (node->expr) == SSA_NAME)
-				{				  
+				{
 				  vn_add (node->expr, eprime);
 				  pre_stats.constified++;
 				}
@@ -2791,10 +2791,10 @@ insert (void)
   bool new_stuff = true;
   basic_block bb;
   int num_iterations = 0;
-  
+
   FOR_ALL_BB (bb)
     NEW_SETS (bb) = bitmap_set_new ();
-  
+
   while (new_stuff)
     {
       num_iterations++;
@@ -2882,7 +2882,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
       gcc_assert (code == TREE_LIST);
       pool = list_node_pool;
     }
-  else 
+  else
     {
       gcc_assert (code == CALL_EXPR);
       pool = expression_node_pool;
@@ -2890,7 +2890,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
 
   vexpr = (tree) pool_alloc (pool);
   memcpy (vexpr, expr, tree_size (expr));
-  
+
   /* This case is only for TREE_LIST's that appear as part of
      CALL_EXPR's.  Anything else is a bug, but we can't easily verify
      this, hence this comment.  TREE_LIST is not handled by the
@@ -2903,9 +2903,9 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
       tree op = NULL_TREE;
       tree temp = NULL_TREE;
       if (TREE_CHAIN (vexpr))
-	temp = create_value_expr_from (TREE_CHAIN (vexpr), block, stmt);      
+	temp = create_value_expr_from (TREE_CHAIN (vexpr), block, stmt);
       TREE_CHAIN (vexpr) = temp ? temp : TREE_CHAIN (vexpr);
-      
+
 
       /* Recursively value-numberize reference ops.  */
       if (REFERENCE_CLASS_P (TREE_VALUE (vexpr)))
@@ -2914,7 +2914,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
 	  op = TREE_VALUE (vexpr);
 	  tempop = create_value_expr_from (op, block, stmt);
 	  op = tempop ? tempop : op;
-	  
+
 	  TREE_VALUE (vexpr)  = vn_lookup_or_add (op, stmt);
 	}
       else
@@ -2933,7 +2933,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
   for (i = 0; i < TREE_CODE_LENGTH (code); i++)
     {
       tree val, op;
-      
+
       op = TREE_OPERAND (expr, i);
       if (op == NULL_TREE)
 	continue;
@@ -2948,10 +2948,10 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
       else if (TREE_CODE (op) == TREE_LIST)
 	{
 	  tree tempop;
-	  
+
 	  gcc_assert (TREE_CODE (expr) == CALL_EXPR);
 	  tempop = create_value_expr_from (op, block, stmt);
-	  
+
 	  op = tempop ? tempop : op;
 	  vn_lookup_or_add (op, NULL);
 	  /* Unlike everywhere else, we do *not* want to replace the
@@ -2959,7 +2959,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
 	     functions we call will blow up.  */
 	  val = op;
 	}
-      else       
+      else
 	/* Create a value handle for OP and add it to VEXPR.  */
 	val = vn_lookup_or_add (op, NULL);
 
@@ -2984,7 +2984,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
 static void
 insert_extra_phis (basic_block block, basic_block dom)
 {
-  
+
   if (!single_pred_p (block))
     {
       edge e;
@@ -3032,7 +3032,7 @@ insert_extra_phis (basic_block block, basic_block dom)
 		  get_var_ann (mergephitemp);
 		}
 	      temp = mergephitemp;
-		  
+
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 		{
 		  fprintf (dump_file, "Creating phi ");
@@ -3042,13 +3042,13 @@ insert_extra_phis (basic_block block, basic_block dom)
 
 	      add_referenced_var (temp);
 	      temp = create_phi_node (temp, block);
-	      NECESSARY (temp) = 0; 
+	      NECESSARY (temp) = 0;
 	      VEC_safe_push (tree, heap, inserted_exprs, temp);
 
 	      FOR_EACH_EDGE (e, ei, block->preds)
 		{
 		  tree leader = bitmap_find_leader (AVAIL_OUT (e->src), val);
-		  
+
 		  gcc_assert (leader);
 		  add_phi_arg (temp, leader, e);
 
@@ -3060,7 +3060,7 @@ insert_extra_phis (basic_block block, basic_block dom)
 		}
 
 	      vn_add (PHI_RESULT (temp), val);
-	      
+
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 		fprintf (dump_file, "\n");
 	    }
@@ -3125,7 +3125,7 @@ try_look_through_load (tree lhs, tree mem_ref, tree stmt, basic_block block)
       || TREE_CODE (rhs) == ADDR_EXPR
       || TREE_INVARIANT (rhs))
     {
-      
+
       /* Yay!  Compute a value number for the RHS of the statement and
  	 add its value to the AVAIL_OUT set for the block.  Add the LHS
 	 to TMP_GEN.  */
@@ -3290,7 +3290,7 @@ realify_fake_stores (void)
 	  /* Mark the temp variable as referenced */
 	  add_referenced_var (SSA_NAME_VAR (TREE_OPERAND (stmt, 0)));
 
-	  /* Put the new statement in GC memory, fix up the 
+	  /* Put the new statement in GC memory, fix up the
 	     SSA_NAME_DEF_STMT on it, and then put it in place of
 	     the old statement before the store in the IR stream
 	     as a plain ssa name copy.  */
@@ -3357,7 +3357,7 @@ try_combine_conversion (tree *expr_p)
    block.  The AVAIL sets are built from information we glean while doing
    this value numbering, since the AVAIL sets contain only one entry per
    value.
-   
+
    AVAIL_IN[BLOCK] = AVAIL_OUT[dom(BLOCK)].
    AVAIL_OUT[BLOCK] = AVAIL_IN[BLOCK] U PHI_GEN[BLOCK] U TMP_GEN[BLOCK].  */
 
@@ -3444,7 +3444,7 @@ compute_avail (void)
 
 	  stmt = bsi_stmt (bsi);
 	  ann = stmt_ann (stmt);
-	  
+
 	  ann->uid = stmt_uid++;
 
 	  /* For regular value numbering, we are only interested in
@@ -3500,14 +3500,14 @@ compute_avail (void)
 		  /* Compute a value number for the RHS of the statement
 		     and add its value to the AVAIL_OUT set for the block.
 		     Add the LHS to TMP_GEN.  */
-		  add_to_sets (lhs, rhs, stmt, TMP_GEN (block), 
+		  add_to_sets (lhs, rhs, stmt, TMP_GEN (block),
 			       AVAIL_OUT (block));
-		  
+
 		  if (TREE_CODE (rhs) == SSA_NAME
 		      && !is_undefined_value (rhs))
 		    value_insert_into_set (EXP_GEN (block), rhs);
 		  continue;
-		}	   
+		}
 	    }
 
 	  /* For any other statement that we don't recognize, simply
@@ -3542,7 +3542,7 @@ eliminate (void)
   FOR_EACH_BB (b)
     {
       block_stmt_iterator i;
-      
+
       for (i = bsi_start (b); !bsi_end_p (i); bsi_next (&i))
         {
           tree stmt = bsi_stmt (i);
@@ -3562,7 +3562,7 @@ eliminate (void)
 
 	      sprime = bitmap_find_leader (AVAIL_OUT (b),
 					   vn_lookup (lhs, NULL));
-	      if (sprime 
+	      if (sprime
 		  && sprime != lhs
 		  && (TREE_CODE (*rhs_p) != SSA_NAME
 		      || may_propagate_copy (*rhs_p, sprime)))
@@ -3578,8 +3578,8 @@ eliminate (void)
 		      fprintf (dump_file, " in ");
 		      print_generic_stmt (dump_file, stmt, 0);
 		    }
-		  
-		  if (TREE_CODE (sprime) == SSA_NAME) 
+
+		  if (TREE_CODE (sprime) == SSA_NAME)
 		    NECESSARY (SSA_NAME_DEF_STMT (sprime)) = 1;
 		  /* We need to make sure the new and old types actually match,
 		     which may require adding a simple cast, which fold_convert
@@ -3588,7 +3588,7 @@ eliminate (void)
 		      && !tree_ssa_useless_type_conversion_1 (TREE_TYPE (*rhs_p),
 							      TREE_TYPE (sprime)))
 		    sprime = fold_convert (TREE_TYPE (*rhs_p), sprime);
-		  
+
 		  pre_stats.eliminations++;
 		  propagate_tree_value (rhs_p, sprime);
 		  update_stmt (stmt);
@@ -3614,7 +3614,7 @@ eliminate (void)
 
 /* If OP's defining statement has not already been determined to be necessary,
    mark that statement necessary. Return the stmt, if it is newly
-   necessary.  */ 
+   necessary.  */
 
 static inline tree
 mark_operand_necessary (tree op)
@@ -3681,14 +3681,14 @@ remove_dead_inserted_code (void)
       else
 	{
 	  /* Propagate through the operands.  Examine all the USE, VUSE and
-	     V_MAY_DEF operands in this statement.  Mark all the statements 
+	     V_MAY_DEF operands in this statement.  Mark all the statements
 	     which feed this statement's uses as necessary.  */
 	  ssa_op_iter iter;
 	  tree use;
 
 	  /* The operands of V_MAY_DEF expressions are also needed as they
 	     represent potential definitions that may reach this
-	     statement (V_MAY_DEF operands allow us to follow def-def 
+	     statement (V_MAY_DEF operands allow us to follow def-def
 	     links).  */
 
 	  FOR_EACH_SSA_TREE_OPERAND (use, t, iter, SSA_OP_ALL_USES)
@@ -3733,7 +3733,7 @@ static void
 init_pre (bool do_fre)
 {
   basic_block bb;
-  
+
   in_fre = do_fre;
 
   inserted_exprs = NULL;
@@ -3784,7 +3784,7 @@ init_pre (bool do_fre)
   expression_node_pool = create_alloc_pool ("Expression tree nodes",
 					    tree_code_size (CALL_EXPR), 30);
   list_node_pool = create_alloc_pool ("List tree nodes",
-				      tree_code_size (TREE_LIST), 30);  
+				      tree_code_size (TREE_LIST), 30);
   comparison_node_pool = create_alloc_pool ("Comparison tree nodes",
       					    tree_code_size (EQ_EXPR), 30);
   modify_expr_node_pool = create_alloc_pool ("MODIFY_EXPR nodes",
@@ -3886,9 +3886,9 @@ execute_pre (bool do_fre)
       FOR_ALL_BB (bb)
 	{
 	  print_value_set (dump_file, EXP_GEN (bb), "exp_gen", bb->index);
-	  bitmap_print_value_set (dump_file, TMP_GEN (bb), "tmp_gen", 
+	  bitmap_print_value_set (dump_file, TMP_GEN (bb), "tmp_gen",
 				  bb->index);
-	  bitmap_print_value_set (dump_file, AVAIL_OUT (bb), "avail_out", 
+	  bitmap_print_value_set (dump_file, AVAIL_OUT (bb), "avail_out",
 				  bb->index);
 	}
     }
@@ -3918,7 +3918,7 @@ execute_pre (bool do_fre)
       fprintf (dump_file, "Eliminated: %d\n", pre_stats.eliminations);
       fprintf (dump_file, "Constified: %d\n", pre_stats.constified);
     }
-  
+
   bsi_commit_edge_inserts ();
 
   if (!do_fre)
@@ -3960,7 +3960,7 @@ struct tree_opt_pass pass_pre =
   0,					/* properties_provided */
   0,					/* properties_destroyed */
   0,					/* todo_flags_start */
-  TODO_update_ssa_only_virtuals | TODO_dump_func | TODO_ggc_collect 
+  TODO_update_ssa_only_virtuals | TODO_dump_func | TODO_ggc_collect
   | TODO_verify_ssa, /* todo_flags_finish */
   0					/* letter */
 };
@@ -3997,4 +3997,3 @@ struct tree_opt_pass pass_fre =
   TODO_dump_func | TODO_ggc_collect | TODO_verify_ssa, /* todo_flags_finish */
   0					/* letter */
 };
-