flow.c (attempt_auto_inc): Remove unused variable `bb'.

* flow.c (attempt_auto_inc): Remove unused variable `bb'.
(attempt_auto_inc): Suppress parentheses warning.
* function.c (put_reg_into_stack): Remove unused variable `unsigned_p'.
* loop.c (load_mems): Remove `u' suffix in two places.
* config/rs6000/rs6000.c: Remove unnecessary `u' suffixes from
hex constants.
* config/rs6000/rs6000.h: Likewise.
* config/rs6000/sol-c0.c: Prototype some functions.  Remove the
__eabi dummy routine.
* config/rs6000/sysv4.h (ASM_DECLARE_FUNCTION_NAME): Remove unused
variable `buf_ptr'.

From-SVN: r35670

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index c8d641ae5a8ffbd6eb325168f5e521e347202876..94e2e03edf844295b43b2aef4c993b979f4ccd38 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,17 @@
 2000-08-13  Geoff Keating  <geoffk@cygnus.com>
 
+       * flow.c (attempt_auto_inc): Remove unused variable `bb'.
+       (attempt_auto_inc): Suppress parentheses warning.
+       * function.c (put_reg_into_stack): Remove unused variable `unsigned_p'.
+       * loop.c (load_mems): Remove `u' suffix in two places.
+       * config/rs6000/rs6000.c: Remove unnecessary `u' suffixes from
+       hex constants.
+       * config/rs6000/rs6000.h: Likewise.
+       * config/rs6000/sol-c0.c: Prototype some functions.  Remove the
+       __eabi dummy routine.
+       * config/rs6000/sysv4.h (ASM_DECLARE_FUNCTION_NAME): Remove unused
+       variable `buf_ptr'.
+
        * config/rs6000/rs6000.c (rs6000_select_section): Rewrite to
        not put stuff in .sdata unnecessarily.
        (rs6000_unique_section): New function.

diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index 83b72fd765c7988e44967829afb325a15aae1a9b..a85f5bddb2d91d101a5b397ad4ce0616b32b9fa9 100644 (file)
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -686,7 +686,7 @@ reg_or_logical_cint_operand (op, mode)
        }
 
       return ((INTVAL (op) & GET_MODE_MASK (mode)
-              & (~ (unsigned HOST_WIDE_INT) 0xffffffffu)) == 0);
+              & (~ (unsigned HOST_WIDE_INT) 0xffffffff)) == 0);
     }
   else if (GET_CODE (op) == CONST_DOUBLE)
     {
@@ -741,13 +741,13 @@ num_insns_constant_wide (value)
 #if HOST_BITS_PER_WIDE_INT == 64
   else if (TARGET_POWERPC64)
     {
-      unsigned HOST_WIDE_INT low  = value & 0xffffffffu;
+      unsigned HOST_WIDE_INT low  = value & 0xffffffff;
       HOST_WIDE_INT high = value >> 32;
 
-      if (high == 0 && (low & 0x80000000u) == 0)
+      if (high == 0 && (low & 0x80000000) == 0)
        return 2;
 
-      else if (high == -1 && (low & 0x80000000u) != 0)
+      else if (high == -1 && (low & 0x80000000) != 0)
        return 2;
 
       else if (! low)
@@ -808,10 +808,10 @@ num_insns_constant (op, mode)
 
       else
        {
-         if (high == 0 && (low & 0x80000000u) == 0)
+         if (high == 0 && (low & 0x80000000) == 0)
            return num_insns_constant_wide (low);
 
-         else if (high == -1 && (low & 0x80000000u) != 0)
+         else if (high == -1 && (low & 0x80000000) != 0)
            return num_insns_constant_wide (low);
 
          else if (mask64_operand (op, mode))
@@ -1003,7 +1003,7 @@ logical_operand (op, mode)
 
   return (oph == 0
          && ((opl & ~ (unsigned HOST_WIDE_INT) 0xffff) == 0
-             || (opl & ~ (unsigned HOST_WIDE_INT) 0xffff0000u) == 0));
+             || (opl & ~ (unsigned HOST_WIDE_INT) 0xffff0000) == 0));
 }
 
 /* Return 1 if C is a constant that is not a logical operand (as
@@ -3899,15 +3899,15 @@ print_operand (file, x, code)
       /* If the high bit is set and the low bit is not, the value is zero.
         If the high bit is zero, the value is the first 1 bit we find from
         the left.  */
-      if ((val & 0x80000000u) && ((val & 1) == 0))
+      if ((val & 0x80000000) && ((val & 1) == 0))
        {
          putc ('0', file);
          return;
        }
-      else if ((val & 0x80000000u) == 0)
+      else if ((val & 0x80000000) == 0)
        {
          for (i = 1; i < 32; i++)
-           if ((val <<= 1) & 0x80000000u)
+           if ((val <<= 1) & 0x80000000)
              break;
          fprintf (file, "%d", i);
          return;
@@ -3934,7 +3934,7 @@ print_operand (file, x, code)
       /* If the low bit is set and the high bit is not, the value is 31.
         If the low bit is zero, the value is the first 1 bit we find from
         the right.  */
-      if ((val & 1) && ((val & 0x80000000u) == 0))
+      if ((val & 1) && ((val & 0x80000000) == 0))
        {
          fputs ("31", file);
          return;
@@ -3954,7 +3954,7 @@ print_operand (file, x, code)
       /* Otherwise, look for the first 0 bit from the left.  The result is its
         number minus 1. We know the high-order bit is one.  */
       for (i = 0; i < 32; i++)
-       if (((val <<= 1) & 0x80000000u) == 0)
+       if (((val <<= 1) & 0x80000000) == 0)
          break;
 
       fprintf (file, "%d", i);
@@ -6660,7 +6660,7 @@ output_toc (file, x, labelno, mode)
            fprintf (file, "\t.llong 0x%lx%08lx\n", k[0], k[1]);
          else
            fprintf (file, "\t.tc FD_%lx_%lx[TC],0x%lx%08lx\n",
-                    k[0], k[1], k[0] & 0xffffffffu, k[1] & 0xffffffffu);
+                    k[0], k[1], k[0] & 0xffffffff, k[1] & 0xffffffff);
          return;
        }
       else
@@ -6713,11 +6713,11 @@ output_toc (file, x, labelno, mode)
 #if HOST_BITS_PER_WIDE_INT == 32
        {
          low = INTVAL (x);
-         high = (low & 0x80000000u) ? ~0 : 0;
+         high = (low & 0x80000000) ? ~0 : 0;
        }
 #else
        {
-          low = INTVAL (x) & 0xffffffffu;
+          low = INTVAL (x) & 0xffffffff;
           high = (HOST_WIDE_INT) INTVAL (x) >> 32;
        }
 #endif

diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h
index c4feb598414dc7988250f7f1dda456ab0a5c7bcf..14ca63a534d65f810a725f0abba8cdbebc20bf83 100644 (file)
--- a/gcc/config/rs6000/rs6000.h
+++ b/gcc/config/rs6000/rs6000.h
@@ -1061,7 +1061,7 @@ enum reg_class
 
 #define CONST_OK_FOR_LETTER_P(VALUE, C)                                        \
    ( (C) == 'I' ? (unsigned HOST_WIDE_INT) ((VALUE) + 0x8000) < 0x10000        \
-   : (C) == 'J' ? ((VALUE) & (~ (unsigned HOST_WIDE_INT) 0xffff0000u)) == 0 \
+   : (C) == 'J' ? ((VALUE) & (~ (unsigned HOST_WIDE_INT) 0xffff0000)) == 0 \
    : (C) == 'K' ? ((VALUE) & (~ (HOST_WIDE_INT) 0xffff)) == 0          \
    : (C) == 'L' ? (((VALUE) & 0xffff) == 0                             \
                   && ((VALUE) >> 31 == -1 || (VALUE) >> 31 == 0))      \
@@ -1960,7 +1960,7 @@ do {                                                                           \
       HOST_WIDE_INT val = INTVAL (XEXP (X, 1));                                     \
       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;               \
       HOST_WIDE_INT high                                                    \
-        = (((val - low) & 0xffffffffu) ^ 0x80000000u) - 0x80000000u;        \
+        = (((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000;           \
                                                                             \
       /* Check for 32-bit overflow.  */                                             \
       if (high + low != val)                                                \
@@ -2591,7 +2591,7 @@ extern char rs6000_reg_names[][8];        /* register names (0 vs. %r0). */
     long t[2];                                         \
     REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t);          \
     fprintf (FILE, "\t.long 0x%lx\n\t.long 0x%lx\n",   \
-            t[0] & 0xffffffffu, t[1] & 0xffffffffu);   \
+            t[0] & 0xffffffff, t[1] & 0xffffffff);     \
   }
 
 /* This is how to output an assembler line defining a `float' constant.  */
@@ -2600,7 +2600,7 @@ extern char rs6000_reg_names[][8];        /* register names (0 vs. %r0). */
   {                                                    \
     long t;                                            \
     REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t);          \
-    fprintf (FILE, "\t.long 0x%lx\n", t & 0xffffffffu);        \
+    fprintf (FILE, "\t.long 0x%lx\n", t & 0xffffffff); \
   }
 
 /* This is how to output an assembler line defining an `int' constant.  */

diff --git a/gcc/config/rs6000/sol-c0.c b/gcc/config/rs6000/sol-c0.c
index 44cd76fe3ba67c1ab9f0b8a7c757e358812f9a1f..a31876c889dfcad39d9e15b6430042ec503de950 100644 (file)
--- a/gcc/config/rs6000/sol-c0.c
+++ b/gcc/config/rs6000/sol-c0.c
@@ -1,5 +1,5 @@
 /* Solaris PowerPC startfile.  */
-/* Copyright (C) 1996 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 2000 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -32,6 +32,10 @@ extern char **_environ;
 extern int atexit (void (*__func) (void));
 extern void __init (void) __attribute__ ((__longcall__));
 extern void __fini (void) __attribute__ ((__longcall__));
+extern void _start(int argc, char *argv[], char *envp[], void *auxp, 
+                  void (*termfunc)());
+extern void exit(int);
+extern int main (int argc, char *argv[], char *envp[], void *auxp);
 
 typedef void (*func_ptr) (void);
 int (*__atexit)(func_ptr) = atexit;
@@ -116,9 +120,3 @@ _start(int argc, char *argv[], char *envp[], void *auxp, void (*termfunc)())
   /* Return to the os */
   exit (ret);
 }
-
-/* Provide a dummy __eabi in case main got compiled without -mcall-solaris.  */
-void
-__eabi ()
-{
-}

diff --git a/gcc/config/rs6000/sysv4.h b/gcc/config/rs6000/sysv4.h
index a3208ac8aa89539a068deb09ecea822e0bb10284..a7590efa36574057535b750835b4e134a9456e3c 100644 (file)
--- a/gcc/config/rs6000/sysv4.h
+++ b/gcc/config/rs6000/sysv4.h
@@ -610,7 +610,6 @@ extern int rs6000_pic_labelno;
        && uses_TOC())                                                  \
       {                                                                        \
        char buf[256];                                                  \
-       const char *buf_ptr;                                            \
                                                                        \
        ASM_OUTPUT_INTERNAL_LABEL (FILE, "LCL", rs6000_pic_labelno);    \
                                                                        \

diff --git a/gcc/flow.c b/gcc/flow.c
index 6c3b18d61a4d856f777f61742b8b7c25c7e9ddb4..e5df347c703b35f9d71035f22e0f9952c33c5c0d 100644 (file)
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -4879,7 +4879,6 @@ attempt_auto_inc (pbi, inc, insn, mem, incr, incr_reg)
         Change it to q = p, ...*q..., q = q+size.
         Then fall into the usual case.  */
       rtx insns, temp;
-      basic_block bb;
 
       start_sequence ();
       emit_move_insn (q, incr_reg);
@@ -4956,7 +4955,7 @@ attempt_auto_inc (pbi, inc, insn, mem, incr, incr_reg)
       /* If the original source was dead, it's dead now.  */
       rtx note;
 
-      while (note = find_reg_note (incr, REG_DEAD, NULL_RTX))
+      while ((note = find_reg_note (incr, REG_DEAD, NULL_RTX)) != NULL_RTX)
        {
          remove_note (incr, note);
          if (XEXP (note, 0) != incr_reg)

diff --git a/gcc/function.c b/gcc/function.c
index 62ae4824e7477df899be321da9332eafbff3704d..7f8bd1ea69c983a508c92ab8fd3636e2bccd688e 100644 (file)
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -1481,7 +1481,6 @@ put_reg_into_stack (function, reg, type, promoted_mode, decl_mode, volatile_p,
   struct function *func = function ? function : cfun;
   rtx new = 0;
   unsigned int regno = original_regno;
-  int unsigned_p;
 
   if (regno == 0)
     regno = REGNO (reg);

diff --git a/gcc/loop.c b/gcc/loop.c
index 225e73a5c113ed8fc81928e134396fc4199a79a1..ddaf017588a4341a482b5b4f561b6406d83b120e 100644 (file)
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -9569,7 +9569,7 @@ load_mems (loop)
                  && GET_CODE (SET_DEST (set)) == REG
                  && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER
                  && REGNO (SET_DEST (set)) < last_max_reg
-                 && VARRAY_INT (n_times_set, REGNO (SET_DEST (set))) == 1U
+                 && VARRAY_INT (n_times_set, REGNO (SET_DEST (set))) == 1
                  && rtx_equal_p (SET_SRC (set), mem))
                SET_REGNO_REG_SET (&load_copies, REGNO (SET_DEST (set)));
 
@@ -9583,7 +9583,7 @@ load_mems (loop)
                  && GET_CODE (SET_SRC (set)) == REG
                  && REGNO (SET_SRC (set)) >= FIRST_PSEUDO_REGISTER
                  && REGNO (SET_SRC (set)) < last_max_reg
-                 && VARRAY_INT (n_times_set, REGNO (SET_SRC (set))) == 1U
+                 && VARRAY_INT (n_times_set, REGNO (SET_SRC (set))) == 1
                  && rtx_equal_p (SET_DEST (set), mem))
                SET_REGNO_REG_SET (&store_copies, REGNO (SET_SRC (set)));