* cse.c: Fix formatting.

From-SVN: r35675

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 94e2e03edf844295b43b2aef4c993b979f4ccd38..beaff7af77296ae9074126753031f5698fda8f06 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,7 @@
+2000-08-13  Kazu Hirata  <kazu@hxi.com>
+
+       * cse.c: Fix formatting.
+
 2000-08-13  Geoff Keating  <geoffk@cygnus.com>
 
        * flow.c (attempt_auto_inc): Remove unused variable `bb'.

diff --git a/gcc/cse.c b/gcc/cse.c
index 59921588e771af29f380a78551f1e9385da22e1f..a65cecabdfa1516d0eac95ac799d517f67b71a95 100644 (file)
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -1952,7 +1952,7 @@ remove_invalid_subreg_refs (regno, word, mode)
                || (((SUBREG_WORD (exp)
                      + (GET_MODE_SIZE (GET_MODE (exp)) - 1) / UNITS_PER_WORD)
                     >= word)
-                && SUBREG_WORD (exp) <= end))
+                   && SUBREG_WORD (exp) <= end))
            && refers_to_regno_p (regno, regno + 1, p->exp, NULL_PTR))
          remove_from_table (p, i);
       }
@@ -2240,13 +2240,11 @@ canon_hash (x, mode)
 
       /* Assume there is only one rtx object for any given label.  */
     case LABEL_REF:
-      hash
-       += ((unsigned) LABEL_REF << 7) + (unsigned long) XEXP (x, 0);
+      hash += ((unsigned) LABEL_REF << 7) + (unsigned long) XEXP (x, 0);
       return hash;
 
     case SYMBOL_REF:
-      hash
-       += ((unsigned) SYMBOL_REF << 7) + (unsigned long) XSTR (x, 0);
+      hash += ((unsigned) SYMBOL_REF << 7) + (unsigned long) XSTR (x, 0);
       return hash;
 
     case MEM:
@@ -2329,7 +2327,8 @@ canon_hash (x, mode)
          hash += tem;
        }
       else if (fmt[i] == '0' || fmt[i] == 't')
-       /* unused */;
+       /* Unused.  */
+       ;
       else
        abort ();
     }
@@ -3200,8 +3199,7 @@ fold_rtx (x, insn)
              && GET_MODE_SIZE (imode) <= UNITS_PER_WORD
              && (elt = lookup (SUBREG_REG (x), HASH (SUBREG_REG (x), imode),
                                imode)) != 0)
-           for (elt = elt->first_same_value;
-                elt; elt = elt->next_same_value)
+           for (elt = elt->first_same_value; elt; elt = elt->next_same_value)
              {
                if (CONSTANT_P (elt->exp)
                    && GET_MODE (elt->exp) == VOIDmode)
@@ -3886,7 +3884,7 @@ fold_rtx (x, insn)
            {
              rtx y
                = GET_CODE (folded_arg0) == MINUS ? folded_arg0
-                 : lookup_as_function (folded_arg0, MINUS);
+               : lookup_as_function (folded_arg0, MINUS);
 
              if (y != 0 && GET_CODE (XEXP (y, 1)) == LABEL_REF
                  && XEXP (XEXP (y, 1), 0) == XEXP (const_arg1, 0))
@@ -3897,7 +3895,7 @@ fold_rtx (x, insn)
                        : lookup_as_function (folded_arg0, CONST))) != 0
                  && GET_CODE (XEXP (y, 0)) == MINUS
                  && GET_CODE (XEXP (XEXP (y, 0), 1)) == LABEL_REF
-                 && XEXP (XEXP (XEXP (y, 0),1), 0) == XEXP (const_arg1, 0))
+                 && XEXP (XEXP (XEXP (y, 0), 1), 0) == XEXP (const_arg1, 0))
                return XEXP (XEXP (y, 0), 0);
            }
 
@@ -3906,7 +3904,7 @@ fold_rtx (x, insn)
            {
              rtx y
                = GET_CODE (folded_arg1) == MINUS ? folded_arg1
-                 : lookup_as_function (folded_arg1, MINUS);
+               : lookup_as_function (folded_arg1, MINUS);
 
              if (y != 0 && GET_CODE (XEXP (y, 1)) == LABEL_REF
                  && XEXP (XEXP (y, 1), 0) == XEXP (const_arg0, 0))
@@ -3917,7 +3915,7 @@ fold_rtx (x, insn)
                        : lookup_as_function (folded_arg1, CONST))) != 0
                  && GET_CODE (XEXP (y, 0)) == MINUS
                  && GET_CODE (XEXP (XEXP (y, 0), 1)) == LABEL_REF
-                 && XEXP (XEXP (XEXP (y, 0),1), 0) == XEXP (const_arg0, 0))
+                 && XEXP (XEXP (XEXP (y, 0), 1), 0) == XEXP (const_arg0, 0))
                return XEXP (XEXP (y, 0), 0);
            }
 
@@ -3935,7 +3933,7 @@ fold_rtx (x, insn)
              && INTVAL (const_arg1) < 0
              /* This used to test
 
-                - INTVAL (const_arg1) >= 0
+                -INTVAL (const_arg1) >= 0
 
                 But The Sun V5.0 compilers mis-compiled that test.  So
                 instead we test for the problematic value in a more direct
@@ -3944,7 +3942,7 @@ fold_rtx (x, insn)
                ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1))
              && GET_CODE (folded_arg1) == REG)
            {
-             rtx new_const = GEN_INT (- INTVAL (const_arg1));
+             rtx new_const = GEN_INT (-INTVAL (const_arg1));
              struct table_elt *p
                = lookup (new_const, safe_hash (new_const, mode) & HASH_MASK,
                          mode);
@@ -3969,7 +3967,7 @@ fold_rtx (x, insn)
                                 NULL_RTX);
            }
 
-         /* ... fall through ...  */
+         /* Fall through.  */
 
        from_plus:
        case SMIN:    case SMAX:      case UMIN:    case UMAX:
@@ -4090,7 +4088,7 @@ fold_rtx (x, insn)
       break;
 
     case 'x':
-      /* Always eliminate CONSTANT_P_RTX at this stage. */
+      /* Always eliminate CONSTANT_P_RTX at this stage.  */
       if (code == CONSTANT_P_RTX)
        return (const_arg0 ? const1_rtx : const0_rtx);
       break;
@@ -4469,7 +4467,7 @@ record_jump_cond (code, mode, op0, op1, reversed_nonequality)
 
    If LIBCALL_INSN is nonzero, don't record any equivalence made in
    the insn.  It means that INSN is inside libcall block.  In this
-   case LIBCALL_INSN is the corresponding insn with REG_LIBCALL. */
+   case LIBCALL_INSN is the corresponding insn with REG_LIBCALL.  */
 
 /* Data on one SET contained in the instruction.  */
 
@@ -5052,7 +5050,7 @@ cse_insn (insn, libcall_insn)
         also have such operations, but this is only likely to be
         beneficial these machines.  */
 
-      if (flag_expensive_optimizations &&  src_related == 0
+      if (flag_expensive_optimizations && src_related == 0
          && (GET_MODE_SIZE (mode) < UNITS_PER_WORD)
          && GET_MODE_CLASS (mode) == MODE_INT
          && GET_CODE (src) == MEM && ! do_not_record
@@ -5225,7 +5223,7 @@ cse_insn (insn, libcall_insn)
          if (elt)
            src_elt_cost = elt->cost;
 
-          /* Find cheapest and skip it for the next time.   For items
+         /* Find cheapest and skip it for the next time.   For items
             of equal cost, use this order:
             src_folded, src, src_eqv, src_related and hash table entry.  */
          if (src_folded_cost <= src_cost
@@ -5287,7 +5285,7 @@ cse_insn (insn, libcall_insn)
            }
 
          /* Look for a substitution that makes a valid insn.  */
-          else if (validate_change (insn, &SET_SRC (sets[i].rtl), trial, 0))
+         else if (validate_change (insn, &SET_SRC (sets[i].rtl), trial, 0))
            {
              /* If we just made a substitution inside a libcall, then we
                 need to make the same substitution in any notes attached
@@ -6331,7 +6329,7 @@ invalidate_skipped_set (dest, set, data)
   enum rtx_code code = GET_CODE (dest);
 
   if (code == MEM
-      && ! addr_affects_sp_p (dest)    /* If this is not a stack push ... */
+      && ! addr_affects_sp_p (dest)    /* If this is not a stack push ...  */
       /* There are times when an address can appear varying and be a PLUS
         during this scan when it would be a fixed address were we to know
         the proper equivalences.  So invalidate all memory if there is
@@ -7198,8 +7196,8 @@ count_reg_usage (x, counts, dest, incr)
 
     case CALL_INSN:
       count_reg_usage (CALL_INSN_FUNCTION_USAGE (x), counts, NULL_RTX, incr);
+      /* Fall through.  */
 
-      /* ... falls through ...  */
     case INSN:
     case JUMP_INSN:
       count_reg_usage (PATTERN (x), counts, NULL_RTX, incr);