Fix indentation problems

From-SVN: r29027

1 files changed, 136 insertions, 136 deletions

diff --git a/gcc/reload.c b/gcc/reload.c
index 46479ac..1ebe140 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -161,7 +161,7 @@ a register with any other reload.  */
 			   or more reloads.
    reload_secondary_in_reload
    reload_secondary_out_reload
-   			  int, gives the reload number of a secondary
+			  int, gives the reload number of a secondary
 			   reload, when needed; otherwise -1
    reload_secondary_in_icode
    reload_secondary_out_icode
@@ -237,9 +237,9 @@ struct decomposition
 #ifdef SECONDARY_MEMORY_NEEDED
 
 /* Save MEMs needed to copy from one class of registers to another.  One MEM
-   is used per mode, but normally only one or two modes are ever used.  
+   is used per mode, but normally only one or two modes are ever used.
 
-   We keep two versions, before and after register elimination.  The one 
+   We keep two versions, before and after register elimination.  The one
    after register elimination is record separately for each operand.  This
    is done in case the address is not valid to be sure that we separately
    reload each.  */
@@ -439,7 +439,7 @@ push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
 
   if (icode != CODE_FOR_nothing)
     {
-      /* If IN_P is non-zero, the reload register will be the output in 
+      /* If IN_P is non-zero, the reload register will be the output in
 	 operand 0.  If IN_P is zero, the reload register will be the input
 	 in operand 1.  Outputs should have an initial "=", which we must
 	 skip.  */
@@ -587,7 +587,7 @@ push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
 #ifdef SECONDARY_MEMORY_NEEDED
       /* If we need a memory location to copy between the two reload regs,
 	 set it up now.  Note that we do the input case before making
-	 the reload and the output case after.  This is due to the 
+	 the reload and the output case after.  This is due to the
 	 way reloads are output.  */
 
       if (in_p && icode == CODE_FOR_nothing
@@ -613,7 +613,7 @@ push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
       reload_when_needed[s_reload] = secondary_type;
       reload_secondary_in_reload[s_reload] = in_p ? t_reload : -1;
       reload_secondary_out_reload[s_reload] = ! in_p ? t_reload : -1;
-      reload_secondary_in_icode[s_reload] = in_p ? t_icode : CODE_FOR_nothing; 
+      reload_secondary_in_icode[s_reload] = in_p ? t_icode : CODE_FOR_nothing;
       reload_secondary_out_icode[s_reload]
 	= ! in_p ? t_icode : CODE_FOR_nothing;
       reload_secondary_p[s_reload] = 1;
@@ -634,7 +634,7 @@ push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
 
 #ifdef SECONDARY_MEMORY_NEEDED
 
-/* Return a memory location that will be used to copy X in mode MODE.  
+/* Return a memory location that will be used to copy X in mode MODE.
    If we haven't already made a location for this mode in this insn,
    call find_reloads_address on the location being returned.  */
 
@@ -664,7 +664,7 @@ get_secondary_mem (x, mode, opnum, type)
   if (secondary_memlocs_elim[(int) mode][opnum] != 0)
     return secondary_memlocs_elim[(int) mode][opnum];
 
-  /* If this is the first time we've tried to get a MEM for this mode, 
+  /* If this is the first time we've tried to get a MEM for this mode,
      allocate a new one.  `something_changed' in reload will get set
      by noticing that the frame size has changed.  */
 
@@ -774,12 +774,12 @@ find_reusable_reload (p_in, out, class, type, opnum, dont_share)
   /* We can use an existing reload if the class is right
      and at least one of IN and OUT is a match
      and the other is at worst neutral.
-     (A zero compared against anything is neutral.) 
+     (A zero compared against anything is neutral.)
 
      If SMALL_REGISTER_CLASSES, don't use existing reloads unless they are
      for the same thing since that can cause us to need more reload registers
      than we otherwise would.  */
-   
+
   for (i = 0; i < n_reloads; i++)
     if ((reg_class_subset_p (class, reload_reg_class[i])
 	 || reg_class_subset_p (reload_reg_class[i], class))
@@ -794,8 +794,8 @@ find_reusable_reload (p_in, out, class, type, opnum, dont_share)
 	     && (in == 0 || reload_in[i] == 0 || MATCHES (reload_in[i], in))))
 	&& (reload_out[i] == 0 || ! earlyclobber_operand_p (reload_out[i]))
 	&& (reg_class_size[(int) class] == 1 || SMALL_REGISTER_CLASSES)
-	    && MERGABLE_RELOADS (type, reload_when_needed[i],
-				 opnum, reload_opnum[i]))
+	&& MERGABLE_RELOADS (type, reload_when_needed[i],
+			     opnum, reload_opnum[i]))
       return i;
 
   /* Reloading a plain reg for input can match a reload to postincrement
@@ -900,7 +900,7 @@ push_reload (in, out, inloc, outloc, class,
   if (outmode == VOIDmode && out != 0)
     outmode = GET_MODE (out);
 
-  /* If IN is a pseudo register everywhere-equivalent to a constant, and 
+  /* If IN is a pseudo register everywhere-equivalent to a constant, and
      it is not in a hard register, reload straight from the constant,
      since we want to get rid of such pseudo registers.
      Often this is done earlier, but not always in find_reloads_address.  */
@@ -1104,7 +1104,7 @@ push_reload (in, out, inloc, outloc, class,
 			  ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) - 1)
 			   / UNITS_PER_WORD)))
 #endif
-	          ))
+		  ))
 	  || (GET_CODE (SUBREG_REG (out)) == REG
 	      && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
 	      && ((GET_MODE_SIZE (outmode) <= UNITS_PER_WORD
@@ -1137,9 +1137,9 @@ push_reload (in, out, inloc, outloc, class,
     {
       out_subreg_loc = outloc;
       outloc = &SUBREG_REG (out);
-      out = *outloc; 
+      out = *outloc;
 #if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
-     if (GET_CODE (out) == MEM
+      if (GET_CODE (out) == MEM
 	  && GET_MODE_SIZE (GET_MODE (out)) > GET_MODE_SIZE (outmode))
 	abort ();
 #endif
@@ -1304,7 +1304,7 @@ push_reload (in, out, inloc, outloc, class,
       if (in != 0 && GET_CODE (in) == REG
 	  && REGNO (in) < FIRST_PSEUDO_REGISTER
 	  && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (REGNO (in)),
-				     class, inmode))
+				      class, inmode))
 	get_secondary_mem (in, inmode, opnum, type);
 #endif
 
@@ -1634,10 +1634,10 @@ loc_mentioned_in_p (loc, in)
       if (loc == &in->fld[i].rtx)
 	return 1;
       if (fmt[i] == 'e')
-        {
+	{
 	  if (loc_mentioned_in_p (loc, XEXP (in, i)))
 	    return 1;
-        }
+	}
       else if (fmt[i] == 'E')
 	for (j = XVECLEN (in, i) - 1; i >= 0; i--)
 	  if (loc_mentioned_in_p (loc, XVECEXP (in, i, j)))
@@ -1806,10 +1806,10 @@ combine_reloads ()
 	    <= HARD_REGNO_NREGS (REGNO (XEXP (note, 0)), GET_MODE (XEXP (note, 0))))
 	/* Ensure that a secondary or tertiary reload for this output
 	   won't want this register.  */
-        && ((secondary_out = reload_secondary_out_reload[output_reload]) == -1
-            || (! (TEST_HARD_REG_BIT
-		    (reg_class_contents[(int) reload_reg_class[secondary_out]],
-		     REGNO (XEXP (note, 0))))
+	&& ((secondary_out = reload_secondary_out_reload[output_reload]) == -1
+	    || (! (TEST_HARD_REG_BIT
+		   (reg_class_contents[(int) reload_reg_class[secondary_out]],
+		    REGNO (XEXP (note, 0))))
 		&& ((secondary_out = reload_secondary_out_reload[secondary_out]) == -1
 		    ||  ! (TEST_HARD_REG_BIT
 			   (reg_class_contents[(int) reload_reg_class[secondary_out]],
@@ -2077,7 +2077,7 @@ operands_match_p (x, y)
   register RTX_CODE code = GET_CODE (x);
   register const char *fmt;
   int success_2;
-      
+
   if (x == y)
     return 1;
   if ((code == REG || (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG))
@@ -2136,7 +2136,7 @@ operands_match_p (x, y)
 
  slow:
 
-  /* Now we have disposed of all the cases 
+  /* Now we have disposed of all the cases
      in which different rtx codes can match.  */
   if (code != GET_CODE (y))
     return 0;
@@ -2207,11 +2207,11 @@ operands_match_p (x, y)
 }
 
 /* Describe the range of registers or memory referenced by X.
-   If X is a register, set REG_FLAG and put the first register 
+   If X is a register, set REG_FLAG and put the first register
    number into START and the last plus one into END.
-   If X is a memory reference, put a base address into BASE 
+   If X is a memory reference, put a base address into BASE
    and a range of integer offsets into START and END.
-   If X is pushing on the stack, we can assume it causes no trouble, 
+   If X is pushing on the stack, we can assume it causes no trouble,
    so we set the SAFE field.  */
 
 static struct decomposition
@@ -2262,7 +2262,7 @@ decompose (x)
 	{
 	  base = addr;
 	  offset = const0_rtx;
-	} 
+	}
       if (GET_CODE (offset) == CONST)
 	offset = XEXP (offset, 0);
       if (GET_CODE (offset) == PLUS)
@@ -2303,7 +2303,7 @@ decompose (x)
   else if (GET_CODE (x) == REG)
     {
       val.reg_flag = 1;
-      val.start = true_regnum (x); 
+      val.start = true_regnum (x);
       if (val.start < 0)
 	{
 	  /* A pseudo with no hard reg.  */
@@ -2320,7 +2320,7 @@ decompose (x)
 	/* This could be more precise, but it's good enough.  */
 	return decompose (SUBREG_REG (x));
       val.reg_flag = 1;
-      val.start = true_regnum (x); 
+      val.start = true_regnum (x);
       if (val.start < 0)
 	return decompose (SUBREG_REG (x));
       else
@@ -2496,7 +2496,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
   if (reg_set_p (cc0_rtx, PATTERN (insn)))
     no_output_reloads = 1;
 #endif
-     
+
 #ifdef SECONDARY_MEMORY_NEEDED
   /* The eliminated forms of any secondary memory locations are per-insn, so
      clear them out here.  */
@@ -2550,7 +2550,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 
       modified[i] = RELOAD_READ;
 
-      /* Scan this operand's constraint to see if it is an output operand, 
+      /* Scan this operand's constraint to see if it is an output operand,
 	 an in-out operand, is commutative, or should match another.  */
 
       while ((c = *p++))
@@ -2605,7 +2605,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
      and reload parts of the addresses into index registers.
      Also here any references to pseudo regs that didn't get hard regs
      but are equivalent to constants get replaced in the insn itself
-     with those constants.  Nobody will ever see them again. 
+     with those constants.  Nobody will ever see them again.
 
      Finally, set up the preferred classes of each operand.  */
 
@@ -2631,7 +2631,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 				recog_operand[i], recog_operand_loc[i],
 				i, operand_type[i], ind_levels, insn);
 
-	  /* If we now have a simple operand where we used to have a 
+	  /* If we now have a simple operand where we used to have a
 	     PLUS or MULT, re-recognize and try again.  */
 	  if ((GET_RTX_CLASS (GET_CODE (*recog_operand_loc[i])) == 'o'
 	       || GET_CODE (*recog_operand_loc[i]) == SUBREG)
@@ -2670,14 +2670,14 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	     that didn't get a hard register, emit a USE with a REG_EQUAL
 	     note in front so that we might inherit a previous, possibly
 	     wider reload.  */
-	     
+
 	  if (replace
 	      && GET_CODE (op) == MEM
 	      && GET_CODE (reg) == REG
 	      && (GET_MODE_SIZE (GET_MODE (reg))
 		  >= GET_MODE_SIZE (GET_MODE (op))))
-            REG_NOTES (emit_insn_before (gen_rtx_USE (VOIDmode, reg), insn))
-              = gen_rtx_EXPR_LIST (REG_EQUAL,
+	    REG_NOTES (emit_insn_before (gen_rtx_USE (VOIDmode, reg), insn))
+	      = gen_rtx_EXPR_LIST (REG_EQUAL,
 				   reg_equiv_memory_loc[REGNO (reg)], NULL_RTX);
 
 	  substed_operand[i] = recog_operand[i] = op;
@@ -2702,13 +2702,13 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	      && (set == 0 || &SET_DEST (set) != recog_operand_loc[i]))
 	    {
 	      /* Record the existing mode so that the check if constants are
-	         allowed will work when operand_mode isn't specified. */
+		 allowed will work when operand_mode isn't specified. */
 
 	      if (operand_mode[i] == VOIDmode)
 		operand_mode[i] = GET_MODE (recog_operand[i]);
 
 	      substed_operand[i] = recog_operand[i]
-	        = reg_equiv_constant[regno];
+		= reg_equiv_constant[regno];
 	    }
 	  if (reg_equiv_memory_loc[regno] != 0
 	      && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
@@ -2780,7 +2780,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
       /* REJECT is a count of how undesirable this alternative says it is
 	 if any reloading is required.  If the alternative matches exactly
 	 then REJECT is ignored, but otherwise it gets this much
-	 counted against it in addition to the reloading needed.  Each 
+	 counted against it in addition to the reloading needed.  Each
 	 ? counts three times here since we want the disparaging caused by
 	 a bad register class to only count 1/3 as much.  */
       int reject = 0;
@@ -2808,7 +2808,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	  int earlyclobber = 0;
 
 	  /* If the predicate accepts a unary operator, it means that
-             we need to reload the operand, but do not do this for
+	     we need to reload the operand, but do not do this for
 	     match_operator and friends.  */
 	  if (GET_RTX_CLASS (GET_CODE (operand)) == '1' && *p != 0)
 	    operand = XEXP (operand, 0);
@@ -2838,10 +2838,10 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 		     made assumptions about the behavior of the machine in such
 		     register access.  If the data is, in fact, in memory we
 		     must always load using the size assumed to be in the
-		     register and let the insn do the different-sized 
+		     register and let the insn do the different-sized
 		     accesses.
 
-		     This is doubly true if WORD_REGISTER_OPERATIONS.  In 
+		     This is doubly true if WORD_REGISTER_OPERATIONS.  In
 		     this case eliminate_regs has left non-paradoxical
 		     subregs for push_reloads to see.  Make sure it does
 		     by forcing the reload.
@@ -2955,10 +2955,10 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 		       don't exchange them, because operands_match is valid
 		       only on one side of its diagonal.  */
 		    ? (operands_match
-		        [(c == commutative || c == commutative + 1)
-			 ? 2*commutative + 1 - c : c]
-		        [(i == commutative || i == commutative + 1)
-			 ? 2*commutative + 1 - i : i])
+		       [(c == commutative || c == commutative + 1)
+		       ? 2*commutative + 1 - c : c]
+		       [(i == commutative || i == commutative + 1)
+		       ? 2*commutative + 1 - i : i])
 		    : operands_match[c][i])
 		  {
 		    /* If we are matching a non-offsettable address where an
@@ -3176,8 +3176,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 		    /* A SCRATCH is not a valid operand.  */
 		    && GET_CODE (operand) != SCRATCH
 #ifdef LEGITIMATE_PIC_OPERAND_P
-		    && (! CONSTANT_P (operand) 
-			|| ! flag_pic 
+		    && (! CONSTANT_P (operand)
+			|| ! flag_pic
 			|| LEGITIMATE_PIC_OPERAND_P (operand))
 #endif
 		    && (GENERAL_REGS == ALL_REGS
@@ -3193,20 +3193,20 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 		goto reg;
 
 #ifdef EXTRA_CONSTRAINT
-              case 'Q':
-              case 'R':
-              case 'S':
-              case 'T':
-              case 'U':
+	      case 'Q':
+	      case 'R':
+	      case 'S':
+	      case 'T':
+	      case 'U':
 		if (EXTRA_CONSTRAINT (operand, c))
 		  win = 1;
 		break;
 #endif
-  
+
 	      default:
 		this_alternative[i]
 		  = (int) reg_class_subunion[this_alternative[i]][(int) REG_CLASS_FROM_LETTER (c)];
-		
+
 	      reg:
 		if (GET_MODE (operand) == BLKmode)
 		  break;
@@ -3247,7 +3247,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	      /* If this is a pseudo-register that is set in the previous
 		 insns, there's a good chance that it will already be in a
 		 spill register and we can use that spill register.  So
-		 make this case cheaper. 
+		 make this case cheaper.
 
 		 Disabled for egcs.  egcs has better inheritance code and
 		 this change causes problems with the improved reload
@@ -3263,14 +3263,14 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 		 reload.  This is consistent with other code and is
 		 required to avoid choosing another alternative when
 		 the constant is moved into memory by this function on
-		 an early reload pass.  Note that the test here is 
+		 an early reload pass.  Note that the test here is
 		 precisely the same as in the code below that calls
 		 force_const_mem.  */
 	      if (CONSTANT_P (operand)
 		  /* force_const_mem does not accept HIGH.  */
 		  && GET_CODE (operand) != HIGH
 		  && ((PREFERRED_RELOAD_CLASS (operand,
-					      (enum reg_class) this_alternative[i])
+					       (enum reg_class) this_alternative[i])
 		       == NO_REGS)
 		      || no_input_reloads)
 		  && operand_mode[i] != VOIDmode)
@@ -3296,8 +3296,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 		 permitted for this insn.  We can always reload SCRATCH
 		 and objects with a REG_UNUSED note.  */
 	      else if (GET_CODE (operand) != SCRATCH
-		  && modified[i] != RELOAD_READ && no_output_reloads
-		  && ! find_reg_note (insn, REG_UNUSED, operand))
+		       && modified[i] != RELOAD_READ && no_output_reloads
+		       && ! find_reg_note (insn, REG_UNUSED, operand))
 		bad = 1;
 	      else if (modified[i] != RELOAD_WRITE && no_input_reloads
 		       && ! const_to_mem)
@@ -3307,7 +3307,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	      /* We prefer to reload pseudos over reloading other things,
 		 since such reloads may be able to be eliminated later.
 		 If we are reloading a SCRATCH, we won't be generating any
-		 insns, just using a register, so it is also preferred. 
+		 insns, just using a register, so it is also preferred.
 		 So bump REJECT in other cases.  Don't do this in the
 		 case where we are forcing a constant into memory and
 		 it will then win since we don't want to have a different
@@ -3325,7 +3325,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 		reject++;
 	    }
 
-	  /* If this operand is a pseudo register that didn't get a hard 
+	  /* If this operand is a pseudo register that didn't get a hard
 	     reg and this alternative accepts some register, see if the
 	     class that we want is a subset of the preferred class for this
 	     register.  If not, but it intersects that class, use the
@@ -3356,7 +3356,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 		{
 		  /* Since we don't have a way of forming the intersection,
 		     we just do something special if the preferred class
-		     is a subset of the class we have; that's the most 
+		     is a subset of the class we have; that's the most
 		     common case anyway.  */
 		  if (reg_class_subset_p (preferred_class[i],
 					  this_alternative[i]))
@@ -3375,13 +3375,13 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	if (this_alternative_earlyclobber[i]
 	    && this_alternative_win[i])
 	  {
-	    struct decomposition early_data; 
+	    struct decomposition early_data;
 
 	    early_data = decompose (recog_operand[i]);
 
 	    if (modified[i] == RELOAD_READ)
 	      abort ();
-	    
+
 	    if (this_alternative[i] == NO_REGS)
 	      {
 		this_alternative_earlyclobber[i] = 0;
@@ -3600,9 +3600,9 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 
 	 One special case that is worth checking is when we have an
 	 output that is earlyclobber but isn't used past the insn (typically
-	 a SCRATCH).  In this case, we only need have the reload live 
+	 a SCRATCH).  In this case, we only need have the reload live
 	 through the insn itself, but not for any of our input or output
-	 reloads. 
+	 reloads.
 	 But we must not accidentally narrow the scope of an existing
 	 RELOAD_OTHER reload - leave these alone.
 
@@ -3623,7 +3623,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	/* force_const_mem does not accept HIGH.  */
 	&& GET_CODE (recog_operand[i]) != HIGH
 	&& ((PREFERRED_RELOAD_CLASS (recog_operand[i],
-				    (enum reg_class) goal_alternative[i])
+				     (enum reg_class) goal_alternative[i])
 	     == NO_REGS)
 	    || no_input_reloads)
 	&& operand_mode[i] != VOIDmode)
@@ -3763,7 +3763,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	     && goal_alternative_matches[i] < 0
 	     && optimize)
       {
-	/* For each non-matching operand that's a MEM or a pseudo-register 
+	/* For each non-matching operand that's a MEM or a pseudo-register
 	   that didn't get a hard register, make an optional reload.
 	   This may get done even if the insn needs no reloads otherwise.  */
 
@@ -3857,7 +3857,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 			   operand_mode[i],
 			   0, 1, goal_alternative_matches[i], RELOAD_OTHER);
       }
-  
+
   /* Perform whatever substitutions on the operands we are supposed
      to make due to commutativity or replacement of registers
      with equivalent constants or memory slots.  */
@@ -3865,9 +3865,9 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
   for (i = 0; i < noperands; i++)
     {
       /* We only do this on the last pass through reload, because it is
-       possible for some data (like reg_equiv_address) to be changed during
-       later passes.  Moreover, we loose the opportunity to get a useful
-       reload_{in,out}_reg when we do these replacements.  */
+	 possible for some data (like reg_equiv_address) to be changed during
+	 later passes.  Moreover, we loose the opportunity to get a useful
+	 reload_{in,out}_reg when we do these replacements.  */
 
       if (replace)
 	{
@@ -3978,7 +3978,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	  }
     }
 
-  /* Scan all the reloads and update their type. 
+  /* Scan all the reloads and update their type.
      If a reload is for the address of an operand and we didn't reload
      that operand, change the type.  Similarly, change the operand number
      of a reload when two operands match.  If a reload is optional, treat it
@@ -4023,7 +4023,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	      /* If there's a tertiary reload we have to change it also.  */
 	      if (secondary_in_reload > 0
 		  && reload_secondary_in_reload[secondary_in_reload] != -1)
-		reload_when_needed[reload_secondary_in_reload[secondary_in_reload]] 
+		reload_when_needed[reload_secondary_in_reload[secondary_in_reload]]
 		  = RELOAD_FOR_OPADDR_ADDR;
 	    }
 
@@ -4039,7 +4039,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	      /* If there's a tertiary reload we have to change it also.  */
 	      if (secondary_out_reload
 		  && reload_secondary_out_reload[secondary_out_reload] != -1)
-		reload_when_needed[reload_secondary_out_reload[secondary_out_reload]] 
+		reload_when_needed[reload_secondary_out_reload[secondary_out_reload]]
 		  = RELOAD_FOR_OPADDR_ADDR;
 	    }
 
@@ -4053,7 +4053,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
       if ((reload_when_needed[i] == RELOAD_FOR_INPUT_ADDRESS
 	   || reload_when_needed[i] == RELOAD_FOR_INPADDR_ADDRESS)
 	  && operand_reloadnum[reload_opnum[i]] >= 0
-	  && (reload_when_needed[operand_reloadnum[reload_opnum[i]]] 
+	  && (reload_when_needed[operand_reloadnum[reload_opnum[i]]]
 	      == RELOAD_OTHER))
 	reload_when_needed[i] = RELOAD_FOR_OTHER_ADDRESS;
 
@@ -4392,8 +4392,8 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn)
       if (reg_equiv_constant[regno] != 0 && !is_set_dest)
 	x = reg_equiv_constant[regno];
 #if 0
-/*  This creates (subreg (mem...)) which would cause an unnecessary
-    reload of the mem.  */
+      /*  This creates (subreg (mem...)) which would cause an unnecessary
+	  reload of the mem.  */
       else if (reg_equiv_mem[regno] != 0)
 	x = reg_equiv_mem[regno];
 #endif
@@ -4426,7 +4426,7 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn)
 
   if (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG)
     {
-      /* Check for SUBREG containing a REG that's equivalent to a constant. 
+      /* Check for SUBREG containing a REG that's equivalent to a constant.
 	 If the constant has a known value, truncate it right now.
 	 Similarly if we are extracting a single-word of a multi-word
 	 constant.  If the constant is symbolic, allow it to be substituted
@@ -4474,18 +4474,18 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn)
 	  && GET_CODE (reg_equiv_constant[regno]) == CONST_INT
 	  && (GET_MODE_SIZE (GET_MODE (x))
 	      < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
-	  {
-	    int shift = SUBREG_WORD (x) * BITS_PER_WORD;
-	    if (WORDS_BIG_ENDIAN)
-	      shift = (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
-		       - GET_MODE_BITSIZE (GET_MODE (x))
-		       - shift);
-	    /* Here we use the knowledge that CONST_INTs have a
-	       HOST_WIDE_INT field.  */
-	    if (shift >= HOST_BITS_PER_WIDE_INT)
-	      shift = HOST_BITS_PER_WIDE_INT - 1;
-	    return GEN_INT (INTVAL (reg_equiv_constant[regno]) >> shift);
-	  }
+	{
+	  int shift = SUBREG_WORD (x) * BITS_PER_WORD;
+	  if (WORDS_BIG_ENDIAN)
+	    shift = (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
+		     - GET_MODE_BITSIZE (GET_MODE (x))
+		     - shift);
+	  /* Here we use the knowledge that CONST_INTs have a
+	     HOST_WIDE_INT field.  */
+	  if (shift >= HOST_BITS_PER_WIDE_INT)
+	    shift = HOST_BITS_PER_WIDE_INT - 1;
+	  return GEN_INT (INTVAL (reg_equiv_constant[regno]) >> shift);
+	}
 
       if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
 	  && reg_equiv_constant[regno] != 0
@@ -4512,7 +4512,7 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn)
 #endif
 	       && (reg_equiv_address[regno] != 0
 		   || (reg_equiv_mem[regno] != 0
-		       && (! strict_memory_address_p (GET_MODE (x), 
+		       && (! strict_memory_address_p (GET_MODE (x),
 						      XEXP (reg_equiv_mem[regno], 0))
 			   || ! offsettable_memref_p (reg_equiv_mem[regno])
 			   || num_not_at_initial_offset))))
@@ -4827,7 +4827,7 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
   /* If we have an indexed stack slot, there are three possible reasons why
      it might be invalid: The index might need to be reloaded, the address
      might have been made by frame pointer elimination and hence have a
-     constant out of range, or both reasons might apply.  
+     constant out of range, or both reasons might apply.
 
      We can easily check for an index needing reload, but even if that is the
      case, we might also have an invalid constant.  To avoid making the
@@ -4868,7 +4868,7 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
       *loc = ad = gen_rtx_PLUS (GET_MODE (ad),
 				plus_constant (XEXP (XEXP (ad, 0), 0),
 					       INTVAL (XEXP (ad, 1))),
-			   XEXP (XEXP (ad, 0), 1));
+				XEXP (XEXP (ad, 0), 1));
       find_reloads_address_part (XEXP (ad, 0), &XEXP (ad, 0), BASE_REG_CLASS,
 				 GET_MODE (ad), opnum, type, ind_levels);
       find_reloads_address_1 (mode, XEXP (ad, 1), 1, &XEXP (ad, 1), opnum,
@@ -4876,7 +4876,7 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
 
       return 0;
     }
-			   
+
   else if (GET_CODE (ad) == PLUS && GET_CODE (XEXP (ad, 1)) == CONST_INT
 	   && GET_CODE (XEXP (ad, 0)) == PLUS
 	   && (XEXP (XEXP (ad, 0), 1) == frame_pointer_rtx
@@ -4900,7 +4900,7 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
 
       return 0;
     }
-			   
+
   /* See if address becomes valid when an eliminable register
      in a sum is replaced.  */
 
@@ -5003,7 +5003,7 @@ subst_reg_equivs (ad, insn)
 	  && GET_CODE (XEXP (ad, 1)) == CONST_INT)
 	return ad;
       break;
-      
+
     default:
       break;
     }
@@ -5095,9 +5095,9 @@ subst_indexed_address (addr)
 	  && reg_equiv_constant[regno] != 0)
 	op0 = reg_equiv_constant[regno];
       else if (GET_CODE (op1) == REG
-	  && (regno = REGNO (op1)) >= FIRST_PSEUDO_REGISTER
-	  && reg_renumber[regno] < 0
-	  && reg_equiv_constant[regno] != 0)
+	       && (regno = REGNO (op1)) >= FIRST_PSEUDO_REGISTER
+	       && reg_renumber[regno] < 0
+	       && reg_equiv_constant[regno] != 0)
 	op1 = reg_equiv_constant[regno];
       else if (GET_CODE (op0) == PLUS
 	       && (tem = subst_indexed_address (op0)) != op0)
@@ -5191,7 +5191,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
 				 REGNO (op1) + SUBREG_WORD (orig_op1));
 	  }
 
-	if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE 
+	if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
 	    || code0 == ZERO_EXTEND || code1 == MEM)
 	  {
 	    find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
@@ -5352,8 +5352,8 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
 		  reloadnum
 		    = push_reload (x, x, loc, loc,
 				   (context ? INDEX_REG_CLASS : BASE_REG_CLASS),
-				    GET_MODE (x), GET_MODE (x), 0, 0,
-				    opnum, RELOAD_OTHER);
+				   GET_MODE (x), GET_MODE (x), 0, 0,
+				   opnum, RELOAD_OTHER);
 
 		  /* If we created a new MEM based on reg_equiv_mem[REGNO], then
 		     LOC above is part of the new MEM, not the MEM in INSN.
@@ -5372,7 +5372,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
 				   opnum, type);
 		  reload_inc[reloadnum]
 		    = find_inc_amount (PATTERN (this_insn), XEXP (x_orig, 0));
-    
+
 		  value = 1;
 		}
 
@@ -5548,7 +5548,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
 	    }
 	}
       break;
-      
+
     default:
       break;
     }
@@ -5926,7 +5926,7 @@ refers_to_regno_for_reload_p (regno, endregno, x, loc)
 	}
 
       return (endregno > i
-	      && regno < i + (i < FIRST_PSEUDO_REGISTER 
+	      && regno < i + (i < FIRST_PSEUDO_REGISTER
 			      ? HARD_REGNO_NREGS (i, GET_MODE (x))
 			      : 1));
 
@@ -5970,7 +5970,7 @@ refers_to_regno_for_reload_p (regno, endregno, x, loc)
 	return 0;
       x = SET_SRC (x);
       goto repeat;
-      
+
     default:
       break;
     }
@@ -6009,7 +6009,7 @@ refers_to_regno_for_reload_p (regno, endregno, x, loc)
    we check if any register number in X conflicts with the relevant register
    numbers.  If X is a constant, return 0.  If X is a MEM, return 1 iff IN
    contains a MEM (we don't bother checking for memory addresses that can't
-   conflict because we expect this to be a rare case. 
+   conflict because we expect this to be a rare case.
 
    This function is similar to reg_overlap_mention_p in rtlanal.c except
    that we look at equivalences for pseudos that didn't get hard registers.  */
@@ -6079,14 +6079,14 @@ refers_to_mem_for_reload_p (x)
   if (GET_CODE (x) == REG)
     return (REGNO (x) >= FIRST_PSEUDO_REGISTER
 	    && reg_equiv_memory_loc[REGNO (x)]);
-			
+
   fmt = GET_RTX_FORMAT (GET_CODE (x));
   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
     if (fmt[i] == 'e'
 	&& (GET_CODE (XEXP (x, i)) == MEM
 	    || refers_to_mem_for_reload_p (XEXP (x, i))))
       return 1;
-  
+
   return 0;
 }
 
@@ -6178,12 +6178,12 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 
   /* On some machines, certain regs must always be rejected
      because they don't behave the way ordinary registers do.  */
-  
+
 #ifdef OVERLAPPING_REGNO_P
-   if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER
-       && OVERLAPPING_REGNO_P (regno))
-     return 0;
-#endif      
+  if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER
+      && OVERLAPPING_REGNO_P (regno))
+    return 0;
+#endif
 
   /* Scan insns back from INSN, looking for one that copies
      a value into or out of GOAL.
@@ -6198,13 +6198,13 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 	  /* If we don't want spill regs ...  */
 	  && (! (reload_reg_p != 0
 		 && reload_reg_p != (short *) (HOST_WIDE_INT) 1)
-	  /* ... then ignore insns introduced by reload; they aren't useful
-	     and can cause results in reload_as_needed to be different
-	     from what they were when calculating the need for spills.
-	     If we notice an input-reload insn here, we will reject it below,
-	     but it might hide a usable equivalent.  That makes bad code.
-	     It may even abort: perhaps no reg was spilled for this insn
-	     because it was assumed we would find that equivalent.  */
+	      /* ... then ignore insns introduced by reload; they aren't useful
+		 and can cause results in reload_as_needed to be different
+		 from what they were when calculating the need for spills.
+		 If we notice an input-reload insn here, we will reject it below,
+		 but it might hide a usable equivalent.  That makes bad code.
+		 It may even abort: perhaps no reg was spilled for this insn
+		 because it was assumed we would find that equivalent.  */
 	      || INSN_UID (p) < reload_first_uid))
 	{
 	  rtx tem;
@@ -6325,11 +6325,11 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 
   /* On some machines, certain regs must always be rejected
      because they don't behave the way ordinary registers do.  */
-  
+
 #ifdef OVERLAPPING_REGNO_P
   if (OVERLAPPING_REGNO_P (valueno))
     return 0;
-#endif      
+#endif
 
   nregs = HARD_REGNO_NREGS (regno, mode);
   valuenregs = HARD_REGNO_NREGS (valueno, mode);
@@ -6380,7 +6380,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 	      || need_stable_sp))
 	return 0;
 
-#ifdef NON_SAVING_SETJMP 
+#ifdef NON_SAVING_SETJMP
       if (NON_SAVING_SETJMP && GET_CODE (p) == NOTE
 	  && NOTE_LINE_NUMBER (p) == NOTE_INSN_SETJMP)
 	return 0;
@@ -6388,9 +6388,9 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 
 #ifdef INSN_CLOBBERS_REGNO_P
       if ((valueno >= 0 && valueno < FIRST_PSEUDO_REGISTER
-	  && INSN_CLOBBERS_REGNO_P (p, valueno))
+	   && INSN_CLOBBERS_REGNO_P (p, valueno))
 	  || (regno >= 0 && regno < FIRST_PSEUDO_REGISTER
-	  && INSN_CLOBBERS_REGNO_P (p, regno)))
+	      && INSN_CLOBBERS_REGNO_P (p, regno)))
 	return 0;
 #endif
 
@@ -6398,8 +6398,8 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 	{
 	  pat = PATTERN (p);
 
-          /* Watch out for unspec_volatile, and volatile asms.  */
-          if (volatile_insn_p (pat))
+	  /* Watch out for unspec_volatile, and volatile asms.  */
+	  if (volatile_insn_p (pat))
 	    return 0;
 
 	  /* If this insn P stores in either GOAL or VALUE, return 0.
@@ -6640,16 +6640,16 @@ regno_clobbered_p (regno, insn)
 
 static const char *reload_when_needed_name[] =
 {
-  "RELOAD_FOR_INPUT", 
-  "RELOAD_FOR_OUTPUT", 
+  "RELOAD_FOR_INPUT",
+  "RELOAD_FOR_OUTPUT",
   "RELOAD_FOR_INSN",
   "RELOAD_FOR_INPUT_ADDRESS",
   "RELOAD_FOR_INPADDR_ADDRESS",
   "RELOAD_FOR_OUTPUT_ADDRESS",
   "RELOAD_FOR_OUTADDR_ADDRESS",
-  "RELOAD_FOR_OPERAND_ADDRESS", 
+  "RELOAD_FOR_OPERAND_ADDRESS",
   "RELOAD_FOR_OPADDR_ADDR",
-  "RELOAD_OTHER", 
+  "RELOAD_OTHER",
   "RELOAD_FOR_OTHER_ADDRESS"
 };