final.c: Fix formatting.

	* final.c: Fix formatting.
	* fix-header.c: Likewise.
	* flow.c: Likewise.
	* fold-const.c: Likewise.
	* function.c: Likewise.

From-SVN: r53563

6 files changed, 111 insertions, 103 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 51ac12203e0..13d793746b6 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+2002-05-17  Kazu Hirata  <kazu@cs.umass.edu>
+
+	* final.c: Fix formatting.
+	* fix-header.c: Likewise.
+	* flow.c: Likewise.
+	* fold-const.c: Likewise.
+	* function.c: Likewise.
+
 2002-05-17  David S. Miller  <davem@redhat.com>
 
 	PR c/6689, PR optimization/6615
diff --git a/gcc/final.c b/gcc/final.c
index 3e1b2232c39..2eeeb8c39a8 100644
--- a/gcc/final.c
+++ b/gcc/final.c
@@ -502,7 +502,7 @@ end_final (filename)
       ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 0);
       DECL_NAME (structure_value) = get_identifier (name);
 
-      /* Size of this structure. */
+      /* Size of this structure.  */
       TREE_VALUE (sizeof_field_value)
 	= convert (long_integer_type_node,
 		   build_int_2 (int_size_in_bytes (structure_decl), 0));
@@ -668,7 +668,7 @@ get_attr_length (insn)
 
       case JUMP_INSN:
 	body = PATTERN (insn);
-        if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
+	if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
 	  {
 	    /* Alignment is machine-dependent and should be handled by
 	       ADDR_VEC_ALIGN.  */
@@ -1521,7 +1521,7 @@ shorten_branches (first)
 
 		      insn_current_address += insn_lengths[inner_uid];
 		    }
-                }
+		}
 	      else
 		insn_current_address += insn_lengths[uid];
 
@@ -1937,7 +1937,7 @@ final (first, file, optimize, prescan)
       new_item->cfg_checksum = profile_info.current_function_cfg_checksum;
       new_item->count_edges = profile_info.count_edges_instrumented_now;
     }
-  
+
   free (line_note_exists);
   line_note_exists = NULL;
 }
@@ -2696,13 +2696,13 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
 	insn_code_number = recog_memoized (insn);
 	cleanup_subreg_operands (insn);
 
-       /* Dump the insn in the assembly for debugging.  */
-       if (flag_dump_rtl_in_asm)
-         {
-           print_rtx_head = ASM_COMMENT_START;
-           print_rtl_single (asm_out_file, insn);
-           print_rtx_head = "";
-         }
+	/* Dump the insn in the assembly for debugging.  */
+	if (flag_dump_rtl_in_asm)
+	  {
+	    print_rtx_head = ASM_COMMENT_START;
+	    print_rtl_single (asm_out_file, insn);
+	    print_rtx_head = "";
+	  }
 
 	if (! constrain_operands_cached (1))
 	  fatal_insn_not_found (insn);
@@ -3127,7 +3127,7 @@ output_operand_lossage VPARAMS ((const char *msgid, ...))
   pfx_str = this_is_asm_operands ? _("invalid `asm': ") : "output_operand: ";
   asprintf (&fmt_string, "%s%s", pfx_str, _(msgid));
   vasprintf (&new_message, fmt_string, ap);
-  
+
   if (this_is_asm_operands)
     error_for_asm (this_is_asm_operands, "%s", new_message);
   else
diff --git a/gcc/fix-header.c b/gcc/fix-header.c
index 6d054b5c107..ba4ba6a6dee 100644
--- a/gcc/fix-header.c
+++ b/gcc/fix-header.c
@@ -411,10 +411,10 @@ int lbrac_line, rbrac_line;
 int required_unseen_count = 0;
 int required_other = 0;
 
-static void 
+static void
 write_lbrac ()
 {
-  
+
 #if ADD_MISSING_EXTERN_C
   if (missing_extern_C_count + required_unseen_count > 0)
     fprintf (outf, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n");
@@ -546,7 +546,7 @@ recognized_function (fname, line, kind, have_arg_list)
   /* If we have a full prototype, we're done.  */
   if (have_arg_list)
     return;
-      
+
   if (kind == 'I')  /* don't edit inline function */
     return;
 
@@ -619,7 +619,7 @@ read_scan_file (in_fname, argc, argv)
   int i;
   struct symbol_list *cur_symbols;
 
-  obstack_init (&scan_file_obstack); 
+  obstack_init (&scan_file_obstack);
 
   scan_in = cpp_create_reader (CLK_GNUC89);
   cb = cpp_get_callbacks (scan_in);
@@ -701,7 +701,7 @@ read_scan_file (in_fname, argc, argv)
   if (required_unseen_count + partial_count + required_other
 #if ADD_MISSING_EXTERN_C
       + missing_extern_C_count
-#endif      
+#endif
       == 0)
     {
       if (verbose)
@@ -1084,8 +1084,8 @@ main (argc, argv)
 
       progname = 0;
       for (p = argv[0]; *p; p++)
-        if (*p == '/')
-          progname = p;
+	if (*p == '/')
+	  progname = p;
       progname = progname ? progname+1 : argv[0];
     }
 
@@ -1114,7 +1114,7 @@ main (argc, argv)
 	      exit (SUCCESS_EXIT_CODE);
 	    }
 	}
-	  
+
     }
 #endif
 
@@ -1148,7 +1148,7 @@ main (argc, argv)
   else
     symbol_table[0].names = NULL;
 
-  /* Count and mark the prototypes required for this include file.  */ 
+  /* Count and mark the prototypes required for this include file.  */
   for (cur_symbols = &symbol_table[0]; cur_symbols->names; cur_symbols++)
     {
       int name_len;
@@ -1313,7 +1313,7 @@ v_fatal (str, ap)
   fprintf (stderr, "%s: %s: ", progname, inc_filename);
   vfprintf (stderr, str, ap);
   fprintf (stderr, "\n");
-  
+
   exit (FATAL_EXIT_CODE);
 }
 
diff --git a/gcc/flow.c b/gcc/flow.c
index 8a9a9db1a45..31017fb28eb 100644
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -592,7 +592,7 @@ verify_local_live_at_start (new_live_at_start, bb)
 
       EXECUTE_IF_SET_IN_REG_SET (new_live_at_start, 0, i,
 	{
-          /* No registers should die.  */
+	  /* No registers should die.  */
 	  if (REGNO_REG_SET_P (bb->global_live_at_start, i))
 	    {
 	      if (rtl_dump_file)
@@ -604,7 +604,7 @@ verify_local_live_at_start (new_live_at_start, bb)
 	      abort ();
 	    }
 
-          /* Verify that the now-live register is wider than word_mode.  */
+	  /* Verify that the now-live register is wider than word_mode.  */
 	  verify_wide_reg (i, bb);
 	});
     }
@@ -989,7 +989,7 @@ mark_regs_live_at_end (set)
 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
       /* If they are different, also mark the hard frame pointer as live.  */
       if (! LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM))
-        SET_REGNO_REG_SET (set, HARD_FRAME_POINTER_REGNUM);
+	SET_REGNO_REG_SET (set, HARD_FRAME_POINTER_REGNUM);
 #endif
     }
 
@@ -1749,7 +1749,7 @@ propagate_one_insn (pbi, insn)
 	      free_EXPR_LIST_list (&pbi->mem_set_list);
 	      pbi->mem_set_list_len = 0;
 	    }
-          else
+	  else
 	    invalidate_mems_from_set (pbi, stack_pointer_rtx);
 
 	  /* There may be extra registers to be clobbered.  */
@@ -2660,7 +2660,7 @@ mark_set_1 (pbi, code, reg, cond, insn, flags)
       if (GET_CODE (reg) == MEM && ! side_effects_p (reg)
 	  /* ??? With more effort we could track conditional memory life.  */
 	  && ! cond)
-        add_to_mem_set_list (pbi, canon_rtx (reg));
+	add_to_mem_set_list (pbi, canon_rtx (reg));
     }
 
   if (GET_CODE (reg) == REG
@@ -3791,7 +3791,7 @@ mark_used_regs (pbi, x, cond, insn)
 
 #ifdef AUTO_INC_DEC
       if (flags & PROP_AUTOINC)
-        find_auto_inc (pbi, x, insn);
+	find_auto_inc (pbi, x, insn);
 #endif
       break;
 
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 0744ada154d..686fd41ce00 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -103,10 +103,10 @@ static tree strip_compound_expr PARAMS ((tree, tree));
 static int multiple_of_p	PARAMS ((tree, tree, tree));
 static tree constant_boolean_node PARAMS ((int, tree));
 static int count_cond		PARAMS ((tree, int));
-static tree fold_binary_op_with_conditional_arg 
+static tree fold_binary_op_with_conditional_arg
   PARAMS ((enum tree_code, tree, tree, tree, int));
 static bool fold_real_zero_addition_p	PARAMS ((tree, tree, int));
-							 
+
 #if defined(HOST_EBCDIC)
 /* bit 8 is significant in EBCDIC */
 #define CHARMASK 0xff
@@ -413,7 +413,7 @@ lshift_double (l1, h1, count, prec, lv, hv, arith)
 
   signmask = -((prec > HOST_BITS_PER_WIDE_INT
 		? ((unsigned HOST_WIDE_INT) *hv
-                   >> (prec - HOST_BITS_PER_WIDE_INT - 1))
+		   >> (prec - HOST_BITS_PER_WIDE_INT - 1))
 		: (*lv >> (prec - 1))) & 1);
 
   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
@@ -2189,7 +2189,7 @@ invert_truthvalue (arg)
     {
       if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
 	  && !flag_unsafe_math_optimizations
-	  && code != NE_EXPR 
+	  && code != NE_EXPR
 	  && code != EQ_EXPR)
 	return build1 (TRUTH_NOT_EXPR, type, arg);
       else
@@ -3112,11 +3112,11 @@ build_range_check (type, exp, in_p, low, high)
   if (integer_zerop (low))
     {
       if (! TREE_UNSIGNED (etype))
-        {
-          etype = (*lang_hooks.types.unsigned_type) (etype);
-          high = convert (etype, high);
-          exp = convert (etype, exp);
-        }
+	{
+	  etype = (*lang_hooks.types.unsigned_type) (etype);
+	  high = convert (etype, high);
+	  exp = convert (etype, exp);
+	}
       return build_range_check (type, exp, 1, 0, high);
     }
 
@@ -3129,26 +3129,26 @@ build_range_check (type, exp, in_p, low, high)
 
       prec = TYPE_PRECISION (etype);
       if (prec <= HOST_BITS_PER_WIDE_INT)
-        {
-          hi = 0;
-          lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
-        }
+	{
+	  hi = 0;
+	  lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
+	}
       else
-        {
-          hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
-          lo = (unsigned HOST_WIDE_INT) -1;
-        }
+	{
+	  hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
+	  lo = (unsigned HOST_WIDE_INT) -1;
+	}
 
       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
-        {
-          if (TREE_UNSIGNED (etype))
-            {
-              etype = (*lang_hooks.types.signed_type) (etype);
-              exp = convert (etype, exp);
-            }
-          return fold (build (GT_EXPR, type, exp,
-                              convert (etype, integer_zero_node)));
-        }
+	{
+	  if (TREE_UNSIGNED (etype))
+	    {
+	      etype = (*lang_hooks.types.signed_type) (etype);
+	      exp = convert (etype, exp);
+	    }
+	  return fold (build (GT_EXPR, type, exp,
+			      convert (etype, integer_zero_node)));
+	}
     }
 
   if (0 != (value = const_binop (MINUS_EXPR, high, low, 0))
@@ -3954,7 +3954,7 @@ extract_muldiv (t, c, code, wide_type)
 	  && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
 		&& TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
 	  && (GET_MODE_SIZE (TYPE_MODE (ctype))
-              > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
+	      > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
 	break;
 
       /* Pass the constant down and see if we can make a simplification.  If
@@ -4074,13 +4074,13 @@ extract_muldiv (t, c, code, wide_type)
          of our constant, do the operation and verify it doesn't overflow.  */
       if (code == MULT_EXPR
 	  || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
-        {
-          op1 = const_binop (code, convert (ctype, op1), convert (ctype, c), 0);
-          if (op1 == 0 || TREE_OVERFLOW (op1))
-            break;
-        }
+	{
+	  op1 = const_binop (code, convert (ctype, op1), convert (ctype, c), 0);
+	  if (op1 == 0 || TREE_OVERFLOW (op1))
+	    break;
+	}
       else
-        break;
+	break;
 
       /* If we have an unsigned type is not a sizetype, we cannot widen
 	 the operation since it will change the result if the original
@@ -4336,7 +4336,7 @@ fold_binary_op_with_conditional_arg (code, type, cond, arg, cond_first_p)
       true_value = convert (testtype, integer_one_node);
       false_value = convert (testtype, integer_zero_node);
     }
-  
+
   /* If ARG is complex we want to make sure we only evaluate
      it once.  Though this is only required if it is volatile, it
      might be more efficient even if it is not.  However, if we
@@ -4345,12 +4345,12 @@ fold_binary_op_with_conditional_arg (code, type, cond, arg, cond_first_p)
      primarily to see if we do end up with constant and this
      SAVE_EXPR interferes with later optimizations, suppressing
      it when we can is important.
-     
+
      If we are not in a function, we can't make a SAVE_EXPR, so don't
      try to do so.  Don't try to see if the result is a constant
      if an arm is a COND_EXPR since we get exponential behavior
      in that case.  */
-  
+
   if (TREE_CODE (arg) != SAVE_EXPR && ! TREE_CONSTANT (arg)
       && (*lang_hooks.decls.global_bindings_p) () == 0
       && ((TREE_CODE (arg) != VAR_DECL
@@ -4359,22 +4359,22 @@ fold_binary_op_with_conditional_arg (code, type, cond, arg, cond_first_p)
     {
       if (TREE_CODE (true_value) != COND_EXPR)
 	lhs = fold (build (lhs_code, lhs_type, *true_lhs, *true_rhs));
-      
+
       if (TREE_CODE (false_value) != COND_EXPR)
 	rhs = fold (build (rhs_code, rhs_type, *false_lhs, *false_rhs));
-      
+
       if ((lhs == 0 || ! TREE_CONSTANT (lhs))
 	  && (rhs == 0 || !TREE_CONSTANT (rhs)))
 	arg = save_expr (arg), lhs = rhs = 0;
     }
-  
+
   if (lhs == 0)
     lhs = fold (build (lhs_code, lhs_type, *true_lhs, *true_rhs));
   if (rhs == 0)
     rhs = fold (build (rhs_code, rhs_type, *false_lhs, *false_rhs));
-  
+
   test = fold (build (COND_EXPR, type, test, lhs, rhs));
-  
+
   if (TREE_CODE (arg) == SAVE_EXPR)
     return build (COMPOUND_EXPR, type,
 		  convert (void_type_node, arg),
@@ -4636,7 +4636,7 @@ fold (expr)
 	       && (! TREE_SIDE_EFFECTS (arg0)
 		   || ((*lang_hooks.decls.global_bindings_p) () == 0
 		       && ! contains_placeholder_p (arg0))))
-	return 
+	return
 	  fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
 					       /*cond_first_p=*/0);
       else if (TREE_CODE (arg0) == COMPOUND_EXPR)
@@ -4650,7 +4650,7 @@ fold (expr)
 	       && (! TREE_SIDE_EFFECTS (arg1)
 		   || ((*lang_hooks.decls.global_bindings_p) () == 0
 		       && ! contains_placeholder_p (arg1))))
-	return 
+	return
 	  fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
 					       /*cond_first_p=*/1);
     }
@@ -6044,31 +6044,31 @@ fold (expr)
 			      convert (st1, integer_zero_node)));
 		  }
 	      }
-            else if (TREE_INT_CST_HIGH (arg1) == 0
+	    else if (TREE_INT_CST_HIGH (arg1) == 0
 		     && (TREE_INT_CST_LOW (arg1)
 			 == ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1)
 		     && TREE_UNSIGNED (TREE_TYPE (arg1)))
-              switch (TREE_CODE (t))
-                {
-                case GT_EXPR:
-                  return omit_one_operand (type,
-                                           convert (type, integer_zero_node),
-                                           arg0);
-                case GE_EXPR:
-                  TREE_SET_CODE (t, EQ_EXPR);
-                  break;
-
-                case LE_EXPR:
-                  return omit_one_operand (type,
-                                           convert (type, integer_one_node),
-                                           arg0);
-                case LT_EXPR:
-                  TREE_SET_CODE (t, NE_EXPR);
-                  break;
-
-                default:
-                  break;
-                }
+	      switch (TREE_CODE (t))
+		{
+		case GT_EXPR:
+		  return omit_one_operand (type,
+					   convert (type, integer_zero_node),
+					   arg0);
+		case GE_EXPR:
+		  TREE_SET_CODE (t, EQ_EXPR);
+		  break;
+
+		case LE_EXPR:
+		  return omit_one_operand (type,
+					   convert (type, integer_one_node),
+					   arg0);
+		case LT_EXPR:
+		  TREE_SET_CODE (t, NE_EXPR);
+		  break;
+
+		default:
+		  break;
+		}
 	  }
       }
 
@@ -6472,7 +6472,7 @@ fold (expr)
 	}
 
       /* Optimize comparisons of strlen vs zero to a compare of the
-	 first character of the string vs zero.  To wit, 
+	 first character of the string vs zero.  To wit,
 	 	strlen(ptr) == 0   =>  *ptr == 0
 		strlen(ptr) != 0   =>  *ptr != 0
 	 Other cases should reduce to one of these two (or a constant)
@@ -7123,7 +7123,7 @@ tree_expr_nonnegative_p (t)
     case FLOOR_DIV_EXPR:
     case ROUND_DIV_EXPR:
       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
-        && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
+	&& tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
     case TRUNC_MOD_EXPR:
     case CEIL_MOD_EXPR:
     case FLOOR_MOD_EXPR:
@@ -7136,10 +7136,10 @@ tree_expr_nonnegative_p (t)
       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
     case MIN_EXPR:
       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
-        && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
+	&& tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
     case MAX_EXPR:
       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
-        || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
+	|| tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
     case MODIFY_EXPR:
       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
     case BIND_EXPR:
@@ -7150,7 +7150,7 @@ tree_expr_nonnegative_p (t)
       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
     case RTL_EXPR:
       return rtl_expr_nonnegative_p (RTL_EXPR_RTL (t));
-      
+
     default:
       if (truth_value_p (TREE_CODE (t)))
 	/* Truth values evaluate to 0 or 1, which is nonnegative.  */
diff --git a/gcc/function.c b/gcc/function.c
index 5bd70a0560f..9a944139ab5 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -4609,8 +4609,8 @@ assign_parms (fndecl)
 	 to indicate there is no preallocated stack slot for the parm.  */
 
       if (entry_parm == stack_parm
-          || (GET_CODE (entry_parm) == PARALLEL
-              && XEXP (XVECEXP (entry_parm, 0, 0), 0) == NULL_RTX)
+	  || (GET_CODE (entry_parm) == PARALLEL
+	      && XEXP (XVECEXP (entry_parm, 0, 0), 0) == NULL_RTX)
 #if defined (REG_PARM_STACK_SPACE) && ! defined (MAYBE_REG_PARM_STACK_SPACE)
 	  /* On some machines, even if a parm value arrives in a register
 	     there is still an (uninitialized) stack slot allocated for it.
@@ -5410,8 +5410,8 @@ pad_to_arg_alignment (offset_ptr, boundary, alignment_pad)
 	      (ARGS_SIZE_TREE (*offset_ptr),
 	       boundary / BITS_PER_UNIT);
 	  offset_ptr->constant = 0; /*?*/
-          if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
-            alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
+	  if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
+	    alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
 					     save_var);
 	}
       else
@@ -5471,7 +5471,7 @@ uninitialized_vars_warning (block)
   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
     {
       if (warn_uninitialized
-          && TREE_CODE (decl) == VAR_DECL
+	  && TREE_CODE (decl) == VAR_DECL
 	  /* These warnings are unreliable for and aggregates
 	     because assigning the fields one by one can fail to convince
 	     flow.c that the entire aggregate was initialized.