alias.c: Fix formatting.

	* alias.c: Fix formatting.
	* attribs.c: Likewise.
	* bb-reorder.c: Likewise.
	* bitmap.c: Likewise.
	* bitmap.h: Likewise.
	* builtins.c: Likewise.

From-SVN: r53898

1 files changed, 58 insertions, 58 deletions

diff --git a/gcc/alias.c b/gcc/alias.c
index 24874f4f63d..140e58aaffc 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -75,7 +75,7 @@ typedef struct alias_set_entry
   /* The children of the alias set.  These are not just the immediate
      children, but, in fact, all descendents.  So, if we have:
 
-       struct T { struct S s; float f; } 
+       struct T { struct S s; float f; }
 
      continuing our example above, the children here will be all of
      `int', `double', `float', and `struct S'.  */
@@ -131,7 +131,7 @@ static int nonlocal_set_p               PARAMS ((rtx));
 /* Cap the number of passes we make over the insns propagating alias
    information through set chains.   10 is a completely arbitrary choice.  */
 #define MAX_ALIAS_LOOP_PASSES 10
-   
+
 /* reg_base_value[N] gives an address to which register N is related.
    If all sets after the first add or subtract to the current value
    or otherwise modify it so it does not point to a different top level
@@ -140,7 +140,7 @@ static int nonlocal_set_p               PARAMS ((rtx));
 
    A base address can be an ADDRESS, SYMBOL_REF, or LABEL_REF.  ADDRESS
    expressions represent certain special values: function arguments and
-   the stack, frame, and argument pointers.  
+   the stack, frame, and argument pointers.
 
    The contents of an ADDRESS is not normally used, the mode of the
    ADDRESS determines whether the ADDRESS is a function argument or some
@@ -215,12 +215,12 @@ get_alias_set_entry (alias_set)
 /* Returns nonzero if the alias sets for MEM1 and MEM2 are such that
    the two MEMs cannot alias each other.  */
 
-static int 
+static int
 mems_in_disjoint_alias_sets_p (mem1, mem2)
      rtx mem1;
      rtx mem2;
 {
-#ifdef ENABLE_CHECKING	
+#ifdef ENABLE_CHECKING
 /* Perform a basic sanity check.  Namely, that there are no alias sets
    if we're not using strict aliasing.  This helps to catch bugs
    whereby someone uses PUT_CODE, but doesn't clear MEM_ALIAS_SET, or
@@ -514,8 +514,8 @@ get_alias_set (t)
 		  else
 		    {
 		      DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
-		      record_alias_subset  (pointed_to_alias_set,
-					    DECL_POINTER_ALIAS_SET (decl));
+		      record_alias_subset (pointed_to_alias_set,
+					   DECL_POINTER_ALIAS_SET (decl));
 		    }
 		}
 
@@ -601,7 +601,7 @@ new_alias_set ()
    not vice versa.  For example, in C, a store to an `int' can alias a
    structure containing an `int', but not vice versa.  Here, the
    structure would be the SUPERSET and `int' the SUBSET.  This
-   function should be called only once per SUPERSET/SUBSET pair. 
+   function should be called only once per SUPERSET/SUBSET pair.
 
    It is illegal for SUPERSET to be zero; everything is implicitly a
    subset of alias set zero.  */
@@ -623,14 +623,14 @@ record_alias_subset (superset, subset)
     abort ();
 
   superset_entry = get_alias_set_entry (superset);
-  if (superset_entry == 0) 
+  if (superset_entry == 0)
     {
       /* Create an entry for the SUPERSET, so that we have a place to
 	 attach the SUBSET.  */
       superset_entry
 	= (alias_set_entry) xmalloc (sizeof (struct alias_set_entry));
       superset_entry->alias_set = superset;
-      superset_entry->children 
+      superset_entry->children
 	= splay_tree_new (splay_tree_compare_ints, 0, 0);
       superset_entry->has_zero_child = 0;
       splay_tree_insert (alias_sets, (splay_tree_key) superset,
@@ -644,7 +644,7 @@ record_alias_subset (superset, subset)
       subset_entry = get_alias_set_entry (subset);
       /* If there is an entry for the subset, enter all of its children
 	 (if they are not already present) as children of the SUPERSET.  */
-      if (subset_entry) 
+      if (subset_entry)
 	{
 	  if (subset_entry->has_zero_child)
 	    superset_entry->has_zero_child = 1;
@@ -654,7 +654,7 @@ record_alias_subset (superset, subset)
 	}
 
       /* Enter the SUBSET itself as a child of the SUPERSET.  */
-      splay_tree_insert (superset_entry->children, 
+      splay_tree_insert (superset_entry->children,
 			 (splay_tree_key) subset, 0);
     }
 }
@@ -687,15 +687,15 @@ record_component_aliases (type)
     case QUAL_UNION_TYPE:
       /* Recursively record aliases for the base classes, if there are any */
       if (TYPE_BINFO (type) != NULL && TYPE_BINFO_BASETYPES (type) != NULL)
-        {
-          int i;
-          for (i = 0; i < TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)); i++)
-            {
-              tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i);
-              record_alias_subset (superset,
+	{
+	  int i;
+	  for (i = 0; i < TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)); i++)
+	    {
+	      tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i);
+	      record_alias_subset (superset,
 				   get_alias_set (BINFO_TYPE (binfo)));
-            }
-        }
+	    }
+	}
       for (field = TYPE_FIELDS (type); field != 0; field = TREE_CHAIN (field))
 	if (TREE_CODE (field) == FIELD_DECL && ! DECL_NONADDRESSABLE_P (field))
 	  record_alias_subset (superset, get_alias_set (TREE_TYPE (field)));
@@ -1120,7 +1120,7 @@ rtx_equal_for_memref_p (x, y)
 
     case LABEL_REF:
       return XEXP (x, 0) == XEXP (y, 0);
-      
+
     case SYMBOL_REF:
       return XSTR (x, 0) == XSTR (y, 0);
 
@@ -1257,7 +1257,7 @@ find_base_term (x)
 
     case TRUNCATE:
       if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (Pmode))
-        return 0;
+	return 0;
       /* Fall through.  */
     case HIGH:
     case PRE_INC:
@@ -1311,7 +1311,7 @@ find_base_term (x)
 	   tests can certainly be added.  For example, if one of the operands
 	   is a shift or multiply, then it must be the index register and the
 	   other operand is the base register.  */
-	
+
 	if (tmp1 == pic_offset_table_rtx && CONSTANT_P (tmp2))
 	  return find_base_term (tmp2);
 
@@ -1409,7 +1409,7 @@ base_alias_check (x, y, x_mode, y_mode)
   if (rtx_equal_p (x_base, y_base))
     return 1;
 
-  /* The base addresses of the read and write are different expressions. 
+  /* The base addresses of the read and write are different expressions.
      If they are both symbols and they are not accessed via AND, there is
      no conflict.  We can bring knowledge of object alignment into play
      here.  For example, on alpha, "char a, b;" can alias one another,
@@ -1484,7 +1484,7 @@ addr_side_effect_eval (addr, size, n_refs)
      int n_refs;
 {
   int offset = 0;
-  
+
   switch (GET_CODE (addr))
     {
     case PRE_INC:
@@ -1503,7 +1503,7 @@ addr_side_effect_eval (addr, size, n_refs)
     default:
       return addr;
     }
-  
+
   if (offset)
     addr = gen_rtx_PLUS (GET_MODE (addr), XEXP (addr, 0), GEN_INT (offset));
   else
@@ -1666,7 +1666,7 @@ memrefs_conflict_p (xsize, x, ysize, y, c)
       }
 
   /* Treat an access through an AND (e.g. a subword access on an Alpha)
-     as an access with indeterminate size.  Assume that references 
+     as an access with indeterminate size.  Assume that references
      besides AND are aligned, so if the size of the other reference is
      at least as large as the alignment, assume no other overlap.  */
   if (GET_CODE (x) == AND && GET_CODE (XEXP (x, 1)) == CONST_INT)
@@ -1678,7 +1678,7 @@ memrefs_conflict_p (xsize, x, ysize, y, c)
   if (GET_CODE (y) == AND && GET_CODE (XEXP (y, 1)) == CONST_INT)
     {
       /* ??? If we are indexing far enough into the array/structure, we
-	 may yet be able to determine that we can not overlap.  But we 
+	 may yet be able to determine that we can not overlap.  But we
 	 also need to that we are far enough from the end not to overlap
 	 a following reference, so we do nothing with that for now.  */
       if (GET_CODE (x) == AND || xsize < -INTVAL (XEXP (y, 1)))
@@ -1740,7 +1740,7 @@ memrefs_conflict_p (xsize, x, ysize, y, c)
    If both memory references are volatile, then there must always be a
    dependence between the two references, since their order can not be
    changed.  A volatile and non-volatile reference can be interchanged
-   though. 
+   though.
 
    A MEM_IN_STRUCT reference at a non-AND varying address can never
    conflict with a non-MEM_IN_STRUCT reference at a fixed address.  We
@@ -1767,23 +1767,23 @@ read_dependence (mem, x)
    to decide whether or not an address may vary; it should return
    nonzero whenever variation is possible.
    MEM1_ADDR and MEM2_ADDR are the addresses of MEM1 and MEM2.  */
-  
+
 static rtx
 fixed_scalar_and_varying_struct_p (mem1, mem2, mem1_addr, mem2_addr, varies_p)
      rtx mem1, mem2;
      rtx mem1_addr, mem2_addr;
      int (*varies_p) PARAMS ((rtx, int));
-{  
+{
   if (! flag_strict_aliasing)
     return NULL_RTX;
 
-  if (MEM_SCALAR_P (mem1) && MEM_IN_STRUCT_P (mem2) 
+  if (MEM_SCALAR_P (mem1) && MEM_IN_STRUCT_P (mem2)
       && !varies_p (mem1_addr, 1) && varies_p (mem2_addr, 1))
     /* MEM1 is a scalar at a fixed address; MEM2 is a struct at a
        varying address.  */
     return mem1;
 
-  if (MEM_IN_STRUCT_P (mem1) && MEM_SCALAR_P (mem2) 
+  if (MEM_IN_STRUCT_P (mem1) && MEM_SCALAR_P (mem2)
       && varies_p (mem1_addr, 1) && !varies_p (mem2_addr, 1))
     /* MEM2 is a scalar at a fixed address; MEM1 is a struct at a
        varying address.  */
@@ -1803,7 +1803,7 @@ aliases_everything_p (mem)
     /* If the address is an AND, its very hard to know at what it is
        actually pointing.  */
     return 1;
-    
+
   return 0;
 }
 
@@ -1861,7 +1861,7 @@ nonoverlapping_component_refs_p (x, y)
   while (x && y
 	 && TREE_CODE (x) == COMPONENT_REF
 	 && TREE_CODE (y) == COMPONENT_REF);
-  
+
   return false;
 }
 
@@ -1894,7 +1894,7 @@ adjust_offset_for_component_ref (x, offset)
     return NULL_RTX;
 
   ioffset = INTVAL (offset);
-  do 
+  do
     {
       tree field = TREE_OPERAND (x, 1);
 
@@ -1980,15 +1980,15 @@ nonoverlapping_memrefs_p (x, y)
     offsety = INTVAL (XEXP (basey, 1)), basey = XEXP (basey, 0);
 
   /* If the bases are different, we know they do not overlap if both
-     are constants or if one is a constant and the other a pointer into the 
+     are constants or if one is a constant and the other a pointer into the
      stack frame.  Otherwise a different base means we can't tell if they
      overlap or not.  */
   if (! rtx_equal_p (basex, basey))
-      return ((CONSTANT_P (basex) && CONSTANT_P (basey))
-	      || (CONSTANT_P (basex) && REG_P (basey)
-		  && REGNO_PTR_FRAME_P (REGNO (basey)))
-	      || (CONSTANT_P (basey) && REG_P (basex)
-		  && REGNO_PTR_FRAME_P (REGNO (basex))));
+    return ((CONSTANT_P (basex) && CONSTANT_P (basey))
+	    || (CONSTANT_P (basex) && REG_P (basey)
+		&& REGNO_PTR_FRAME_P (REGNO (basey)))
+	    || (CONSTANT_P (basey) && REG_P (basex)
+		&& REGNO_PTR_FRAME_P (REGNO (basex))));
 
   sizex = (GET_CODE (rtlx) != MEM ? (int) GET_MODE_SIZE (GET_MODE (rtlx))
 	   : MEM_SIZE (rtlx) ? INTVAL (MEM_SIZE (rtlx))
@@ -2105,9 +2105,9 @@ true_dependence (mem, mem_mode, x, varies)
 }
 
 /* Canonical true dependence: X is read after store in MEM takes place.
-   Variant of true_dependence which assumes MEM has already been 
-   canonicalized (hence we no longer do that here).  
-   The mem_addr argument has been added, since true_dependence computed 
+   Variant of true_dependence which assumes MEM has already been
+   canonicalized (hence we no longer do that here).
+   The mem_addr argument has been added, since true_dependence computed
    this value prior to canonicalizing.  */
 
 int
@@ -2233,7 +2233,7 @@ write_dependence_p (mem, x, writep)
 			   SIZE_FOR_MODE (x), x_addr, 0))
     return 0;
 
-  fixed_scalar 
+  fixed_scalar
     = fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr,
 					 rtx_addr_varies_p);
 
@@ -2378,9 +2378,9 @@ nonlocal_mentioned_p (x)
 	  x = CALL_INSN_FUNCTION_USAGE (x);
 	  if (x == 0)
 	    return 0;
-        }
+	}
       else
-        x = PATTERN (x);
+	x = PATTERN (x);
     }
 
   return for_each_rtx (&x, nonlocal_mentioned_p_1, NULL);
@@ -2476,9 +2476,9 @@ nonlocal_referenced_p (x)
 	  x = CALL_INSN_FUNCTION_USAGE (x);
 	  if (x == 0)
 	    return 0;
-        }
+	}
       else
-        x = PATTERN (x);
+	x = PATTERN (x);
     }
 
   return for_each_rtx (&x, nonlocal_referenced_p_1, NULL);
@@ -2556,9 +2556,9 @@ nonlocal_set_p (x)
 	  x = CALL_INSN_FUNCTION_USAGE (x);
 	  if (x == 0)
 	    return 0;
-        }
+	}
       else
-        x = PATTERN (x);
+	x = PATTERN (x);
     }
 
   return for_each_rtx (&x, nonlocal_set_p_1, NULL);
@@ -2597,16 +2597,16 @@ mark_constant_function ()
 
       if (nonlocal_set_p (insn) || global_reg_mentioned_p (insn)
 	  || volatile_refs_p (PATTERN (insn)))
-  	break;
+	break;
 
       if (! nonlocal_memory_referenced)
 	nonlocal_memory_referenced = nonlocal_referenced_p (insn);
     }
-  
+
   end_alias_analysis ();
-  
+
   /* Mark the function.  */
-  
+
   if (insn)
     ;
   else if (nonlocal_memory_referenced)
@@ -2651,10 +2651,10 @@ init_alias_analysis ()
 
   reg_known_value_size = maxreg;
 
-  reg_known_value 
+  reg_known_value
     = (rtx *) xcalloc ((maxreg - FIRST_PSEUDO_REGISTER), sizeof (rtx))
     - FIRST_PSEUDO_REGISTER;
-  reg_known_equiv_p 
+  reg_known_equiv_p
     = (char*) xcalloc ((maxreg - FIRST_PSEUDO_REGISTER), sizeof (char))
     - FIRST_PSEUDO_REGISTER;