* config/s390/s390.c: Follow spelling convention.
* config/sh/lib1funcs.asm: Likewise.
* config/sh/sh.c: Likewise.
* config/sh/sh.h: Likewise.
* config/sparc/sparc.c: Likewise.
* config/sparc/sparc.h: Likewise.
* config/sparc/sparc.md: Likewise.
* config/stormy16/stormy16.c: Likewise.
* config/stormy16/stormy16.h: Likewise.
* config/v850/v850.c: Likewise.
* config/v850/v850.h: Likewise.
* config/vax/vax.c: Likewise.
* config/vax/vax.h: Likewise.
From-SVN: r57276
+2002-09-18 Kazu Hirata <kazu@cs.umass.edu>
+
+ * config/s390/s390.c: Follow spelling convention.
+ * config/sh/lib1funcs.asm: Likewise.
+ * config/sh/sh.c: Likewise.
+ * config/sh/sh.h: Likewise.
+ * config/sparc/sparc.c: Likewise.
+ * config/sparc/sparc.h: Likewise.
+ * config/sparc/sparc.md: Likewise.
+ * config/stormy16/stormy16.c: Likewise.
+ * config/stormy16/stormy16.h: Likewise.
+ * config/v850/v850.c: Likewise.
+ * config/v850/v850.h: Likewise.
+ * config/vax/vax.c: Likewise.
+ * config/vax/vax.h: Likewise.
+
2002-09-18 Nick Clifton <nickc@redhat.com>
* config/rs60000/rs6000.c (rs6000_emit_move): Handle V1DImode moves.
LEVEL is the optimization level specified; 2 if `-O2' is
specified, 1 if `-O' is specified, and 0 if neither is specified.
- SIZE is non-zero if `-Os' is specified and zero otherwise. */
+ SIZE is nonzero if `-Os' is specified and zero otherwise. */
void
optimization_options (level, size)
would require a lot of instructions to do the shifts just right. Using
the full 64 bit shift result to multiply with the divisor would require
four extra instructions for the upper 32 bits (shift / mulu / shift / sub).
- Fortunately, if the upper 32 bits of the shift result are non-zero, we
+ Fortunately, if the upper 32 bits of the shift result are nonzero, we
know that the rest after taking this partial result into account will
fit into 32 bits. So we just clear the upper 32 bits of the rest if the
- upper 32 bits of the partial result are non-zero. */
+ upper 32 bits of the partial result are nonzero. */
#endif /* __SHMEDIA__ */
#endif /* L_udivdi3 */
would require a lot of instructions to do the shifts just right. Using
the full 64 bit shift result to multiply with the divisor would require
four extra instructions for the upper 32 bits (shift / mulu / shift / sub).
- Fortunately, if the upper 32 bits of the shift result are non-zero, we
+ Fortunately, if the upper 32 bits of the shift result are nonzero, we
know that the rest after taking this partial result into account will
fit into 32 bits. So we just clear the upper 32 bits of the rest if the
- upper 32 bits of the partial result are non-zero. */
+ upper 32 bits of the partial result are nonzero. */
#endif /* __SHMEDIA__ */
#endif /* L_umoddi3 */
pool_window_last = 0;
}
-/* Return non-zero if constant would be an ok source for a
+/* Return nonzero if constant would be an ok source for a
mov.w instead of a mov.l. */
static int
&& INTVAL (src) <= 32767);
}
-/* Non-zero if the insn is a move instruction which needs to be fixed. */
+/* Nonzero if the insn is a move instruction which needs to be fixed. */
/* ??? For a DImode/DFmode moves, we don't need to fix it if each half of the
CONST_DOUBLE input value is CONST_OK_FOR_I. For a SFmode move, we don't
return INSN_ADDRESSES (dest_uid);
}
\f
-/* Return non-zero if REG is not used after INSN.
+/* Return nonzero if REG is not used after INSN.
We assume REG is a reload reg, and therefore does
not live past labels. It may live past calls or jumps though. */
int
return 0;
}
-/* Return non-zero if register old_reg can be renamed to register new_reg. */
+/* Return nonzero if register old_reg can be renamed to register new_reg. */
int
sh_hard_regno_rename_ok (old_reg, new_reg)
unsigned int old_reg ATTRIBUTE_UNUSED;
struct sh_args {
int arg_count[2];
int force_mem;
- /* Non-zero if a prototype is available for the function. */
+ /* Nonzero if a prototype is available for the function. */
int prototype_p;
/* The number of an odd floating-point register, that should be used
for the next argument of type float. */
\f
/* Operand constraints. */
-/* Return non-zero only if OP is a register of mode MODE,
+/* Return nonzero only if OP is a register of mode MODE,
or const0_rtx. */
int
return 0;
}
-/* Return non-zero only if OP is const1_rtx. */
+/* Return nonzero only if OP is const1_rtx. */
int
const1_operand (op, mode)
return 0;
}
-/* Return non-zero if REG is not used after INSN.
+/* Return nonzero if REG is not used after INSN.
We assume REG is a reload reg, and therefore does
not live past labels or calls or jumps. */
int
XEXP (OP, 0) is assumed to be a condition code register (integer or
floating point) and its mode specifies what kind of comparison we made.
- REVERSED is non-zero if we should reverse the sense of the comparison.
+ REVERSED is nonzero if we should reverse the sense of the comparison.
- ANNUL is non-zero if we should generate an annulling branch.
+ ANNUL is nonzero if we should generate an annulling branch.
- NOOP is non-zero if we have to follow this branch by a noop.
+ NOOP is nonzero if we have to follow this branch by a noop.
INSN, if set, is the insn. */
operand number of the reg. OP is the conditional expression. The mode
of REG says what kind of comparison we made.
- REVERSED is non-zero if we should reverse the sense of the comparison.
+ REVERSED is nonzero if we should reverse the sense of the comparison.
- ANNUL is non-zero if we should generate an annulling branch.
+ ANNUL is nonzero if we should generate an annulling branch.
- NOOP is non-zero if we have to follow this branch by a noop. */
+ NOOP is nonzero if we have to follow this branch by a noop. */
char *
output_v9branch (op, dest, reg, label, reversed, annul, noop, insn)
#define MASK_V9 0x40
#define TARGET_V9 (target_flags & MASK_V9)
-/* Non-zero to generate code that uses the instructions deprecated in
+/* Nonzero to generate code that uses the instructions deprecated in
the v9 architecture. This option only applies to v9 systems. */
/* ??? This isn't user selectable yet. It's used to enable such insns
on 32 bit v9 systems and for the moment they're permanently disabled
#define MASK_ISA \
(MASK_V8 + MASK_SPARCLITE + MASK_SPARCLET + MASK_V9 + MASK_DEPRECATED_V8_INSNS)
-/* Non-zero means don't pass `-assert pure-text' to the linker. */
+/* Nonzero means don't pass `-assert pure-text' to the linker. */
#define MASK_IMPURE_TEXT 0x100
#define TARGET_IMPURE_TEXT (target_flags & MASK_IMPURE_TEXT)
#define MASK_HARD_QUAD 0x800
#define TARGET_HARD_QUAD (target_flags & MASK_HARD_QUAD)
-/* Non-zero on little-endian machines. */
+/* Nonzero on little-endian machines. */
/* ??? Little endian support currently only exists for sparclet-aout and
sparc64-elf configurations. May eventually want to expand the support
to all targets, but for now it's kept local to only those two. */
/* 0x20000,0x40000 unused */
-/* Non-zero means use a stack bias of 2047. Stack offsets are obtained by
+/* Nonzero means use a stack bias of 2047. Stack offsets are obtained by
adding 2047 to %sp. This option is for v9 only and is the default. */
#define MASK_STACK_BIAS 0x80000
#define TARGET_STACK_BIAS (target_flags & MASK_STACK_BIAS)
/* 0x100000,0x200000 unused */
-/* Non-zero means -m{,no-}fpu was passed on the command line. */
+/* Nonzero means -m{,no-}fpu was passed on the command line. */
#define MASK_FPU_SET 0x400000
#define TARGET_FPU_SET (target_flags & MASK_FPU_SET)
call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; \
} \
/* If the user has passed -f{fixed,call-{used,saved}}-g5 */ \
- /* then honour it. */ \
+ /* then honor it. */ \
if (TARGET_ARCH32 && fixed_regs[5]) \
fixed_regs[5] = 1; \
else if (TARGET_ARCH64 && fixed_regs[5] == 2) \
fixed_regs[regno] = 1; \
} \
/* If the user has passed -f{fixed,call-{used,saved}}-g2 */ \
- /* then honour it. Likewise with g3 and g4. */ \
+ /* then honor it. Likewise with g3 and g4. */ \
if (fixed_regs[2] == 2) \
fixed_regs[2] = ! TARGET_APP_REGS; \
if (fixed_regs[3] == 2) \
struct sparc_args {
int words; /* number of words passed so far */
- int prototype_p; /* non-zero if a prototype is present */
- int libcall_p; /* non-zero if a library call */
+ int prototype_p; /* nonzero if a prototype is present */
+ int libcall_p; /* nonzero if a library call */
};
#define CUMULATIVE_ARGS struct sparc_args
processing is needed. */
#define SELECT_CC_MODE(OP,X,Y) select_cc_mode ((OP), (X), (Y))
-/* Return non-zero if MODE implies a floating point inequality can be
+/* Return nonzero if MODE implies a floating point inequality can be
reversed. For SPARC this is always true because we have a full
compliment of ordered and unordered comparisons, but until generic
code knows how to reverse it correctly we keep the old definition. */
;; SPARC V9 conditional move instructions.
;; We can handle larger constants here for some flavors, but for now we keep
-;; it simple and only allow those constants supported by all flavours.
+;; it simple and only allow those constants supported by all flavors.
;; Note that emit_conditional_move canonicalizes operands 2,3 so that operand
;; 3 contains the constant if one is present, but we handle either for
;; generality (sparc.c puts a constant in operand 2).
OP is the conditional expression, or NULL for branch-always.
- REVERSED is non-zero if we should reverse the sense of the comparison.
+ REVERSED is nonzero if we should reverse the sense of the comparison.
INSN is the insn. */
OP is the conditional expression (OP is never NULL_RTX).
- REVERSED is non-zero if we should reverse the sense of the comparison.
+ REVERSED is nonzero if we should reverse the sense of the comparison.
INSN is the insn. */
return record;
}
-/* Implement the stdarg/varargs va_start macro. STDARG_P is non-zero if this
+/* Implement the stdarg/varargs va_start macro. STDARG_P is nonzero if this
is stdarg.h instead of varargs.h. VALIST is the tree of the va_list
variable to initialize. NEXTARG is the machine independent notion of the
'next' argument after the variable arguments. */
/* Certain machines have the property that some registers cannot be copied to
some other registers without using memory. Define this macro on those
- machines to be a C expression that is non-zero if objects of mode M in
+ machines to be a C expression that is nonzero if objects of mode M in
registers of CLASS1 can only be copied to registers of class CLASS2 by
storing a register of CLASS1 into memory and loading that memory location
into a register of CLASS2.
few registers of certain classes that there would not be enough registers to
use as spill registers if this were done.
- Define `SMALL_REGISTER_CLASSES' to be an expression with a non-zero value on
- these machines. When this macro has a non-zero value, the compiler allows
+ Define `SMALL_REGISTER_CLASSES' to be an expression with a nonzero value on
+ these machines. When this macro has a nonzero value, the compiler allows
registers explicitly used in the rtl to be used as spill registers but
avoids extending the lifetime of these registers.
- It is always safe to define this macro with a non-zero value, but if you
+ It is always safe to define this macro with a nonzero value, but if you
unnecessarily define it, you will reduce the amount of optimizations that
can be performed in some cases. If you do not define this macro with a
- non-zero value when it is required, the compiler will run out of spill
+ nonzero value when it is required, the compiler will run out of spill
registers and print a fatal error message. For most machines, you should
not define this macro at all. */
/* #define SMALL_REGISTER_CLASSES */
{ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \
}
-/* A C expression that returns non-zero if the compiler is allowed to try to
+/* A C expression that returns nonzero if the compiler is allowed to try to
replace register number FROM with register number TO. This macro need only
be defined if `ELIMINABLE_REGS' is defined, and will usually be the constant
1, since most of the cases preventing register elimination are things that
You may use the macro `MUST_PASS_IN_STACK (MODE, TYPE)' in the definition of
this macro to determine if this argument is of a type that must be passed in
the stack. If `REG_PARM_STACK_SPACE' is not defined and `FUNCTION_ARG'
- returns non-zero for such an argument, the compiler will abort. If
+ returns nonzero for such an argument, the compiler will abort. If
`REG_PARM_STACK_SPACE' is defined, the argument will be computed in the
stack and then loaded into a register. */
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
#define BUILD_VA_LIST_TYPE(NODE) \
((NODE) = xstormy16_build_va_list ())
-/* Implement the stdarg/varargs va_start macro. STDARG_P is non-zero if this
+/* Implement the stdarg/varargs va_start macro. STDARG_P is nonzero if this
is stdarg.h instead of varargs.h. VALIST is the tree of the va_list
variable to initialize. NEXTARG is the machine independent notion of the
'next' argument after the variable arguments. If not defined, a standard
times greater than aligned accesses, for example if they are emulated in a
trap handler.
- When this macro is non-zero, the compiler will act as if `STRICT_ALIGNMENT'
- were non-zero when generating code for block moves. This can cause
+ When this macro is nonzero, the compiler will act as if `STRICT_ALIGNMENT'
+ were nonzero when generating code for block moves. This can cause
significantly more instructions to be produced. Therefore, do not set this
- macro non-zero if unaligned accesses only add a cycle or two to the time for
+ macro nonzero if unaligned accesses only add a cycle or two to the time for
a memory access.
If the value of this macro is always zero, it need not be defined. */
/* #define ASM_OUTPUT_ASCII(STREAM, PTR, LEN) */
/* You may define this macro as a C expression. You should define the
- expression to have a non-zero value if GNU CC should output the
+ expression to have a nonzero value if GNU CC should output the
constant pool for a function before the code for the function, or
a zero value if GNU CC should output the constant pool after the
function. If you do not define this macro, the usual case, GNU CC
/* A C expression that is nonzero if on this machine the number of bits
actually used for the count of a shift operation is equal to the number of
bits needed to represent the size of the object being shifted. When this
- macro is non-zero, the compiler will assume that it is safe to omit a
+ macro is nonzero, the compiler will assume that it is safe to omit a
sign-extend, zero-extend, and certain bitwise `and' instructions that
truncates the count of a shift operation. On machines that have
instructions that act on bitfields at variable positions, which may include
instructions. */
/* #define STORE_FLAG_VALUE */
-/* A C expression that gives a non-zero floating point value that is returned
+/* A C expression that gives a nonzero floating point value that is returned
when comparison operators with floating-point results are true. Define this
macro on machine that have comparison operations that return floating-point
values. If there are no such operations, do not define this macro. */
&& (((REGNO (op) >= 20) && REGNO (op) <= 31)));
}
-/* Return non-zero if the given RTX is suitable for collapsing into
+/* Return nonzero if the given RTX is suitable for collapsing into
jump to a function epilogue. */
int
pattern_is_ok_for_epilogue (op, mode)
}
-/* Return non-zero if the given RTX is suitable for collapsing into
+/* Return nonzero if the given RTX is suitable for collapsing into
a jump to a function prologue. */
int
pattern_is_ok_for_prologue (op, mode)
}
}
-/* Return non-zero if the given RTX is suitable
+/* Return nonzero if the given RTX is suitable
for collapsing into a DISPOSE instruction. */
int
return buff;
}
-/* Return non-zero if the given RTX is suitable
+/* Return nonzero if the given RTX is suitable
for collapsing into a PREPARE instruction. */
int
LEVEL is the optimization level specified; 2 if `-O2' is
specified, 1 if `-O' is specified, and 0 if neither is specified.
- SIZE is non-zero if `-Os' is specified, 0 otherwise.
+ SIZE is nonzero if `-Os' is specified, 0 otherwise.
You should not use this macro to change options that are not
machine-specific. These should uniformly selected by the same
{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM }, \
{ ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM }} \
-/* A C expression that returns non-zero if the compiler is allowed to
+/* A C expression that returns nonzero if the compiler is allowed to
try to replace register number FROM-REG with register number
TO-REG. This macro need only be defined if `ELIMINABLE_REGS' is
defined, and will usually be the constant 1, since most of the
else
abort ();
- /* If REG1 is non-zero, figure out if it is a base or index register. */
+ /* If REG1 is nonzero, figure out if it is a base or index register. */
if (reg1)
{
if (breg != 0 || (offset && GET_CODE (offset) == MEM))
|| GET_CODE (X) == CONST_INT)
-/* Non-zero if X is an address which can be indirected. External symbols
+/* Nonzero if X is an address which can be indirected. External symbols
could be in a sharable image library, so we disallow those. */
#define INDIRECTABLE_ADDRESS_P(X) \
#define INDIRECTABLE_CONSTANT_ADDRESS_P(X) CONSTANT_ADDRESS_P(X)
-/* Non-zero if X is an address which can be indirected. */
+/* Nonzero if X is an address which can be indirected. */
#define INDIRECTABLE_ADDRESS_P(X) \
(CONSTANT_ADDRESS_P (X) \
|| (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X)) \
projects / gcc.git / commitdiff