2001-10-10 Stan Shebs <shebs@apple.com>

        * alias.c: Remove uses of "register" specifier in declarations
        of arguments and local variables.
        * c-common.c: Ditto.
        * c-convert.c: Ditto.
        * c-decl.c: Ditto.
        * c-format.c: Ditto.
        * c-semantics.c: Ditto.
        * c-typeck.c: Ditto.
        * caller-save.c: Ditto.
        * calls.c: Ditto.
        * cfg.c: Ditto.
        * cfgbuild.c: Ditto.
        * cfgrtl.c: Ditto.
        * collect2.c: Ditto.
        * combine.c: Ditto.
        * convert.c: Ditto.
        * cppexp.c: Ditto.
        * cppfiles.c: Ditto.
        * cse.c: Ditto.
        * dbxout.c: Ditto.
        * defaults.h: Ditto.
        * df.c: Ditto.
        * dwarf2out.c: Ditto.
        * dwarfout.c: Ditto.
        * emit-rtl.c: Ditto.
        * explow.c: Ditto.
        * expmed.c: Ditto.
        * expr.c: Ditto.
        * final.c: Ditto.
        * fix-header.c: Ditto.
        * floatlib.c: Ditto.
        * flow.c: Ditto.
        * fold-const.c: Ditto.
        * function.c: Ditto.
        * gcc.c: Ditto.
        * gcse.c: Ditto.
        * gen-protos.c: Ditto.
        * genattrtab.c: Ditto.
        * gencheck.c: Ditto.
        * genconfig.c: Ditto.
        * genemit.c: Ditto.
        * genextract.c: Ditto.
        * genflags.c: Ditto.
        * gengenrtl.c: Ditto.
        * genoutput.c: Ditto.
        * genpeep.c: Ditto.
        * genrecog.c: Ditto.
        * gensupport.c: Ditto.
        * global.c: Ditto.
        * gmon.c: Ditto.
        * graph.c: Ditto.
        * haifa-sched.c: Ditto.
        * hard-reg-set.h: Ditto.
        * hash.c: Ditto.
        * integrate.c: Ditto.
        * jump.c: Ditto.
        * lists.c: Ditto.
        * local-alloc.c: Ditto.
        * loop.c: Ditto.
        * mips-tdump.c: Ditto.
        * mips-tfile.c: Ditto.
        * optabs.c: Ditto.
        * prefix.c: Ditto.
        * print-rtl.c: Ditto.
        * read-rtl.c: Ditto.
        * real.c: Ditto.
        * recog.c: Ditto.
        * reg-stack.c: Ditto.
        * regclass.c: Ditto.
        * regmove.c: Ditto.
        * reload.c: Ditto.
        * reload1.c: Ditto.
        * reorg.c: Ditto.
        * resource.c: Ditto.
        * rtl.c: Ditto.
        * rtlanal.c: Ditto.
        * scan.c: Ditto.
        * sched-deps.c: Ditto.
        * sched-rgn.c: Ditto.
        * sdbout.c: Ditto.
        * simplify-rtx.c: Ditto.
        * stmt.c: Ditto.
        * stor-layout.c: Ditto.
        * toplev.c: Ditto.
        * tradcif.y: Ditto.
        * tradcpp.c: Ditto.
        * tree.c: Ditto.
        * unroll.c: Ditto.
        * varasm.c: Ditto.
        * xcoffout.c: Ditto.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@46173 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 75 insertions, 75 deletions

diff --git a/gcc/reload.c b/gcc/reload.c
index 0b497aa6f96..613d6c7e2c7 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -857,7 +857,7 @@ push_reload (in, out, inloc, outloc, class,
      int opnum;
      enum reload_type type;
 {
-  register int i;
+  int i;
   int dont_share = 0;
   int dont_remove_subreg = 0;
   rtx *in_subreg_loc = 0, *out_subreg_loc = 0;
@@ -879,7 +879,7 @@ push_reload (in, out, inloc, outloc, class,
      Often this is done earlier, but not always in find_reloads_address.  */
   if (in != 0 && GET_CODE (in) == REG)
     {
-      register int regno = REGNO (in);
+      int regno = REGNO (in);
 
       if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
 	  && reg_equiv_constant[regno] != 0)
@@ -891,7 +891,7 @@ push_reload (in, out, inloc, outloc, class,
      (in the case of a parameter).  */
   if (out != 0 && GET_CODE (out) == REG)
     {
-      register int regno = REGNO (out);
+      int regno = REGNO (out);
 
       if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
 	  && reg_equiv_constant[regno] != 0)
@@ -1402,7 +1402,7 @@ push_reload (in, out, inloc, outloc, class,
     {
       if (inloc != 0)
 	{
-	  register struct replacement *r = &replacements[n_replacements++];
+	  struct replacement *r = &replacements[n_replacements++];
 	  r->what = i;
 	  r->subreg_loc = in_subreg_loc;
 	  r->where = inloc;
@@ -1410,7 +1410,7 @@ push_reload (in, out, inloc, outloc, class,
 	}
       if (outloc != 0 && outloc != inloc)
 	{
-	  register struct replacement *r = &replacements[n_replacements++];
+	  struct replacement *r = &replacements[n_replacements++];
 	  r->what = i;
 	  r->where = outloc;
 	  r->subreg_loc = out_subreg_loc;
@@ -1537,7 +1537,7 @@ push_replacement (loc, reloadnum, mode)
 {
   if (replace_reloads)
     {
-      register struct replacement *r = &replacements[n_replacements++];
+      struct replacement *r = &replacements[n_replacements++];
       r->what = reloadnum;
       r->where = loc;
       r->subreg_loc = 0;
@@ -1978,7 +1978,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
 {
   if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
     {
-      register rtx op0 = SET_DEST (x);
+      rtx op0 = SET_DEST (x);
 
       while (GET_CODE (op0) == SUBREG)
 	op0 = SUBREG_REG (op0);
@@ -1994,7 +1994,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
     }
   else if (GET_CODE (x) == PARALLEL)
     {
-      register int i = XVECLEN (x, 0) - 1;
+      int i = XVECLEN (x, 0) - 1;
 
       for (; i >= 0; i--)
 	if (hard_reg_set_here_p (beg_regno, end_regno, XVECEXP (x, 0, i)))
@@ -2011,7 +2011,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
 int
 strict_memory_address_p (mode, addr)
      enum machine_mode mode ATTRIBUTE_UNUSED;
-     register rtx addr;
+     rtx addr;
 {
   GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
   return 0;
@@ -2037,11 +2037,11 @@ strict_memory_address_p (mode, addr)
 
 int
 operands_match_p (x, y)
-     register rtx x, y;
+     rtx x, y;
 {
-  register int i;
-  register RTX_CODE code = GET_CODE (x);
-  register const char *fmt;
+  int i;
+  RTX_CODE code = GET_CODE (x);
+  const char *fmt;
   int success_2;
 
   if (x == y)
@@ -2050,7 +2050,7 @@ operands_match_p (x, y)
       && (GET_CODE (y) == REG || (GET_CODE (y) == SUBREG
 				  && GET_CODE (SUBREG_REG (y)) == REG)))
     {
-      register int j;
+      int j;
 
       if (code == SUBREG)
 	{
@@ -2410,8 +2410,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
      int live_known;
      short *reload_reg_p;
 {
-  register int insn_code_number;
-  register int i, j;
+  int insn_code_number;
+  int i, j;
   int noperands;
   /* These start out as the constraints for the insn
      and they are chewed up as we consider alternatives.  */
@@ -2524,8 +2524,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 
   for (i = 0; i < noperands; i++)
     {
-      register char *p;
-      register int c;
+      char *p;
+      int c;
 
       substed_operand[i] = recog_data.operand[i];
       p = constraints[i];
@@ -2596,7 +2596,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 
   for (i = 0; i < noperands; i++)
     {
-      register RTX_CODE code = GET_CODE (recog_data.operand[i]);
+      RTX_CODE code = GET_CODE (recog_data.operand[i]);
 
       address_reloaded[i] = 0;
       operand_type[i] = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT
@@ -2687,7 +2687,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	     we replace it by the constant.  We must be sure, however,
 	     that we don't try to replace it in the insn in which it
 	     is being set.  */
-	  register int regno = REGNO (recog_data.operand[i]);
+	  int regno = REGNO (recog_data.operand[i]);
 	  if (reg_equiv_constant[regno] != 0
 	      && (set == 0 || &SET_DEST (set) != recog_data.operand_loc[i]))
 	    {
@@ -2774,15 +2774,15 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 
       for (i = 0; i < noperands; i++)
 	{
-	  register char *p = constraints[i];
-	  register int win = 0;
+	  char *p = constraints[i];
+	  int win = 0;
 	  int did_match = 0;
 	  /* 0 => this operand can be reloaded somehow for this alternative.  */
 	  int badop = 1;
 	  /* 0 => this operand can be reloaded if the alternative allows regs.  */
 	  int winreg = 0;
 	  int c;
-	  register rtx operand = recog_data.operand[i];
+	  rtx operand = recog_data.operand[i];
 	  int offset = 0;
 	  /* Nonzero means this is a MEM that must be reloaded into a reg
 	     regardless of what the constraint says.  */
@@ -3494,8 +3494,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
       swapped = !swapped;
       if (swapped)
 	{
-	  register enum reg_class tclass;
-	  register int t;
+	  enum reg_class tclass;
+	  int t;
 
 	  recog_data.operand[commutative] = substed_operand[commutative + 1];
 	  recog_data.operand[commutative + 1] = substed_operand[commutative];
@@ -3564,7 +3564,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 
   if (goal_alternative_swapped)
     {
-      register rtx tem;
+      rtx tem;
 
       tem = substed_operand[commutative];
       substed_operand[commutative] = substed_operand[commutative + 1];
@@ -4229,7 +4229,7 @@ alternative_allows_memconst (constraint, altnum)
      const char *constraint;
      int altnum;
 {
-  register int c;
+  int c;
   /* Skip alternatives before the one requested.  */
   while (altnum > 0)
     {
@@ -4277,16 +4277,16 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
      rtx insn;
      int *address_reloaded;
 {
-  register RTX_CODE code = GET_CODE (x);
+  RTX_CODE code = GET_CODE (x);
 
-  register const char *fmt = GET_RTX_FORMAT (code);
-  register int i;
+  const char *fmt = GET_RTX_FORMAT (code);
+  int i;
   int copied;
 
   if (code == REG)
     {
       /* This code is duplicated for speed in find_reloads.  */
-      register int regno = REGNO (x);
+      int regno = REGNO (x);
       if (reg_equiv_constant[regno] != 0 && !is_set_dest)
 	x = reg_equiv_constant[regno];
 #if 0
@@ -4343,7 +4343,7 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
 	 the register (this should never happen because one of the cases
 	 above should handle it).  */
 
-      register int regno = REGNO (SUBREG_REG (x));
+      int regno = REGNO (SUBREG_REG (x));
       rtx tem;
 
       if (subreg_lowpart_p (x)
@@ -4514,7 +4514,7 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
      int ind_levels;
      rtx insn;
 {
-  register int regno;
+  int regno;
   int removed_and = 0;
   rtx tem;
 
@@ -4874,9 +4874,9 @@ subst_reg_equivs (ad, insn)
      rtx ad;
      rtx insn;
 {
-  register RTX_CODE code = GET_CODE (ad);
-  register int i;
-  register const char *fmt;
+  RTX_CODE code = GET_CODE (ad);
+  int i;
+  const char *fmt;
 
   switch (code)
     {
@@ -4892,7 +4892,7 @@ subst_reg_equivs (ad, insn)
 
     case REG:
       {
-	register int regno = REGNO (ad);
+	int regno = REGNO (ad);
 
 	if (reg_equiv_constant[regno] != 0)
 	  {
@@ -5105,18 +5105,18 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
      int ind_levels;
      rtx insn;
 {
-  register RTX_CODE code = GET_CODE (x);
+  RTX_CODE code = GET_CODE (x);
 
   switch (code)
     {
     case PLUS:
       {
-	register rtx orig_op0 = XEXP (x, 0);
-	register rtx orig_op1 = XEXP (x, 1);
-	register RTX_CODE code0 = GET_CODE (orig_op0);
-	register RTX_CODE code1 = GET_CODE (orig_op1);
-	register rtx op0 = orig_op0;
-	register rtx op1 = orig_op1;
+	rtx orig_op0 = XEXP (x, 0);
+	rtx orig_op1 = XEXP (x, 1);
+	RTX_CODE code0 = GET_CODE (orig_op0);
+	RTX_CODE code1 = GET_CODE (orig_op1);
+	rtx op0 = orig_op0;
+	rtx op1 = orig_op1;
 
 	if (GET_CODE (op0) == SUBREG)
 	  {
@@ -5316,7 +5316,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
     case PRE_DEC:
       if (GET_CODE (XEXP (x, 0)) == REG)
 	{
-	  register int regno = REGNO (XEXP (x, 0));
+	  int regno = REGNO (XEXP (x, 0));
 	  int value = 0;
 	  rtx x_orig = x;
 
@@ -5429,7 +5429,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
 	     reload it into a register.  */
 	  /* Variable `tem' might or might not be used in FIND_REG_INC_NOTE.  */
 	  rtx tem ATTRIBUTE_UNUSED = XEXP (x, 0);
-	  register rtx link;
+	  rtx link;
 	  int reloadnum;
 
 	  /* Since we know we are going to reload this item, don't decrement
@@ -5481,7 +5481,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
 
     case REG:
       {
-	register int regno = REGNO (x);
+	int regno = REGNO (x);
 
 	if (reg_equiv_constant[regno] != 0)
 	  {
@@ -5586,8 +5586,8 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
     }
 
   {
-    register const char *fmt = GET_RTX_FORMAT (code);
-    register int i;
+    const char *fmt = GET_RTX_FORMAT (code);
+    int i;
 
     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
       {
@@ -5765,12 +5765,12 @@ void
 subst_reloads (insn)
      rtx insn;
 {
-  register int i;
+  int i;
 
   for (i = 0; i < n_replacements; i++)
     {
-      register struct replacement *r = &replacements[i];
-      register rtx reloadreg = rld[r->what].reg_rtx;
+      struct replacement *r = &replacements[i];
+      rtx reloadreg = rld[r->what].reg_rtx;
       if (reloadreg)
 	{
 #ifdef ENABLE_CHECKING
@@ -6090,7 +6090,7 @@ refers_to_regno_for_reload_p (regno, endregno, x, loc)
 	}
       else if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 	    if (loc != &XVECEXP (x, i, j)
 		&& refers_to_regno_for_reload_p (regno, endregno,
@@ -6218,18 +6218,18 @@ refers_to_mem_for_reload_p (x)
 
 rtx
 find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
-     register rtx goal;
+     rtx goal;
      rtx insn;
      enum reg_class class;
-     register int other;
+     int other;
      short *reload_reg_p;
      int goalreg;
      enum machine_mode mode;
 {
-  register rtx p = insn;
+  rtx p = insn;
   rtx goaltry, valtry, value, where;
-  register rtx pat;
-  register int regno = -1;
+  rtx pat;
+  int regno = -1;
   int valueno;
   int goal_mem = 0;
   int goal_const = 0;
@@ -6515,7 +6515,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 	    pat = COND_EXEC_CODE (pat);
 	  if (GET_CODE (pat) == SET || GET_CODE (pat) == CLOBBER)
 	    {
-	      register rtx dest = SET_DEST (pat);
+	      rtx dest = SET_DEST (pat);
 	      while (GET_CODE (dest) == SUBREG
 		     || GET_CODE (dest) == ZERO_EXTRACT
 		     || GET_CODE (dest) == SIGN_EXTRACT
@@ -6523,7 +6523,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 		dest = XEXP (dest, 0);
 	      if (GET_CODE (dest) == REG)
 		{
-		  register int xregno = REGNO (dest);
+		  int xregno = REGNO (dest);
 		  int xnregs;
 		  if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
 		    xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
@@ -6551,15 +6551,15 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 	    }
 	  else if (GET_CODE (pat) == PARALLEL)
 	    {
-	      register int i;
+	      int i;
 	      for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
 		{
-		  register rtx v1 = XVECEXP (pat, 0, i);
+		  rtx v1 = XVECEXP (pat, 0, i);
 		  if (GET_CODE (v1) == COND_EXEC)
 		    v1 = COND_EXEC_CODE (v1);
 		  if (GET_CODE (v1) == SET || GET_CODE (v1) == CLOBBER)
 		    {
-		      register rtx dest = SET_DEST (v1);
+		      rtx dest = SET_DEST (v1);
 		      while (GET_CODE (dest) == SUBREG
 			     || GET_CODE (dest) == ZERO_EXTRACT
 			     || GET_CODE (dest) == SIGN_EXTRACT
@@ -6567,7 +6567,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 			dest = XEXP (dest, 0);
 		      if (GET_CODE (dest) == REG)
 			{
-			  register int xregno = REGNO (dest);
+			  int xregno = REGNO (dest);
 			  int xnregs;
 			  if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
 			    xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
@@ -6609,11 +6609,11 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 		  pat = XEXP (link, 0);
 		  if (GET_CODE (pat) == CLOBBER)
 		    {
-		      register rtx dest = SET_DEST (pat);
+		      rtx dest = SET_DEST (pat);
 
 		      if (GET_CODE (dest) == REG)
 			{
-			  register int xregno = REGNO (dest);
+			  int xregno = REGNO (dest);
 			  int xnregs
 			    = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
 
@@ -6645,13 +6645,13 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
 	     If GOAL is a memory ref and its address is not constant,
 	     and this insn P increments a register used in GOAL, return 0.  */
 	  {
-	    register rtx link;
+	    rtx link;
 
 	    for (link = REG_NOTES (p); link; link = XEXP (link, 1))
 	      if (REG_NOTE_KIND (link) == REG_INC
 		  && GET_CODE (XEXP (link, 0)) == REG)
 		{
-		  register int incno = REGNO (XEXP (link, 0));
+		  int incno = REGNO (XEXP (link, 0));
 		  if (incno < regno + nregs && incno >= regno)
 		    return 0;
 		  if (incno < valueno + valuenregs && incno >= valueno)
@@ -6675,13 +6675,13 @@ static int
 find_inc_amount (x, inced)
      rtx x, inced;
 {
-  register enum rtx_code code = GET_CODE (x);
-  register const char *fmt;
-  register int i;
+  enum rtx_code code = GET_CODE (x);
+  const char *fmt;
+  int i;
 
   if (code == MEM)
     {
-      register rtx addr = XEXP (x, 0);
+      rtx addr = XEXP (x, 0);
       if ((GET_CODE (addr) == PRE_DEC
 	   || GET_CODE (addr) == POST_DEC
 	   || GET_CODE (addr) == PRE_INC
@@ -6705,16 +6705,16 @@ find_inc_amount (x, inced)
     {
       if (fmt[i] == 'e')
 	{
-	  register int tem = find_inc_amount (XEXP (x, i), inced);
+	  int tem = find_inc_amount (XEXP (x, i), inced);
 	  if (tem != 0)
 	    return tem;
 	}
       if (fmt[i] == 'E')
 	{
-	  register int j;
+	  int j;
 	  for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 	    {
-	      register int tem = find_inc_amount (XVECEXP (x, i, j), inced);
+	      int tem = find_inc_amount (XVECEXP (x, i, j), inced);
 	      if (tem != 0)
 		return tem;
 	    }