[patch] gcc/e*.[ch]: Fix formatting.

Kazu Hirata kazu@cs.umass.edu
Sun Jun 2 18:13:00 GMT 2002


Hi,

Attached is a patch to fix formatting.  Committed as obvious.

Kazu Hirata

2002-06-02  Kazu Hirata  <kazu@cs.umass.edu>

	* emit-rtl.c: Likewise.
	* errors.h: Likewise.
	* except.c: Likewise.
	* explow.c: Likewise.
	* expmed.c: Likewise.
	* expr.c: Likewise.
	* expr.h: Likewise.

Index: emit-rtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/emit-rtl.c,v
retrieving revision 1.268
diff -u -r1.268 emit-rtl.c
--- emit-rtl.c	2 Jun 2002 21:09:14 -0000	1.268
+++ emit-rtl.c	3 Jun 2002 01:07:30 -0000
@@ -650,7 +650,7 @@
 	HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
 	HOST_WIDE_INT arg1 = va_arg (p, HOST_WIDE_INT);
 
-        rt_val = immed_double_const (arg0, arg1, mode);
+	rt_val = immed_double_const (arg0, arg1, mode);
       }
       break;
 
@@ -3050,9 +3050,9 @@
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     {
       if (fmt[i] == 'e')
-        mark_label_nuses (XEXP (x, i));
+	mark_label_nuses (XEXP (x, i));
       else if (fmt[i] == 'E')
-        for (j = XVECLEN (x, i) - 1; j >= 0; j--)
+	for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 	  mark_label_nuses (XVECEXP (x, i, j));
     }
 }
@@ -3634,7 +3634,7 @@
 
   for (; insn; insn = PREV_INSN (insn))
     if (GET_CODE (insn) == NOTE
-        && NOTE_LINE_NUMBER (insn) >= 0)
+	&& NOTE_LINE_NUMBER (insn) >= 0)
       break;
 
   return insn;
@@ -4162,10 +4162,10 @@
     {
       bb->flags |= BB_DIRTY;
       for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
-        if (GET_CODE (last) != BARRIER)
+	if (GET_CODE (last) != BARRIER)
 	  set_block_for_insn (last, bb);
       if (GET_CODE (last) != BARRIER)
-        set_block_for_insn (last, bb);
+	set_block_for_insn (last, bb);
       if (bb->end == after)
 	bb->end = last;
     }
Index: errors.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/errors.h,v
retrieving revision 1.9
diff -u -r1.9 errors.h
--- errors.h	24 Sep 2001 00:27:31 -0000	1.9
+++ errors.h	3 Jun 2002 01:07:30 -0000
@@ -39,5 +39,5 @@
 
 extern int have_error;
 extern const char *progname;
-    
+
 #endif /* ! GCC_ERRORS_H */
Index: except.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/except.c,v
retrieving revision 1.221
diff -u -r1.221 except.c
--- except.c	1 Jun 2002 02:23:37 -0000	1.221
+++ except.c	3 Jun 2002 01:07:34 -0000
@@ -851,11 +851,11 @@
       tree type_node;
 
       if (TREE_CODE (type_or_list) != TREE_LIST)
-        type_list = tree_cons (NULL_TREE, type_or_list, NULL_TREE);
+	type_list = tree_cons (NULL_TREE, type_or_list, NULL_TREE);
 
       type_node = type_list;
       for (; type_node; type_node = TREE_CHAIN (type_node))
-        add_type_for_runtime (TREE_VALUE (type_node));
+	add_type_for_runtime (TREE_VALUE (type_node));
     }
 
   expand_eh_region_start ();
@@ -1165,7 +1165,7 @@
 
       /* Allow GC to maybe free some memory.  */
       if (fixup->type == ERT_CLEANUP)
-        fixup->u.cleanup.exp = NULL_TREE;
+	fixup->u.cleanup.exp = NULL_TREE;
 
       if (fixup->type != ERT_FIXUP)
 	continue;
@@ -1221,23 +1221,23 @@
 	continue;
 
       if (r->resume)
-        {
+	{
 	  if (uid_region_num[INSN_UID (r->resume)])
 	    abort ();
 	  uid_region_num[INSN_UID (r->resume)] = i;
-        }
+	}
       if (r->label)
-        {
+	{
 	  if (uid_region_num[INSN_UID (r->label)])
 	    abort ();
 	  uid_region_num[INSN_UID (r->label)] = i;
-        }
+	}
       if (r->type == ERT_TRY && r->u.try.continue_label)
-        {
+	{
 	  if (uid_region_num[INSN_UID (r->u.try.continue_label)])
 	    abort ();
 	  uid_region_num[INSN_UID (r->u.try.continue_label)] = i;
-        }
+	}
     }
 
   for (insn = insns; insn; insn = NEXT_INSN (insn))
@@ -1415,7 +1415,7 @@
       /* ??? The expansion factor here (3/2) must be greater than the htab
 	 occupancy factor (4/3) to avoid unnecessary resizing.  */
       exception_handler_label_map
-        = htab_create (cfun->eh->last_region_number * 3 / 2,
+	= htab_create (cfun->eh->last_region_number * 3 / 2,
 		       ehl_hash, ehl_eq, ehl_free);
     }
 
@@ -1529,9 +1529,9 @@
 
     case ERT_CATCH:
       if (o->u.catch.next_catch)
-        n->u.catch.next_catch = n_array[o->u.catch.next_catch->region_number];
+	n->u.catch.next_catch = n_array[o->u.catch.next_catch->region_number];
       if (o->u.catch.prev_catch)
-        n->u.catch.prev_catch = n_array[o->u.catch.prev_catch->region_number];
+	n->u.catch.prev_catch = n_array[o->u.catch.prev_catch->region_number];
       break;
 
     default:
@@ -2281,7 +2281,7 @@
       /* Don't separate a call from it's argument loads.  */
       before = insn;
       if (GET_CODE (insn) == CALL_INSN)
-         before = find_first_parameter_load (insn, NULL_RTX);
+	before = find_first_parameter_load (insn, NULL_RTX);
 
       start_sequence ();
       mem = adjust_address (cfun->eh->sjlj_fc, TYPE_MODE (integer_type_node),
@@ -2600,7 +2600,7 @@
   if (outer)
     {
       if (!outer->aka)
-        outer->aka = BITMAP_XMALLOC ();
+	outer->aka = BITMAP_XMALLOC ();
       if (region->aka)
 	bitmap_a_or_b (outer->aka, outer->aka, region->aka);
       bitmap_set_bit (outer->aka, region->region_number);
@@ -2941,7 +2941,7 @@
       if (info && info->handlers)
 	{
 	  add_reachable_handler (info, region, region);
-          return RNL_CAUGHT;
+	  return RNL_CAUGHT;
 	}
       else
 	return RNL_BLOCKED;
@@ -3061,7 +3061,7 @@
       if (how == RNL_BLOCKED)
 	return false;
       if (how != RNL_NOT_CAUGHT)
-        return true;
+	return true;
     }
 
   return false;
@@ -3965,7 +3965,7 @@
 	assemble_integer (value, tt_format_size,
 			  tt_format_size * BITS_PER_UNIT, 1);
       else
-        dw2_asm_output_encoded_addr_rtx (tt_format, value, NULL);
+	dw2_asm_output_encoded_addr_rtx (tt_format, value, NULL);
     }
 
 #ifdef HAVE_AS_LEB128
Index: explow.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/explow.c,v
retrieving revision 1.91
diff -u -r1.91 explow.c
--- explow.c	21 Feb 2002 23:06:14 -0000	1.91
+++ explow.c	3 Jun 2002 01:07:35 -0000
@@ -391,7 +391,7 @@
 
     case CONST:
       if (POINTERS_EXTEND_UNSIGNED >= 0)
-        return gen_rtx_CONST (to_mode,
+	return gen_rtx_CONST (to_mode,
 			      convert_memory_address (to_mode, XEXP (x, 0)));
       break;
 
@@ -1375,7 +1375,7 @@
 #ifdef SETJMP_VIA_SAVE_AREA
       if (setjmpless_size != NULL_RTX)
 	{
- 	  rtx note_target = get_last_insn ();
+	  rtx note_target = get_last_insn ();
 
 	  REG_NOTES (note_target)
 	    = gen_rtx_EXPR_LIST (REG_SAVE_AREA, setjmpless_size,
@@ -1620,17 +1620,17 @@
 	 will match and we will abort later in this function.  */
 
       for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
-           tmpmode != VOIDmode;
-           tmpmode = GET_MODE_WIDER_MODE (tmpmode))
-        {
-          /* Have we found a large enough mode?  */
-          if (GET_MODE_SIZE (tmpmode) >= bytes)
-            break;
-        }
+	   tmpmode != VOIDmode;
+	   tmpmode = GET_MODE_WIDER_MODE (tmpmode))
+	{
+	  /* Have we found a large enough mode?  */
+	  if (GET_MODE_SIZE (tmpmode) >= bytes)
+	    break;
+	}
 
       /* No suitable mode found.  */
       if (tmpmode == VOIDmode)
-        abort ();
+	abort ();
 
       PUT_MODE (val, tmpmode);
     }
Index: expmed.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/expmed.c,v
retrieving revision 1.118
diff -u -r1.118 expmed.c
--- expmed.c	30 May 2002 21:33:31 -0000	1.118
+++ expmed.c	3 Jun 2002 01:07:39 -0000
@@ -347,7 +347,7 @@
       && (GET_CODE (op0) != MEM
 	  ? ((GET_MODE_SIZE (fieldmode) >= UNITS_PER_WORD
 	     || GET_MODE_SIZE (GET_MODE (op0)) == GET_MODE_SIZE (fieldmode))
-            && byte_offset % GET_MODE_SIZE (fieldmode) == 0)
+	     && byte_offset % GET_MODE_SIZE (fieldmode) == 0)
 	  : (! SLOW_UNALIGNED_ACCESS (fieldmode, MEM_ALIGN (op0))
 	     || (offset * BITS_PER_UNIT % bitsize == 0
 		 && MEM_ALIGN (op0) % GET_MODE_BITSIZE (fieldmode) == 0))))
@@ -675,7 +675,7 @@
       if (pat)
 	emit_insn (pat);
       else
-        {
+	{
 	  delete_insns_since (last);
 	  store_fixed_bit_field (op0, offset, bitsize, bitpos, value);
 	}
@@ -737,8 +737,8 @@
 
       mode = GET_MODE (op0);
       if (GET_MODE_BITSIZE (mode) == 0
-          || GET_MODE_BITSIZE (mode) > GET_MODE_BITSIZE (word_mode))
-        mode = word_mode;
+	  || GET_MODE_BITSIZE (mode) > GET_MODE_BITSIZE (word_mode))
+	mode = word_mode;
       mode = get_best_mode (bitsize, bitpos + offset * BITS_PER_UNIT,
 			    MEM_ALIGN (op0), mode, MEM_VOLATILE_P (op0));
 
@@ -1109,8 +1109,8 @@
                 + (offset * UNITS_PER_WORD);
 
   mode1  = (VECTOR_MODE_P (tmode)
-           ? mode
-	   : mode_for_size (bitsize, GET_MODE_CLASS (tmode), 0));
+	    ? mode
+	    : mode_for_size (bitsize, GET_MODE_CLASS (tmode), 0));
 
   if (((GET_CODE (op0) != MEM
 	&& TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
@@ -1928,9 +1928,9 @@
   if (SHIFT_COUNT_TRUNCATED)
     {
       if (GET_CODE (op1) == CONST_INT
-          && ((unsigned HOST_WIDE_INT) INTVAL (op1) >=
+	  && ((unsigned HOST_WIDE_INT) INTVAL (op1) >=
 	      (unsigned HOST_WIDE_INT) GET_MODE_BITSIZE (mode)))
-        op1 = GEN_INT ((unsigned HOST_WIDE_INT) INTVAL (op1)
+	op1 = GEN_INT ((unsigned HOST_WIDE_INT) INTVAL (op1)
 		       % GET_MODE_BITSIZE (mode));
       else if (GET_CODE (op1) == SUBREG
 	       && subreg_lowpart_p (op1))
@@ -2566,8 +2566,8 @@
      there is no difference between signed and unsigned.  */
   op0 = expand_binop (mode,
 		      ! unsignedp
-                       && flag_trapv && (GET_MODE_CLASS(mode) == MODE_INT)
-                       ? smulv_optab : smul_optab,
+		      && flag_trapv && (GET_MODE_CLASS(mode) == MODE_INT)
+		      ? smulv_optab : smul_optab,
 		      op0, op1, target, unsignedp, OPTAB_LIB_WIDEN);
   if (op0 == 0)
     abort ();
@@ -3012,9 +3012,9 @@
   if (! unsignedp && op1 == constm1_rtx)
     {
       if (rem_flag)
-        return const0_rtx;
+	return const0_rtx;
       return expand_unop (mode, flag_trapv && GET_MODE_CLASS(mode) == MODE_INT
-                        ? negv_optab : neg_optab, op0, target, 0);
+			  ? negv_optab : neg_optab, op0, target, 0);
     }
 
   if (target
Index: expr.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/expr.c,v
retrieving revision 1.460
diff -u -r1.460 expr.c
--- expr.c	31 May 2002 22:08:12 -0000	1.460
+++ expr.c	3 Jun 2002 01:07:49 -0000
@@ -277,7 +277,7 @@
     {
       enum machine_mode srcmode;
       for (srcmode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); srcmode != mode;
-           srcmode = GET_MODE_WIDER_MODE (srcmode))
+	   srcmode = GET_MODE_WIDER_MODE (srcmode))
 	{
 	  enum insn_code ic;
 
@@ -286,7 +286,7 @@
 	    continue;
 
 	  PUT_MODE (mem, srcmode);
-	  
+
 	  if ((*insn_data[ic].operand[1].predicate) (mem, srcmode))
 	    float_extend_from_mem[mode][srcmode] = true;
 	}
@@ -3054,7 +3054,7 @@
 	{
 	  rtx temp;
 	  enum rtx_code code;
-	  
+
 	  /* Do not use anti_adjust_stack, since we don't want to update
 	     stack_pointer_delta.  */
 	  temp = expand_binop (Pmode,
@@ -3069,18 +3069,18 @@
 				  (GET_MODE_SIZE (GET_MODE (x)))),
 			       stack_pointer_rtx, 0, OPTAB_LIB_WIDEN);
 
-          if (temp != stack_pointer_rtx)
-            emit_move_insn (stack_pointer_rtx, temp);
+	  if (temp != stack_pointer_rtx)
+	    emit_move_insn (stack_pointer_rtx, temp);
 
 	  code = GET_CODE (XEXP (x, 0));
 
 	  /* Just hope that small offsets off SP are OK.  */
 	  if (code == POST_INC)
-	    temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx, 
+	    temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
 				GEN_INT (-((HOST_WIDE_INT)
 					   GET_MODE_SIZE (GET_MODE (x)))));
 	  else if (code == POST_DEC)
-	    temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx, 
+	    temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
 				GEN_INT (GET_MODE_SIZE (GET_MODE (x))));
 	  else
 	    temp = stack_pointer_rtx;
@@ -3357,7 +3357,7 @@
 void
 emit_push_insn (x, mode, type, size, align, partial, reg, extra,
 		args_addr, args_so_far, reg_parm_stack_space,
-                alignment_pad)
+		alignment_pad)
      rtx x;
      enum machine_mode mode;
      tree type;
@@ -3384,7 +3384,7 @@
      Default is below for small data on big-endian machines; else above.  */
   enum direction where_pad = FUNCTION_ARG_PADDING (mode, type);
 
-  /* Invert direction if stack is post-decrement. 
+  /* Invert direction if stack is post-decrement.
      FIXME: why?  */
   if (STACK_PUSH_CODE == POST_DEC)
     if (where_pad != none)
@@ -4174,7 +4174,7 @@
 	    {
 	      temp = gen_lowpart_SUBREG (GET_MODE (target), temp);
 	      SUBREG_PROMOTED_VAR_P (temp) = 1;
-	      SUBREG_PROMOTED_UNSIGNED_SET (temp, 
+	      SUBREG_PROMOTED_UNSIGNED_SET (temp,
 		SUBREG_PROMOTED_UNSIGNED_P (target));
 	    }
 	  else
@@ -6456,7 +6456,7 @@
 	  /* Get the signedness used for this variable.  Ensure we get the
 	     same mode we got when the variable was declared.  */
 	  if (GET_MODE (DECL_RTL (exp))
-	      != promote_mode (type, DECL_MODE (exp), &unsignedp, 
+	      != promote_mode (type, DECL_MODE (exp), &unsignedp,
 			       (TREE_CODE (exp) == RESULT_DECL ? 1 : 0)))
 	    abort ();
 
@@ -6773,9 +6773,9 @@
 			&& (! MOVE_BY_PIECES_P
 			    (tree_low_cst (TYPE_SIZE_UNIT (type), 1),
 			     TYPE_ALIGN (type)))
- 			&& ((TREE_CODE (type) == VECTOR_TYPE
- 			     && !is_zeros_p (exp))
- 			    || ! mostly_zeros_p (exp)))))
+			&& ((TREE_CODE (type) == VECTOR_TYPE
+			     && !is_zeros_p (exp))
+			    || ! mostly_zeros_p (exp)))))
 	       || (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp)))
 	{
 	  rtx constructor = output_constant_def (exp, 1);
@@ -6812,14 +6812,14 @@
 	tree string = string_constant (exp1, &index);
 
 	/* Try to optimize reads from const strings.  */
- 	if (string
- 	    && TREE_CODE (string) == STRING_CST
- 	    && TREE_CODE (index) == INTEGER_CST
+	if (string
+	    && TREE_CODE (string) == STRING_CST
+	    && TREE_CODE (index) == INTEGER_CST
 	    && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
- 	    && GET_MODE_CLASS (mode) == MODE_INT
- 	    && GET_MODE_SIZE (mode) == 1
+	    && GET_MODE_CLASS (mode) == MODE_INT
+	    && GET_MODE_SIZE (mode) == 1
 	    && modifier != EXPAND_WRITE)
- 	  return gen_int_mode (TREE_STRING_POINTER (string)
+	  return gen_int_mode (TREE_STRING_POINTER (string)
 			       [TREE_INT_CST_LOW (index)], mode);
 
 	op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
@@ -7428,7 +7428,7 @@
 	  && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
 	      == FUNCTION_DECL)
 	  && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
-        {
+	{
 	  if (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
 	      == BUILT_IN_FRONTEND)
 	    return (*lang_hooks.expand_expr)
@@ -7511,7 +7511,7 @@
 	  tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
 	  enum machine_mode inner_mode = TYPE_MODE (inner_type);
 
-          if (modifier == EXPAND_INITIALIZER)
+	  if (modifier == EXPAND_INITIALIZER)
 	    return simplify_gen_subreg (mode, op0, inner_mode,
 					subreg_lowpart_offset (mode,
 							       inner_mode));
@@ -7598,7 +7598,7 @@
 
 	      op0 = new;
 	    }
-      
+
 	  op0 = adjust_address (op0, TYPE_MODE (type), 0);
 	}
 
@@ -7645,7 +7645,7 @@
 
 	 If this is an EXPAND_SUM call, always return the sum.  */
       if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
-          || (mode == ptr_mode && (unsignedp || ! flag_trapv)))
+	  || (mode == ptr_mode && (unsignedp || ! flag_trapv)))
 	{
 	  if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
 	      && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
@@ -7994,9 +7994,9 @@
     case NEGATE_EXPR:
       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
       temp = expand_unop (mode,
-                          ! unsignedp && flag_trapv
-                          && (GET_MODE_CLASS(mode) == MODE_INT)
-                          ? negv_optab : neg_optab, op0, target, 0);
+			  ! unsignedp && flag_trapv
+			  && (GET_MODE_CLASS(mode) == MODE_INT)
+			  ? negv_optab : neg_optab, op0, target, 0);
       if (temp == 0)
 	abort ();
       return temp;
@@ -8172,7 +8172,7 @@
 	      enum machine_mode mode1 = GET_MODE (temp);
 	      if (mode1 == VOIDmode)
 		mode1 = tmode != VOIDmode ? tmode : mode;
-	      
+
 	      temp = copy_to_mode_reg (mode1, temp);
 	    }
 
@@ -8352,13 +8352,13 @@
 	  {
 	    rtx result;
 	    optab boptab = (TREE_CODE (binary_op) == PLUS_EXPR
-                            ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
-                               ? addv_optab : add_optab)
-                            : TREE_CODE (binary_op) == MINUS_EXPR
-                              ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
-                                 ? subv_optab : sub_optab)
-                            : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab
-                            : xor_optab);
+			    ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
+			       ? addv_optab : add_optab)
+			    : TREE_CODE (binary_op) == MINUS_EXPR
+			    ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
+			       ? subv_optab : sub_optab)
+			    : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab
+			    : xor_optab);
 
 	    /* If we had X ? A : A + 1, do this as A + (X == 0).
 
@@ -8673,7 +8673,7 @@
 	  }
 
 	temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
-	
+
 	return temp;
       }
 
@@ -8762,11 +8762,11 @@
 		    /* Handle calls that pass values in multiple
 		       non-contiguous locations.  The Irix 6 ABI has examples
 		       of this.  */
-		    emit_group_store (memloc, op0, 
+		    emit_group_store (memloc, op0,
 				      int_size_in_bytes (inner_type));
 		  else
 		    emit_move_insn (memloc, op0);
-		  
+
 		  op0 = memloc;
 		}
 	    }
@@ -8904,9 +8904,9 @@
 
 	imag_t = gen_imagpart (partmode, target);
 	temp = expand_unop (partmode,
-                            ! unsignedp && flag_trapv
-                            && (GET_MODE_CLASS(partmode) == MODE_INT)
-                            ? negv_optab : neg_optab,
+			    ! unsignedp && flag_trapv
+			    && (GET_MODE_CLASS(partmode) == MODE_INT)
+			    ? negv_optab : neg_optab,
 			    gen_imagpart (partmode, op0), imag_t, 0);
 	if (temp != imag_t)
 	  emit_move_insn (imag_t, temp);
@@ -9737,7 +9737,7 @@
 		|| rcmp == UNORDERED))
 	  do_rev = 1;
 
-        if (! do_rev)
+	if (! do_rev)
 	  do_compare_and_jump (exp, cmp, cmp, if_false_label, if_true_label);
 	else
 	  do_compare_and_jump (exp, rcmp, rcmp, if_true_label, if_false_label);
@@ -9770,7 +9770,7 @@
 	goto unordered_bcc;
 
       unordered_bcc:
-        mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
+	mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 	if (can_compare_p (rcode1, mode, ccp_jump))
 	  do_compare_and_jump (exp, rcode1, rcode1, if_false_label,
 			       if_true_label);
@@ -9839,7 +9839,7 @@
       /* Do any postincrements in the expression that was tested.  */
       emit_queue ();
 
-      if (GET_CODE (temp) == CONST_INT 
+      if (GET_CODE (temp) == CONST_INT
 	  || (GET_CODE (temp) == CONST_DOUBLE && GET_MODE (temp) == VOIDmode)
 	  || GET_CODE (temp) == LABEL_REF)
 	{
Index: expr.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/expr.h,v
retrieving revision 1.114
diff -u -r1.114 expr.h
--- expr.h	30 May 2002 21:33:32 -0000	1.114
+++ expr.h	3 Jun 2002 01:07:50 -0000
@@ -132,7 +132,7 @@
 /* Supply a default definition for FUNCTION_ARG_BOUNDARY.  Normally, we let
    FUNCTION_ARG_PADDING, which also pads the length, handle any needed
    alignment.  */
-  
+
 #ifndef FUNCTION_ARG_BOUNDARY
 #define FUNCTION_ARG_BOUNDARY(MODE, TYPE)	PARM_BOUNDARY
 #endif
@@ -289,7 +289,7 @@
 extern int have_add2_insn PARAMS ((rtx, rtx));
 extern int have_sub2_insn PARAMS ((rtx, rtx));
 
-/* Emit a pair of rtl insns to compare two rtx's and to jump 
+/* Emit a pair of rtl insns to compare two rtx's and to jump
    to a label if the comparison is true.  */
 extern void emit_cmp_and_jump_insns PARAMS ((rtx, rtx, enum rtx_code, rtx,
 					     enum machine_mode, int, rtx));
@@ -727,7 +727,7 @@
    says how many bytes.  */
 extern rtx allocate_dynamic_stack_space PARAMS ((rtx, rtx, int));
 
-/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 
+/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
    FIRST is a constant and size is a Pmode RTX.  These are offsets from the
    current stack pointer.  STACK_GROWS_DOWNWARD says whether to add or
    subtract from the stack.  If SIZE is constant, this is done



More information about the Gcc-patches mailing list