vax.c: (override_options) Remove 'register' keyword.

	* config/vax/vax.c: (override_options) Remove 'register' keyword.
	(split_quadword_operands) Likewise. (rev_cond_name) Likewise.
	(vax_float_literal) Likewise. (vax_rtx_costs) Remove trailing
	whitespace.
	* config/vax/vax.h: Remove 'register' keyword. Misc. whitespace fixes,
	mostly removal of trailing spaces...
	* config/vax/vax-modes.def: Remove trailing whitespace.

From-SVN: r99701

gcc/ChangeLog

 2005-05-14  Jan-Benedict Glaw  <jbglaw@lug-owl.de>
 
+	* config/vax/vax.c: (override_options) Remove 'register' keyword.
+	(split_quadword_operands) Likewise. (rev_cond_name) Likewise.
+	(vax_float_literal) Likewise. (vax_rtx_costs) Remove trailing
+	whitespace.
+	* config/vax/vax.h: Remove 'register' keyword. Misc. whitespace fixes,
+	mostly removal of trailing spaces...
+	* config/vax/vax-modes.def: Remove trailing whitespace.
+
 	* config/vax/elf.h: Update whitespace.
 
 2005-05-14  Richard Guenther  <rguenth@gcc.gnu.org>

gcc/config/vax/vax-modes.def

-/* VAX extra machine modes. 
+/* VAX extra machine modes.
    Copyright (C) 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.

gcc/config/vax/vax.c

@@ -112,8 +112,8 @@ override_options (void)
 static void
 vax_output_function_prologue (FILE * file, HOST_WIDE_INT size)
 {
-  register int regno;
-  register int mask = 0;
+  int regno;
+  int mask = 0;
 
   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
     if (regs_ever_live[regno] && !call_used_regs[regno])
@@ -199,9 +199,9 @@ split_quadword_operands (rtx * operands, rtx * low, int n ATTRIBUTE_UNUSED)
 }
 
 void
-print_operand_address (FILE * file, register rtx addr)
+print_operand_address (FILE * file, rtx addr)
 {
-  register rtx reg1, breg, ireg;
+  rtx reg1, breg, ireg;
   rtx offset;
 
  retry:
@@ -411,9 +411,9 @@ rev_cond_name (rtx op)
 }
 
 int
-vax_float_literal(register rtx c)
+vax_float_literal(rtx c)
 {
-  register enum machine_mode mode;
+  enum machine_mode mode;
   REAL_VALUE_TYPE r, s;
   int i;
 
@@ -457,7 +457,7 @@ vax_float_literal(register rtx c)
 
 
 static int
-vax_address_cost_1 (register rtx addr)
+vax_address_cost_1 (rtx addr)
 {
   int reg = 0, indexed = 0, indir = 0, offset = 0, predec = 0;
   rtx plus_op0 = 0, plus_op1 = 0;

gcc/config/vax/vax.h

@@ -150,8 +150,8 @@ Boston, MA 02111-1307, USA.  */
    This is ordinarily the length in words of a value of mode MODE
    but can be less for certain modes in special long registers.
    On the VAX, all registers are one word long.  */
-#define HARD_REGNO_NREGS(REGNO, MODE)   \
- ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
+#define HARD_REGNO_NREGS(REGNO, MODE)	\
+  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 
 /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
    On the VAX, all registers can hold all modes.  */
@@ -210,7 +210,7 @@ Boston, MA 02111-1307, USA.  */
 
    For any two classes, it is very desirable that there be another
    class that represents their union.  */
-   
+
 /* The VAX has only one kind of registers, so NO_REGS and ALL_REGS
    are the only classes.  */
 
@@ -225,8 +225,8 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
 
 /* Give names of register classes as strings for dump file.  */
 
-#define REG_CLASS_NAMES \
- {"NO_REGS", "ALL_REGS" }
+#define REG_CLASS_NAMES	\
+  { "NO_REGS", "ALL_REGS" }
 
 /* Define which registers fit in which classes.
    This is an initializer for a vector of HARD_REG_SET
@@ -264,7 +264,7 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
    'N' is a value between 0 and 65535 (inclusive)
    `O' is a value between -63 and -1 (inclusive)  */
 
-#define CONST_OK_FOR_LETTER_P(VALUE, C) \
+#define CONST_OK_FOR_LETTER_P(VALUE, C)				\
   (  (C) == 'I' ?	(VALUE) == 0				\
    : (C) == 'J' ?	0 <= (VALUE) && (VALUE) < 64		\
    : (C) == 'O' ?	-63 <= (VALUE) && (VALUE) < 0		\
@@ -275,11 +275,11 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
    : 0)
 
 /* Similar, but for floating constants, and defining letters G and H.
-   Here VALUE is the CONST_DOUBLE rtx itself. 
+   Here VALUE is the CONST_DOUBLE rtx itself.
 
    `G' is a floating-point zero.  */
 
-#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \
+#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)		\
   ((C) == 'G' ? ((VALUE) == CONST0_RTX (DFmode)		\
 		 || (VALUE) == CONST0_RTX (SFmode))	\
    : 0)
@@ -289,7 +289,7 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
    For the VAX, `Q' means that OP is a MEM that does not have a mode-dependent
    address.  */
 
-#define EXTRA_CONSTRAINT(OP, C) \
+#define EXTRA_CONSTRAINT(OP, C)						\
   ((C) == 'Q'								\
    ? GET_CODE (OP) == MEM && ! mode_dependent_address_p (XEXP (OP, 0))	\
    : 0)
@@ -348,23 +348,23 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
 
    On the VAX, the RET insn pops a maximum of 255 args for any function.  */
 
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) \
-  ((SIZE) > 255*4 ? 0 : (SIZE))
+#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE)	\
+  ((SIZE) > 255 * 4 ? 0 : (SIZE))
 
 /* Define how to find the value returned by a function.
    VALTYPE is the data type of the value (as a tree).
    If the precise function being called is known, FUNC is its FUNCTION_DECL;
    otherwise, FUNC is 0.  */
 
-/* On the VAX the return value is in R0 regardless.  */   
+/* On the VAX the return value is in R0 regardless.  */
 
-#define FUNCTION_VALUE(VALTYPE, FUNC)  \
+#define FUNCTION_VALUE(VALTYPE, FUNC)	\
   gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
 
 /* Define how to find the value returned by a library function
    assuming the value has mode MODE.  */
 
-/* On the VAX the return value is in R0 regardless.  */   
+/* On the VAX the return value is in R0 regardless.  */
 
 #define LIBCALL_VALUE(MODE)  gen_rtx_REG (MODE, 0)
 
@@ -408,9 +408,9 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
    (TYPE is null for libcalls where that information may not be available.)  */
 
 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)	\
- ((CUM) += ((MODE) != BLKmode			\
-	    ? (GET_MODE_SIZE (MODE) + 3) & ~3	\
-	    : (int_size_in_bytes (TYPE) + 3) & ~3))
+  ((CUM) += ((MODE) != BLKmode				\
+	     ? (GET_MODE_SIZE (MODE) + 3) & ~3		\
+	     : (int_size_in_bytes (TYPE) + 3) & ~3))
 
 /* Define where to put the arguments to a function.
    Value is zero to push the argument on the stack,
@@ -425,7 +425,7 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
    NAMED is nonzero if this argument is a named parameter
     (otherwise it is an extra parameter matching an ellipsis).  */
 
-/* On the VAX all args are pushed.  */   
+/* On the VAX all args are pushed.  */
 
 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) 0
 
@@ -510,9 +510,9 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
    FRAMEADDR is already the frame pointer of the COUNT frame, so we
    can ignore COUNT.  */
 
-#define RETURN_ADDR_RTX(COUNT, FRAME)	\
-  ((COUNT == 0)				\
-   ? gen_rtx_MEM (Pmode, plus_constant (FRAME, RETURN_ADDRESS_OFFSET)) \
+#define RETURN_ADDR_RTX(COUNT, FRAME)					\
+  ((COUNT == 0)								\
+   ? gen_rtx_MEM (Pmode, plus_constant (FRAME, RETURN_ADDRESS_OFFSET))	\
    : (rtx) 0)
 
 
@@ -530,10 +530,10 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
    Since they use reg_renumber, they are safe only once reg_renumber
    has been allocated, which happens in local-alloc.c.  */
 
-#define REGNO_OK_FOR_INDEX_P(regno)  \
-((regno) < FIRST_PSEUDO_REGISTER || reg_renumber[regno] >= 0)
-#define REGNO_OK_FOR_BASE_P(regno) \
-((regno) < FIRST_PSEUDO_REGISTER || reg_renumber[regno] >= 0)
+#define REGNO_OK_FOR_INDEX_P(regno)	\
+  ((regno) < FIRST_PSEUDO_REGISTER || reg_renumber[regno] >= 0)
+#define REGNO_OK_FOR_BASE_P(regno)	\
+  ((regno) < FIRST_PSEUDO_REGISTER || reg_renumber[regno] >= 0)
 
 /* Maximum number of registers that can appear in a valid memory address.  */
 
@@ -574,7 +574,7 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
    that is a valid memory address for an instruction.  */
 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
-{ if (legitimate_address_p ((MODE), (X), 0)) goto ADDR; }
+  { if (legitimate_address_p ((MODE), (X), 0)) goto ADDR; }
 
 #else
 
@@ -587,14 +587,14 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
    that is a valid memory address for an instruction.  */
 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
-{ if (legitimate_address_p ((MODE), (X), 1)) goto ADDR; }
+  { if (legitimate_address_p ((MODE), (X), 1)) goto ADDR; }
 
 #endif
 
 /* Go to LABEL if ADDR (a legitimate address expression)
    has an effect that depends on the machine mode it is used for.  */
 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL) \
- { if (vax_mode_dependent_address_p (ADDR)) goto LABEL; }
+  { if (vax_mode_dependent_address_p (ADDR)) goto LABEL; }
 
 /* Specify the machine mode that this machine uses
    for the index in the tablejump instruction.  */
@@ -665,13 +665,14 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
    after execution of an instruction whose pattern is EXP.
    Do not alter them if the instruction would not alter the cc's.  */
 
-#define NOTICE_UPDATE_CC(EXP, INSN) \
+#define NOTICE_UPDATE_CC(EXP, INSN)	\
   vax_notice_update_cc ((EXP), (INSN))
 
-#define OUTPUT_JUMP(NORMAL, FLOAT, NO_OV)  \
-{ if (cc_status.flags & CC_NO_OVERFLOW)				\
-    return NO_OV;						\
-  return NORMAL; }
+#define OUTPUT_JUMP(NORMAL, FLOAT, NO_OV)	\
+  { if (cc_status.flags & CC_NO_OVERFLOW)	\
+      return NO_OV;				\
+    return NORMAL;				\
+  }
 
 /* Control the assembler format that we output.  */
 
@@ -704,9 +705,9 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
    The register names will be prefixed by REGISTER_PREFIX, if any.  */
 
 #define REGISTER_PREFIX ""
-#define REGISTER_NAMES \
-{"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", \
- "r9", "r10", "r11", "ap", "fp", "sp", "pc"}
+#define REGISTER_NAMES					\
+  { "r0", "r1",  "r2",  "r3", "r4", "r5", "r6", "r7",	\
+    "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc", }
 
 /* This is BSD, so it wants DBX format.  */
 
@@ -760,8 +761,8 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
 /* This is how to output an insn to pop a register from the stack.
    It need not be very fast code.  */
 
-#define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
-  fprintf (FILE, "\tmovl (%s)+,%s\n", reg_names[STACK_POINTER_REGNUM], \
+#define ASM_OUTPUT_REG_POP(FILE,REGNO)					\
+  fprintf (FILE, "\tmovl (%s)+,%s\n", reg_names[STACK_POINTER_REGNUM],	\
 	   reg_names[REGNO])
 
 /* This is how to output an element of a case-vector that is absolute.
@@ -811,26 +812,26 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
 /* This says how to output an assembler line
    to define a global common symbol.  */
 
-#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
-( fputs (".comm ", (FILE)),			\
-  assemble_name ((FILE), (NAME)),		\
-  fprintf ((FILE), ",%u\n", (int)(ROUNDED)))
+#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)	\
+  ( fputs (".comm ", (FILE)),				\
+    assemble_name ((FILE), (NAME)),			\
+    fprintf ((FILE), ",%u\n", (int)(ROUNDED)))
 
 /* This says how to output an assembler line
    to define a local common symbol.  */
 
-#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)  \
-( fputs (".lcomm ", (FILE)),			\
-  assemble_name ((FILE), (NAME)),		\
-  fprintf ((FILE), ",%u\n", (int)(ROUNDED)))
+#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)	\
+  ( fputs (".lcomm ", (FILE)),				\
+    assemble_name ((FILE), (NAME)),			\
+    fprintf ((FILE), ",%u\n", (int)(ROUNDED)))
 
 /* Store in OUTPUT a string (made with alloca) containing
    an assembler-name for a local static variable named NAME.
    LABELNO is an integer which is different for each call.  */
 
 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)	\
-( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),	\
-  sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
+  ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),	\
+    sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
 
 /* Print an instruction operand X on file FILE.
    CODE is the code from the %-spec that requested printing this operand;
@@ -865,7 +866,7 @@ VAX operand formatting codes:
 #define PRINT_OPERAND_PUNCT_VALID_P(CODE)				\
   ((CODE) == '#' || (CODE) == '|')
 
-#define PRINT_OPERAND(FILE, X, CODE)  \
+#define PRINT_OPERAND(FILE, X, CODE)					\
 { if (CODE == '#') fputc (ASM_DOUBLE_CHAR, FILE);			\
   else if (CODE == '|')							\
     fputs (REGISTER_PREFIX, FILE);					\
@@ -910,9 +911,10 @@ VAX operand formatting codes:
    This uses a function in output-vax.c.  */
 
 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
- print_operand_address (FILE, ADDR)
+  print_operand_address (FILE, ADDR)
 
 /* This is a blatent lie.  However, it's good enough, since we don't
    actually have any code whatsoever for which this isn't overridden
    by the proper FDE definition.  */
 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, PC_REGNUM)
+