* config/fp-bit.c: Follow spelling conventions.
* config/d30v/d30v.c: Likewise.
* config/d30v/d30v.h: Likewise.
* config/fr30/fr30.c: Likewise.
* config/fr30/fr30.h: Likewise.
* config/fr30/fr30.md: Likewise.
* config/frv/frv.c: Likewise.
* config/frv/frv.h: Likewise.
* config/h8300/h8300.c: Likewise.
* config/h8300/lib1funcs.asm: Likewise.
* config/i370/i370.c: Likewise.
* config/i386/i386.h: Likewise.
* config/i386/i386.md: Likewise.
* config/i386/pentium.md: Likewise.
* config/i386/winnt.c: Likewise.
* config/i960/i960.c: Likewise.
* config/ia64/ia64.h: Likewise.
* config/ip2k/ip2k.c: Likewise.
* config/ip2k/ip2k.h: Likewise.
* config/ip2k/ip2k.md: Likewise.
* config/ip2k/libgcc.S: Likewise.
From-SVN: r57303
+2002-09-19 Kazu Hirata <kazu@cs.umass.edu>
+
+ * config/fp-bit.c: Follow spelling conventions.
+ * config/d30v/d30v.c: Likewise.
+ * config/d30v/d30v.h: Likewise.
+ * config/fr30/fr30.c: Likewise.
+ * config/fr30/fr30.h: Likewise.
+ * config/fr30/fr30.md: Likewise.
+ * config/frv/frv.c: Likewise.
+ * config/frv/frv.h: Likewise.
+ * config/h8300/h8300.c: Likewise.
+ * config/h8300/lib1funcs.asm: Likewise.
+ * config/i370/i370.c: Likewise.
+ * config/i386/i386.h: Likewise.
+ * config/i386/i386.md: Likewise.
+ * config/i386/pentium.md: Likewise.
+ * config/i386/winnt.c: Likewise.
+ * config/i960/i960.c: Likewise.
+ * config/ia64/ia64.h: Likewise.
+ * config/ip2k/ip2k.c: Likewise.
+ * config/ip2k/ip2k.h: Likewise.
+ * config/ip2k/ip2k.md: Likewise.
+ * config/ip2k/libgcc.S: Likewise.
+
2002-09-19 Stephen Clarke <stephen.clarke@superh.com>
* config/sh/sh.h (UNSPEC_GOTOFF_P): Define.
2002-09-18 Kazu Hirata <kazu@cs.umass.edu>
- * config/s390/s390.c: Follow spelling convention.
+ * config/s390/s390.c: Follow spelling conventions.
* config/sh/lib1funcs.asm: Likewise.
* config/sh/sh.c: Likewise.
* config/sh/sh.h: Likewise.
}
\f
-/* Return non-zero if this function is known to have a null or 1 instruction epilogue. */
+/* Return nonzero if this function is known to have a null or 1 instruction epilogue. */
int
direct_return ()
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. */
/* 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 */
{ FRAME_POINTER_REGNUM, STACK_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-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 cases preventing register elimination are
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. */
(VALIST) = d30v_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. */
#include "tconfig.h"
#include "fp-bit.h"
-/* The following macros can be defined to change the behaviour of this file:
+/* The following macros can be defined to change the behavior of this file:
FLOAT: Implement a `float', aka SFmode, fp library. If this is not
defined, then this file implements a `double', aka DFmode, fp library.
FLOAT_ONLY: Used with FLOAT, to implement a `float' only library, i.e.
SP ->| | /
+-----------------------+
- Note, AP is a fake hard register. It will be eliminated in favour of
+ Note, AP is a fake hard register. It will be eliminated in favor of
SP or FP as appropriate.
Note, Some or all of the stack sections above may be omitted if they
{FRAME_POINTER_REGNUM, STACK_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
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. */
)
;; Do not allow an eliminable register in the source register. It
-;; might be eliminated in favour of the stack pointer, probably
+;; might be eliminated in favor of the stack pointer, probably
;; increasing the offset, and so rendering the instruction illegal.
(define_insn "addsi_small_int"
[(set (match_operand:SI 0 "register_operand" "=r,r")
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 optimization
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. */
cc_reg,
const0_rtx)));
- /* If are taking the min/max of a non-zero constant, load that first, and
+ /* If are taking the min/max of a nonzero constant, load that first, and
then do a conditional move of the other value. */
if (GET_CODE (src2) == CONST_INT && INTVAL (src2) != 0)
{
}
break;
- /* Non-zero constants should be loaded into an FPR through a GPR. */
+ /* Nonzero constants should be loaded into an FPR through a GPR. */
case QUAD_FPR_REGS:
case FEVEN_REGS:
case FPR_REGS:
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 optimization
{FRAME_POINTER_REGNUM, STACK_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) \
frv_setup_incoming_varargs (& ARGS_SO_FAR, (int) MODE, TYPE, \
& PRETEND_ARGS_SIZE, SECOND_TIME)
-/* 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
const char *special;
/* Insn for a one-bit shift. Valid when ALG is either SHIFT_INLINE
- or SHIFT_SPECIAL, and REMAINDER is non-zero. */
+ or SHIFT_SPECIAL, and REMAINDER is nonzero. */
const char *shift1;
/* Insn for a two-bit shift. Valid when ALG is either SHIFT_INLINE
- or SHIFT_SPECIAL, and REMAINDER is non-zero. */
+ or SHIFT_SPECIAL, and REMAINDER is nonzero. */
const char *shift2;
/* Valid CC flags. */
tmp = gen_rtx_PLUS (QImode, counter, GEN_INT (-1));
emit_insn (gen_rtx_SET (VOIDmode, counter, tmp));
- /* If the loop counter is non-zero, we go back to the beginning
+ /* If the loop counter is nonzero, we go back to the beginning
of the loop. */
emit_cmp_and_jump_insns (counter, GEN_INT (0), NE, NULL_RTX, QImode, 1,
start_label);
space. For the H8/300H and H8S, the C version is good enough. */
#ifdef __H8300__
/* We still treat NANs different than libgcc2.c, but then, the
- behaviour is undefined anyways. */
+ behavior is undefined anyways. */
.global ___fixunssfsi
___fixunssfsi:
cmp.b #0x47,r0h
-- subtracts stackframe size from the stack pointer.
-- stores backpointer to old caller stack.
- XXX hack alert -- if the global var int leaf_function is non-zero,
+ XXX hack alert -- if the global var int leaf_function is nonzero,
then this is a leaf, and it might be possible to optimize the prologue
into doing even less, e.g. not grabbing a new stackframe or maybe just a
partial stack frame.
#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) \
ix86_function_arg_boundary ((MODE), (TYPE))
-/* Set this non-zero if move instructions will actually fail to work
+/* Set this nonzero if move instructions will actually fail to work
when given unaligned data. */
#define STRICT_ALIGNMENT 0
cost many 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
+ 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
+ produced. Therefore, do not set this 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 SELECT_CC_MODE(OP, X, Y) ix86_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. */
#define REVERSIBLE_CC_MODE(MODE) 1
(use (match_dup 3))
(clobber (reg:CC 17))])]
{
- /* Avoid use of cltd in favour of a mov+shift. */
+ /* Avoid use of cltd in favor of a mov+shift. */
if (!TARGET_USE_CLTD && !optimize_size)
{
if (true_regnum (operands[1]))
(use (match_dup 3))
(clobber (reg:CC 17))])]
{
- /* Avoid use of cltd in favour of a mov+shift. */
+ /* Avoid use of cltd in favor of a mov+shift. */
if (!TARGET_USE_CLTD && !optimize_size)
{
if (true_regnum (operands[1]))
;; cmpCC op0, op4 - set op0 to 0 or ffffffff depending on the comparison
;; and op2, op0 - zero op2 if comparison was false
;; nand op0, op3 - load op3 to op0 if comparison was false
-;; or op2, op0 - get the non-zero one into the result.
+;; or op2, op0 - get the nonzero one into the result.
(define_split
[(set (match_operand 0 "register_operand" "")
(if_then_else (match_operator 1 "sse_comparison_operator"
;; |
;; fpu
;; We add dummy "port" pipes allocated only first cycle of
-;; instruction to specify this behaviour.
+;; instruction to specify this behavior.
(define_cpu_unit "pentium-portu,pentium-portv" "pentium")
(define_cpu_unit "pentium-u,pentium-v" "pentium")
return t;
}
-/* Return non-zero if DECL is a dllexport'd object. */
+/* Return nonzero if DECL is a dllexport'd object. */
int
i386_pe_dllexport_p (decl)
return 0;
}
-/* Return non-zero if DECL is a dllimport'd object. */
+/* Return nonzero if DECL is a dllimport'd object. */
int
i386_pe_dllimport_p (decl)
return 0;
}
-/* Return non-zero if SYMBOL is marked as being dllexport'd. */
+/* Return nonzero if SYMBOL is marked as being dllexport'd. */
int
i386_pe_dllexport_name_p (symbol)
return symbol[0] == '@' && symbol[1] == 'e' && symbol[2] == '.';
}
-/* Return non-zero if SYMBOL is marked as being dllimport'd. */
+/* Return nonzero if SYMBOL is marked as being dllimport'd. */
int
i386_pe_dllimport_name_p (symbol)
/* Mark a function appropriately. This should only be called for
functions for which we are not emitting COFF debugging information.
FILE is the assembler output file, NAME is the name of the
- function, and PUBLIC is non-zero if the function is globally
+ function, and PUBLIC is nonzero if the function is globally
visible. */
void
return -1;
}
-/* Return non-zero if OP is a mask, i.e. all one bits are consecutive.
- The return value indicates how many consecutive non-zero bits exist
+/* Return nonzero if OP is a mask, i.e. all one bits are consecutive.
+ The return value indicates how many consecutive nonzero bits exist
if this is a mask. This is the same as the next function, except that
it does not indicate what the start and stop bit positions are. */
#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
/* By default, the C++ compiler will use function addresses in the
- vtable entries. Setting this non-zero tells the compiler to use
+ vtable entries. Setting this nonzero tells the compiler to use
function descriptors instead. The value of this macro says how
many words wide the descriptor is (normally 2). It is assumed
that the address of a function descriptor may be treated as a
/* 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. */
{RETURN_ADDRESS_POINTER_REGNUM, BR_REG (0)}, \
}
-/* 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. The frame pointer
is automatically handled. */
return 0;
}
-/* Return non-zero if FUNC is a naked function. */
+/* Return nonzero if FUNC is a naked function. */
static int
ip2k_naked_function_p (func)
goto zero;
case GTU:
- code = NE; /* Anything non-zero is GTU. */
+ code = NE; /* Anything nonzero is GTU. */
/* fall-thru */
case EQ:
#endif /* IP2K_MD_REORG_PASS */
/* Look to see if the expression, x, can have any stack references offset by
- a fixed constant, offset. If it definitely can then returns non-zero. */
+ a fixed constant, offset. If it definitely can then returns nonzero. */
static int
ip2k_check_can_adjust_stack_ref (x, offset)
/* Look to see if the expression, x, does not make any memory references
via the specified register. This is very conservative and only returns
- non-zero if we definitely don't have such a memory ref. */
+ nonzero if we definitely don't have such a memory ref. */
static int
ip2k_xexp_not_uses_reg_for_mem (x, regno)
/* `SECONDARY_MEMORY_NEEDED (CLASS1, CLASS2, M)'
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
+ macro on those 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.
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
+ 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
+ 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
+ define this macro with a 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. */
? (flag_omit_frame_pointer && !frame_pointer_needed) : 1)
/* Don't eliminate FP unless we EXPLICITLY_ASKED */
-/* 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
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
+ is not defined and `FUNCTION_ARG' 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. */
cost many 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
+ 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
+ produced. Therefore, do not set this 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.
[(set_attr "skip" "yes")
(set_attr "clobberw" "no")])
-;; IP isn't offsettable but we can fake this behaviour here and win if we would
+;; IP isn't offsettable but we can fake this behavior here and win if we would
;; otherwise use DP and require a reload from IP. This instruction is only
;; matched by peephole2 operations.
;;
return \"\";
}")
-;; IP isn't offsettable but we can fake this behaviour here and win if we would
+;; IP isn't offsettable but we can fake this behavior here and win if we would
;; otherwise use DP and require a reload from IP. This instruction is only
;; matched by peephole2 operations.
;;
;; Tidy up stack slot addressing where we've eliminated some registers.
;; This looks like something strange going on though as gcc-2.97 didn't
-;; exhibit this behaviour, whereas gcc-3.0.4 does.
+;; exhibit this behavior, whereas gcc-3.0.4 does.
;;
(define_peephole2
[(set (match_operand:HI 0 "register_operand" "")
mov w, 8(SP)
mov ipl, w
- test 10(SP) ; If we have a non-zero LSB then adjust the
+ test 10(SP) ; If we have a nonzero LSB then adjust the
sz ; MSB of the loop count to allow us to use
inc 9(SP) ; skip tricks!
projects / gcc.git / commitdiff