* dbxout.c: Follow spelling conventions.
* defaults.h: Likewise.
* df.c: Likewise.
* diagnostic.h: Likewise.
* doloop.c: Likewise.
* dwarf2out.c: Likewise.
* dwarfout.c: Likewise.
* emit-rtl.c: Likewise.
* except.c: Likewise.
* explow.c: Likewise.
* expmed.c: Likewise.
* expr.c: Likewise.
* expr.h: Likewise.
* flags.h: Likewise.
* flow.c: Likewise.
* fold-const.c: Likewise.
* function.c: Likewise.
* function.h: Likewise.
* gcc.c: Likewise.
* gcov-io.h: Likewise.
* gcov.c: Likewise.
* gcse.c: Likewise.
* genattrtab.c: Likewise.
* genconfig.c: Likewise.
* genrecog.c: Likewise.
* ggc-page.c: Likewise.
* ggc.h: Likewise.
* global.c: Likewise.
* gthr-win32.h: Likewise.
* integrate.c: Likewise.
* jump.c: Likewise.
* langhooks.c: Likewise.
* langhooks.h: Likewise.
* line-map.h: Likewise.
* local-alloc.c: Likewise.
* longlong.h: Likewise.
* loop.c: Likewise.
* loop.h: Likewise.
From-SVN: r57406
+2002-09-22 Kazu Hirata <kazu@cs.umass.edu>
+
+ * dbxout.c: Follow spelling conventions.
+ * defaults.h: Likewise.
+ * df.c: Likewise.
+ * diagnostic.h: Likewise.
+ * doloop.c: Likewise.
+ * dwarf2out.c: Likewise.
+ * dwarfout.c: Likewise.
+ * emit-rtl.c: Likewise.
+ * except.c: Likewise.
+ * explow.c: Likewise.
+ * expmed.c: Likewise.
+ * expr.c: Likewise.
+ * expr.h: Likewise.
+ * flags.h: Likewise.
+ * flow.c: Likewise.
+ * fold-const.c: Likewise.
+ * function.c: Likewise.
+ * function.h: Likewise.
+ * gcc.c: Likewise.
+ * gcov-io.h: Likewise.
+ * gcov.c: Likewise.
+ * gcse.c: Likewise.
+ * genattrtab.c: Likewise.
+ * genconfig.c: Likewise.
+ * genrecog.c: Likewise.
+ * ggc-page.c: Likewise.
+ * ggc.h: Likewise.
+ * global.c: Likewise.
+ * gthr-win32.h: Likewise.
+ * integrate.c: Likewise.
+ * jump.c: Likewise.
+ * langhooks.c: Likewise.
+ * langhooks.h: Likewise.
+ * line-map.h: Likewise.
+ * local-alloc.c: Likewise.
+ * longlong.h: Likewise.
+ * loop.c: Likewise.
+ * loop.h: Likewise.
+
Tue Aug 27 22:26:35 CEST 2002 Jan Hubicka <jh@suse.cz>
* i386.h (BIGGEST_FIELD_ALIGNMENT): Set proper default for x86_64.
#endif
}
-/* Output definitions of all the decls in a chain. Return non-zero if
+/* Output definitions of all the decls in a chain. Return nonzero if
anything was output */
int
#endif
/* 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
}
-/* Return non-zero if any of the requested blocks in the bitmap
+/* Return nonzero if any of the requested blocks in the bitmap
BLOCKS have been modified. */
static int
df_modified_p (df, blocks)
}
-/* Return non-zero if all DF dominates all the uses within the bitmap
+/* Return nonzero if all DF dominates all the uses within the bitmap
BLOCKS. */
static int
df_def_dominates_uses_p (df, def, blocks)
}
-/* Return non-zero if all the defs of INSN within BB dominates
+/* Return nonzero if all the defs of INSN within BB dominates
all the corresponding uses. */
int
df_insn_dominates_uses_p (df, bb, insn, blocks)
}
-/* Return non-zero if REG used in multiple basic blocks. */
+/* Return nonzero if REG used in multiple basic blocks. */
int
df_reg_global_p (df, reg)
struct df *df;
}
-/* Return non-zero if REG live at start of BB. */
+/* Return nonzero if REG live at start of BB. */
int
df_bb_reg_live_start_p (df, bb, reg)
struct df *df ATTRIBUTE_UNUSED;
}
-/* Return non-zero if REG live at end of BB. */
+/* Return nonzero if REG live at end of BB. */
int
df_bb_reg_live_end_p (df, bb, reg)
struct df *df ATTRIBUTE_UNUSED;
/* Similarly, but for sorrys. */
#define sorrycount diagnostic_kind_count (global_dc, DK_SORRY)
-/* Returns non-zero if warnings should be emitted. */
+/* Returns nonzero if warnings should be emitted. */
#define diagnostic_report_warnings_p() \
(!inhibit_warnings \
&& !(in_system_header && !warn_system_headers))
/* Return an estimate of the maximum number of loop iterations for the
loop specified by LOOP or zero if the loop is not normal.
- MODE is the mode of the iteration count and NONNEG is non-zero if
+ MODE is the mode of the iteration count and NONNEG is nonzero if
the iteration count has been proved to be non-negative. */
static unsigned HOST_WIDE_INT
doloop_iterations_max (loop_info, mode, nonneg)
}
-/* Return non-zero if the loop specified by LOOP is suitable for
+/* Return nonzero if the loop specified by LOOP is suitable for
the use of special low-overhead looping instructions. */
static int
doloop_valid_p (loop, jump_insn)
number of loop iterations, ITERATIONS_MAX is a CONST_INT specifying
the maximum number of loop iterations, and DOLOOP_INSN is the
low-overhead looping insn to emit at the end of the loop. This
- returns non-zero if it was successful. */
+ returns nonzero if it was successful. */
static int
doloop_modify (loop, iterations, iterations_max,
doloop_seq, start_label, condition)
not present, we emit one. The loop to modify is described by LOOP.
ITERATIONS_MAX is a CONST_INT specifying the estimated maximum
number of loop iterations. DOLOOP_INSN is the low-overhead looping
- insn to insert. Returns non-zero if loop successfully modified. */
+ insn to insert. Returns nonzero if loop successfully modified. */
static int
doloop_modify_runtime (loop, iterations_max,
doloop_seq, start_label, mode, condition)
suitable. We distinguish between loops with compile-time bounds
and those with run-time bounds. Information from LOOP is used to
compute the number of iterations and to determine whether the loop
- is a candidate for this optimization. Returns non-zero if loop
+ is a candidate for this optimization. Returns nonzero if loop
successfully modified. */
int
doloop_optimize (loop)
had better be the one we think we're using for this purpose.
Except: If the register being saved is the CFA register, and the
- offset is non-zero, we are saving the CFA, so we assume we have to
+ offset is nonzero, we are saving the CFA, so we assume we have to
use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
the intent is to save the value of SP from the previous frame.
#define ASM_COMMENT_START ";#"
#endif
-/* Define a macro which returns non-zero for a TYPE_DECL which was
+/* Define a macro which returns nonzero for a TYPE_DECL which was
implicitly generated for a tagged type.
Note that unlike the gcc front end (which generates a NULL named
return type;
}
-/* Return non-zero if the given type node represents a tagged type. */
+/* Return nonzero if the given type node represents a tagged type. */
static inline int
is_tagged_type (type)
}
}
-/* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
+/* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
given input type is a Dwarf "fundamental" type. Otherwise return null. */
static inline int
fprintf ((FILE), "%s", reg_names[REGNO (RTX)])
#endif
-/* Define a macro which returns non-zero for any tagged type which is
+/* Define a macro which returns nonzero for any tagged type which is
used (directly or indirectly) in the specification of either some
function's return type or some formal parameter of some function.
We use this macro when we are operating in "terse" mode to help us
for these nodes. For now, we have to just fake it. It it safe for
us to simply return zero for all complete tagged types (which will
get forced out anyway if they were used in the specification of some
- formal or return type) and non-zero for all incomplete tagged types.
+ formal or return type) and nonzero for all incomplete tagged types.
*/
#define TYPE_USED_FOR_FUNCTION(tagged_type) (TYPE_SIZE (tagged_type) == 0)
-/* Define a macro which returns non-zero for a TYPE_DECL which was
+/* Define a macro which returns nonzero for a TYPE_DECL which was
implicitly generated for a tagged type.
Note that unlike the gcc front end (which generates a NULL named
#define PENDING_SIBLINGS_INCREMENT 64
-/* Non-zero if we are performing our file-scope finalization pass and if
+/* Nonzero if we are performing our file-scope finalization pass and if
we should force out Dwarf descriptions of any and all file-scope
tagged types which are still incomplete types. */
return type;
}
-/* Return non-zero if the given type node represents a tagged type. */
+/* Return nonzero if the given type node represents a tagged type. */
static inline int
is_tagged_type (type)
write_modifier_bytes_1 (type, decl_const, decl_volatile, 0);
}
\f
-/* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
+/* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
given input type is a Dwarf "fundamental" type. Otherwise return zero. */
static inline int
TREE_ASM_WRITTEN (type) = 1;
}
-/* Return non-zero if it is legitimate to output DIEs to represent a
+/* Return nonzero if it is legitimate to output DIEs to represent a
given type while we are generating the list of child DIEs for some
DIE (e.g. a function or lexical block DIE) associated with a given scope.
return (hashval_t) INTVAL ((struct rtx_def *) x);
}
-/* Returns non-zero if the value represented by X (which is really a
+/* Returns nonzero if the value represented by X (which is really a
CONST_INT) is the same as that given by Y (which is really a
HOST_WIDE_INT *). */
return h;
}
-/* Returns non-zero if the value represented by X (really a ...)
+/* Returns nonzero if the value represented by X (really a ...)
is the same as that represented by Y (really a ...) */
static int
const_double_htab_eq (x, y)
^ (size_t) p->expr);
}
-/* Returns non-zero if the value represented by X (which is really a
+/* Returns nonzero if the value represented by X (which is really a
mem_attrs *) is the same as that given by Y (which is also really a
mem_attrs *). */
unsigned int memalign = MEM_ALIGN (memref);
/* ??? Prefer to create garbage instead of creating shared rtl.
- This may happen even if offset is non-zero -- consider
+ This may happen even if offset is nonzero -- consider
(plus (plus reg reg) const_int) -- so do this always. */
addr = copy_rtx (addr);
/* Try splitting insns that can be split for better scheduling.
PAT is the pattern which might split.
TRIAL is the insn providing PAT.
- LAST is non-zero if we should return the last insn of the sequence produced.
+ LAST is nonzero if we should return the last insn of the sequence produced.
If this routine succeeds in splitting, it returns the first or last
replacement insn depending on the value of LAST. Otherwise, it
\f
/* Routine to see if exception handling is turned on.
- DO_WARN is non-zero if we want to inform the user that exception
+ DO_WARN is nonzero if we want to inform the user that exception
handling is turned off.
This is used to ensure that -fexceptions has been specified if the
PUNSIGNEDP points to the signedness of the type and may be adjusted
to show what signedness to use on extension operations.
- FOR_CALL is non-zero if this call is promoting args for a call. */
+ FOR_CALL is nonzero if this call is promoting args for a call. */
enum machine_mode
promote_mode (type, mode, punsignedp, for_call)
always know its final value at this point in the compilation (it
might depend on the size of the outgoing parameter lists, for
example), so we must align the value to be returned in that case.
- (Note that STACK_DYNAMIC_OFFSET will have a default non-zero value if
+ (Note that STACK_DYNAMIC_OFFSET will have a default nonzero value if
STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined).
We must also do an alignment operation on the returned value if
the stack pointer alignment is less strict that BIGGEST_ALIGNMENT.
static void do_cmp_and_jump PARAMS ((rtx, rtx, enum rtx_code,
enum machine_mode, rtx));
-/* Non-zero means divides or modulus operations are relatively cheap for
+/* Nonzero means divides or modulus operations are relatively cheap for
powers of two, so don't use branches; emit the operation instead.
Usually, this will mean that the MD file will emit non-branch
sequences. */
MODE is the machine mode for the computation.
X and MULT must have mode MODE. ADD may have a different mode.
So can X (defaults to same as MODE).
- UNSIGNEDP is non-zero to do unsigned multiplication. */
+ UNSIGNEDP is nonzero to do unsigned multiplication. */
bool
const_mult_add_overflow_p (x, mult, add, mode, unsignedp)
MODE is the machine mode for the computation.
X and MULT must have mode MODE. ADD may have a different mode.
So can X (defaults to same as MODE).
- UNSIGNEDP is non-zero to do unsigned multiplication.
+ UNSIGNEDP is nonzero to do unsigned multiplication.
This may emit insns. */
rtx
if (code == EQ || code == NE)
{
/* For EQ or NE, one way to do the comparison is to apply an operation
- that converts the operand into a positive number if it is non-zero
+ that converts the operand into a positive number if it is nonzero
or zero if it was originally zero. Then, for EQ, we subtract 1 and
for NE we negate. This puts the result in the sign bit. Then we
normalize with a shift, if needed.
/* This array records the insn_code of insns to perform block clears. */
enum insn_code clrstr_optab[NUM_MACHINE_MODES];
-/* SLOW_UNALIGNED_ACCESS is non-zero if unaligned accesses are very slow. */
+/* SLOW_UNALIGNED_ACCESS is nonzero if unaligned accesses are very slow. */
#ifndef SLOW_UNALIGNED_ACCESS
#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
{
if (TREE_CODE (exp) == CONSTRUCTOR
&& bitpos % BITS_PER_UNIT == 0
- /* If we have a non-zero bitpos for a register target, then we just
+ /* If we have a nonzero bitpos for a register target, then we just
let store_field do the bitfield handling. This is unlikely to
generate unnecessary clear instructions anyways. */
&& (bitpos == 0 || GET_CODE (target) == MEM))
}
\f
/* Return the tree node if an ARG corresponds to a string constant or zero
- if it doesn't. If we return non-zero, set *PTR_OFFSET to the offset
+ if it doesn't. If we return nonzero, set *PTR_OFFSET to the offset
in bytes within the string that ARG is accessing. The type of the
offset will be `sizetype'. */
case NEGATE_EXPR:
case LROTATE_EXPR:
case RROTATE_EXPR:
- /* These cannot change zero->non-zero or vice versa. */
+ /* These cannot change zero->nonzero or vice versa. */
do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
break;
#endif
case MINUS_EXPR:
- /* Non-zero iff operands of minus differ. */
+ /* Nonzero iff operands of minus differ. */
do_compare_and_jump (build (NE_EXPR, TREE_TYPE (exp),
TREE_OPERAND (exp, 0),
TREE_OPERAND (exp, 1)),
If TARGET is nonzero, store the result there if convenient.
- If ONLY_CHEAP is non-zero, only do this if it is likely to be very
+ If ONLY_CHEAP is nonzero, only do this if it is likely to be very
cheap.
Return zero if there is no suitable set-flag instruction
enum machine_mode, rtx, rtx,
enum machine_mode, int));
-/* Return non-zero if the conditional move is supported. */
+/* Return nonzero if the conditional move is supported. */
int can_conditionally_move_p PARAMS ((enum machine_mode mode));
#endif
If OBJECT has BLKmode, SIZE is its length in bytes. */
extern rtx clear_storage PARAMS ((rtx, rtx));
-/* Return non-zero if it is desirable to store LEN bytes generated by
+/* Return nonzero if it is desirable to store LEN bytes generated by
CONSTFUN with several move instructions by store_by_pieces
function. CONSTFUNDATA is a pointer which will be passed as argument
in every CONSTFUN call.
extern int flag_eliminate_dwarf2_dups;
-/* Non-zero means to collect statistics which might be expensive
+/* Nonzero means to collect statistics which might be expensive
and to print them when we are done. */
extern int flag_detailed_statistics;
/* The length of mem_set_list. */
int mem_set_list_len;
- /* Non-zero if the value of CC0 is live. */
+ /* Nonzero if the value of CC0 is live. */
int cc0_live;
/* Flags controling the set of information propagate_block collects. */
/* Free the variables allocated by find_basic_blocks.
- KEEP_HEAD_END_P is non-zero if basic_block_info is not to be freed. */
+ KEEP_HEAD_END_P is nonzero if basic_block_info is not to be freed. */
void
free_basic_block_vars (keep_head_end_p)
case, the resulting set will be equal to the union of the two sets that
would otherwise be computed.
- Return non-zero if an INSN is deleted (i.e. by dead code removal). */
+ Return nonzero if an INSN is deleted (i.e. by dead code removal). */
int
propagate_block (bb, live, local_set, cond_local_set, flags)
(SET expressions whose destinations are registers dead after the insn).
NEEDED is the regset that says which regs are alive after the insn.
- Unless CALL_OK is non-zero, an insn is needed if it contains a CALL.
+ Unless CALL_OK is nonzero, an insn is needed if it contains a CALL.
If X is the entire body of an insn, NOTES contains the reg notes
pertaining to the insn. */
int num_hi_sig, den_hi_sig;
unsigned HOST_WIDE_INT quo_est, scale;
- /* Find the highest non-zero divisor digit. */
+ /* Find the highest nonzero divisor digit. */
for (i = 4 - 1;; i--)
if (den[i] != 0)
{
^ (TREE_OVERFLOW (t) << 20));
}
-/* Return non-zero if the value represented by *X (an INTEGER_CST tree node)
+/* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
is the same as that given by *Y, which is the same. */
static int
}
\f
/* Return nonzero if two operands are necessarily equal.
- If ONLY_CONST is non-zero, only return non-zero for constants.
+ If ONLY_CONST is nonzero, only return nonzero for constants.
This function tests whether the operands are indistinguishable;
it does not test whether they are equal using C's == operation.
The distinction is important for IEEE floating point, because
/* See if ARG is an expression that is either a comparison or is performing
arithmetic on comparisons. The comparisons must only be comparing
two different values, which will be stored in *CVAL1 and *CVAL2; if
- they are non-zero it means that some operands have already been found.
+ they are nonzero it means that some operands have already been found.
No variables may be used anywhere else in the expression except in the
comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
the expression and save_expr needs to be called with CVAL1 and CVAL2.
}
\f
/* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
- starting at BITPOS. The field is unsigned if UNSIGNEDP is non-zero. */
+ starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero. */
static tree
make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
return inner;
}
-/* Return non-zero if MASK represents a mask of SIZE ones in the low-order
+/* Return nonzero if MASK represents a mask of SIZE ones in the low-order
bit positions. */
static int
/* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
- expression, and ARG to `a'. If COND_FIRST_P is non-zero, then the
+ expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
COND is the first argument to CODE; otherwise (as in the example
given here), it is the second argument. TYPE is the type of the
original expression. */
TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
ADDEND is the same as X.
- X + 0 and X - 0 both give X when X is NaN, infinite, or non-zero
+ X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
and finite. The problematic cases are when X is zero, and its mode
has signed zeros. In the case of rounding towards -infinity,
X - 0 is not the same as X because 0 - 0 is -0. In other rounding
tree type;
/* The value of `sequence_rtl_expr' when this temporary is allocated. */
tree rtl_expr;
- /* Non-zero if this temporary is currently in use. */
+ /* Nonzero if this temporary is currently in use. */
char in_use;
- /* Non-zero if this temporary has its address taken. */
+ /* Nonzero if this temporary has its address taken. */
char addr_taken;
/* Nesting level at which this slot is being used. */
int level;
- /* Non-zero if this should survive a call to free_temp_slots. */
+ /* Nonzero if this should survive a call to free_temp_slots. */
int keep;
/* The offset of the slot from the frame_pointer, including extra space
for alignment. This info is for combine_temp_slots. */
return (hashval_t) m->key;
}
-/* Return non-zero if K1 and K2 (two REGs) are the same. */
+/* Return nonzero if K1 and K2 (two REGs) are the same. */
static int
insns_for_mem_comp (k1, k2)
/* Subroutine of the preceding procedures: Given RTL representing a
decl and the size of the object, do any instantiation required.
- If VALID_ONLY is non-zero, it means that the RTL should only be
+ If VALID_ONLY is nonzero, it means that the RTL should only be
changed if the new address is valid. */
static void
The starting offset and size for this parm are returned in *OFFSET_PTR
and *ARG_SIZE_PTR, respectively.
- IN_REGS is non-zero if the argument will be passed in registers. It will
+ IN_REGS is nonzero if the argument will be passed in registers. It will
never be set if REG_PARM_STACK_SPACE is not defined.
FNDECL is the function in which the argument was defined.
since code outside the conditional won't know whether or not the
arguments need to be popped.)
- When INHIBIT_DEFER_POP is non-zero, however, the compiler does not
+ When INHIBIT_DEFER_POP is nonzero, however, the compiler does not
attempt to defer pops. Instead, the stack is popped immediately
after each call. Rather then setting this variable directly, use
NO_DEFER_POP and OK_DEFER_POP. */
used for the current function's args. */
CUMULATIVE_ARGS args_info;
- /* If non-zero, an RTL expression for the location at which the current
+ /* If nonzero, an RTL expression for the location at which the current
function returns its result. If the current function returns its
result in a register, current_function_return_rtx will always be
the hard register containing the result. */
#endif
/* The number of errors that have occurred; the link phase will not be
- run if this is non-zero. */
+ run if this is nonzero. */
static int error_count = 0;
/* Greatest exit code of sub-processes that has been encountered up to
\f
/* Build a list of search directories from PATHS.
PREFIX is a string to prepend to the list.
- If CHECK_DIR_P is non-zero we ensure the directory exists.
+ If CHECK_DIR_P is nonzero we ensure the directory exists.
This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
It is also used by the --print-search-dirs flag. */
/* These routines only work for signed values. */
/* Store a portable representation of VALUE in DEST using BYTES*8-1 bits.
- Return a non-zero value if VALUE requires more than BYTES*8-1 bits
+ Return a nonzero value if VALUE requires more than BYTES*8-1 bits
to store. */
static int
}
/* Retrieve a quantity containing BYTES*8-1 bits from SOURCE and store
- the result in DEST. Returns a non-zero value if the value in SOURCE
+ the result in DEST. Returns a nonzero value if the value in SOURCE
will not fit in DEST. */
static int
return 0;
}
-/* Write a BYTES*8-bit quantity to FILE, portably. Returns a non-zero
+/* Write a BYTES*8-bit quantity to FILE, portably. Returns a nonzero
value if the write fails, or if VALUE can't be stored in BYTES*8
bits.
}
/* Read a quantity containing BYTES bytes from FILE, portably. Return
- a non-zero value if the read fails or if the value will not fit
+ a nonzero value if the read fails or if the value will not fit
in DEST.
Note that DEST may not be large enough to hold all of the requested
static int output_function_summary = 0;
/* Object directory file prefix. This is the directory/file
- where .bb and .bbg files are looked for, if non-zero. */
+ where .bb and .bbg files are looked for, if nonzero. */
static char *object_directory = 0;
}
/* There will be a zero before the first file name, in which case s_ptr
will still be uninitialized. So, only try to set the maxlineno
- field if line_num is non-zero. */
+ field if line_num is nonzero. */
else if (line_num > 0)
{
if (s_ptr->maxlineno <= line_num)
/* An obstack for our working variables. */
static struct obstack gcse_obstack;
-/* Non-zero for each mode that supports (set (reg) (reg)).
+/* Nonzero for each mode that supports (set (reg) (reg)).
This is trivially true for integer and floating point values.
It may or may not be true for condition codes. */
static char can_copy_p[(int) NUM_MACHINE_MODES];
-/* Non-zero if can_copy_p has been initialized. */
+/* Nonzero if can_copy_p has been initialized. */
static int can_copy_init_p;
struct reg_use {rtx reg_rtx; };
struct occr *next;
/* The insn that computes the expression. */
rtx insn;
- /* Non-zero if this [anticipatable] occurrence has been deleted. */
+ /* Nonzero if this [anticipatable] occurrence has been deleted. */
char deleted_p;
- /* Non-zero if this [available] occurrence has been copied to
+ /* Nonzero if this [available] occurrence has been copied to
reaching_reg. */
/* ??? This is mutually exclusive with deleted_p, so they could share
the same byte. */
compute_transp (expr->expr, indx, transp, table->set_p);
/* The occurrences recorded in antic_occr are exactly those that
- we want to set to non-zero in ANTLOC. */
+ we want to set to nonzero in ANTLOC. */
if (antloc)
for (occr = expr->antic_occr; occr != NULL; occr = occr->next)
{
}
/* The occurrences recorded in avail_occr are exactly those that
- we want to set to non-zero in COMP. */
+ we want to set to nonzero in COMP. */
if (comp)
for (occr = expr->avail_occr; occr != NULL; occr = occr->next)
{
&& (num_clobbers == 0 || ! added_clobbers_hard_reg_p (icode)));
}
-/* Return non-zero if the operands of expression X are unchanged from the
+/* Return nonzero if the operands of expression X are unchanged from the
start of INSN's basic block up to but not including INSN (if AVAIL_P == 0),
or from INSN to the end of INSN's basic block (if AVAIL_P != 0). */
return 0;
}
-/* Return non-zero if the operands of expression X are unchanged from
+/* Return nonzero if the operands of expression X are unchanged from
the start of INSN's basic block up to but not including INSN. */
static int
return oprs_unchanged_p (x, insn, 0);
}
-/* Return non-zero if the operands of expression X are unchanged from
+/* Return nonzero if the operands of expression X are unchanged from
INSN to the end of INSN's basic block. */
static int
return hash % hash_table_size;
}
-/* Return non-zero if exp1 is equivalent to exp2.
+/* Return nonzero if exp1 is equivalent to exp2.
??? Borrowed from cse.c. Might want to remerge with cse.c. Later. */
static int
MODE is the mode of the value X is being stored into.
It is only used if X is a CONST_INT.
- ANTIC_P is non-zero if X is an anticipatable expression.
- AVAIL_P is non-zero if X is an available expression. */
+ ANTIC_P is nonzero if X is an anticipatable expression.
+ AVAIL_P is nonzero if X is an available expression. */
static void
insert_expr_in_table (x, mode, insn, antic_p, avail_p, table)
that isn't dealt with right now. The trick is handling the CLOBBERs that
are also in the PARALLEL. Later.
- If SET_P is non-zero, this is for the assignment hash table,
+ If SET_P is nonzero, this is for the assignment hash table,
otherwise it is for the expression hash table.
If IN_LIBCALL_BLOCK nonzero, we are in a libcall block, and should
not record any expressions. */
clear_modify_mem_tables ();
}
-/* Return non-zero if the operands of X are not set before INSN in
+/* Return nonzero if the operands of X are not set before INSN in
INSN's basic block. */
static int
SET_BIT (ae_gen[BLOCK_NUM (occr->insn)], expr->bitmap_index);
}
-/* Return non-zero if expression X is killed in BB. */
+/* Return nonzero if expression X is killed in BB. */
static int
expr_killed_p (x, bb)
\f
/* Actually perform the Classic GCSE optimizations. */
-/* Return non-zero if occurrence OCCR of expression EXPR reaches block BB.
+/* Return nonzero if occurrence OCCR of expression EXPR reaches block BB.
- CHECK_SELF_LOOP is non-zero if we should consider a block reaching itself
+ CHECK_SELF_LOOP is nonzero if we should consider a block reaching itself
as a positive reach. We want to do this when there are two computations
of the expression in the block.
}
}
-/* Return non-zero if the definition in DEF_INSN can reach INSN.
+/* Return nonzero if the definition in DEF_INSN can reach INSN.
Only called by can_disregard_other_sets. */
static int
return 0;
}
-/* Return non-zero if *ADDR_THIS_REG can only have one value at INSN. The
+/* Return nonzero if *ADDR_THIS_REG can only have one value at INSN. The
value returned is the number of definitions that reach INSN. Returning a
value of zero means that [maybe] more than one definition reaches INSN and
the caller can't perform whatever optimization it is trying. i.e. it is
/* Expression computed by insn is available and the substitution is legal,
so try to perform the substitution.
- The result is non-zero if any changes were made. */
+ The result is nonzero if any changes were made. */
static int
handle_avail_expr (insn, expr)
/* Perform classic GCSE. This is called by one_classic_gcse_pass after all
the dataflow analysis has been done.
- The result is non-zero if a change was made. */
+ The result is nonzero if a change was made. */
static int
classic_gcse ()
/* Top level routine to perform one classic GCSE pass.
- Return non-zero if a change was made. */
+ Return nonzero if a change was made. */
static int
one_classic_gcse_pass (pass)
}
/* Try to replace all non-SET_DEST occurrences of FROM in INSN with TO.
- Returns non-zero is successful. */
+ Returns nonzero is successful. */
static int
try_replace_reg (from, to, insn)
}
/* Perform constant and copy propagation on INSN.
- The result is non-zero if a change was made. */
+ The result is nonzero if a change was made. */
static int
cprop_insn (insn, alter_jumps)
}
/* Forward propagate copies. This includes copies and constants. Return
- non-zero if a change was made. */
+ nonzero if a change was made. */
static int
cprop (alter_jumps)
\f
/* PRE utilities */
-/* Return non-zero if an occurrence of expression EXPR in OCCR_BB would reach
+/* Return nonzero if an occurrence of expression EXPR in OCCR_BB would reach
block BB.
VISITED is a pointer to a working buffer for tracking which BB's have
the expression into the result of the SET. It is left to later passes
(cprop, cse2, flow, combine, regmove) to propagate the copy or eliminate it.
- Returns non-zero if a change is made. */
+ Returns nonzero if a change is made. */
static int
pre_delete ()
/* Top level routine to perform one PRE GCSE pass.
- Return non-zero if a change was made. */
+ Return nonzero if a change was made. */
static int
one_pre_gcse_pass (pass)
/* Top level routine to perform one code hoisting (aka unification) pass
- Return non-zero if a change was made. */
+ Return nonzero if a change was made. */
static int
one_code_hoisting_pass ()
SET_BIT (*regvec, REGNO (dest));
}
-/* Return non-zero if the register operands of expression X are killed
+/* Return nonzero if the register operands of expression X are killed
anywhere in basic block BB. */
static int
}
/* This routine will insert a store on an edge. EXPR is the ldst entry for
- the memory reference, and E is the edge to insert it on. Returns non-zero
+ the memory reference, and E is the edge to insert it on. Returns nonzero
if an edge insertion was performed. */
static int
fill the unit given the minimum issue delay. FILL-TIME is the
constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
the simultaneity constraint is "READY-COST (E) - FILL-TIME"
- if SIMULTANEITY is non-zero and zero otherwise.
+ if SIMULTANEITY is nonzero and zero otherwise.
Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
return 0;
}
\f
-/* Returns non-zero if the given expression contains an EQ_ATTR with the
+/* Returns nonzero if the given expression contains an EQ_ATTR with the
`alternative' attribute. */
static int
return 0;
}
\f
-/* Returns non-zero is INNER is contained in EXP. */
+/* Returns nonzero is INNER is contained in EXP. */
static int
contained_in_p (inner, exp)
/* Given a piece of RTX, print a C expression to test its truth value.
We use AND and IOR both for logical and bit-wise operations, so
interpret them as logical unless they are inside a comparison expression.
- The first bit of FLAGS will be non-zero in that case.
+ The first bit of FLAGS will be nonzero in that case.
Set the second bit of FLAGS to make references to attribute values use
a cached local variable instead of calling a function. */
}
\f
/* Write a subroutine that is given an insn that requires a delay slot, a
- delay slot ordinal, and a candidate insn. It returns non-zero if the
+ delay slot ordinal, and a candidate insn. It returns nonzero if the
candidate can be placed in the specified delay slot of the insn.
We can write as many as three subroutines. `eligible_for_delay'
}
/* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
- is non-zero, build a new attribute, if one does not exist. */
+ is nonzero, build a new attribute, if one does not exist. */
static struct attr_desc *
find_attr (name, create)
static void gen_peephole PARAMS ((rtx));
static void gen_peephole2 PARAMS ((rtx));
-/* RECOG_P will be non-zero if this pattern was seen in a context where it will
+/* RECOG_P will be nonzero if this pattern was seen in a context where it will
be used to recognize, rather than just generate an insn.
- NON_PC_SET_SRC will be non-zero if this pattern was seen in a SET_SRC
+ NON_PC_SET_SRC will be nonzero if this pattern was seen in a SET_SRC
of a SET whose destination is not (pc). */
static void
D1 and D2. Otherwise, return 1 (it may be that there is an RTL that
can match both or just that we couldn't prove there wasn't such an RTL).
- TOPLEVEL is non-zero if we are to only look at the top level and not
+ TOPLEVEL is nonzero if we are to only look at the top level and not
recursively descend. */
static int
\f
/* Assuming that the state of argument is denoted by OLDPOS, take whatever
actions are necessary to move to NEWPOS. If we fail to move to the
- new state, branch to node AFTERWARD if non-zero, otherwise return.
+ new state, branch to node AFTERWARD if nonzero, otherwise return.
Failure to move to the new state can only occur if we are trying to
match multiple insns and we try to step past the end of the stream. */
void debug_print_page_list PARAMS ((int));
\f
-/* Returns non-zero if P was allocated in GC'able memory. */
+/* Returns nonzero if P was allocated in GC'able memory. */
static inline int
ggc_allocated_p (p)
8
};
-/* Allocate a chunk of memory of SIZE bytes. If ZERO is non-zero, the
+/* Allocate a chunk of memory of SIZE bytes. If ZERO is nonzero, the
memory is zeroed; otherwise, its contents are undefined. */
void *
/* Actually set the mark on a particular region of memory, but don't
follow pointers. This function is called by ggc_mark_*. It
- returns zero if the object was not previously marked; non-zero if
+ returns zero if the object was not previously marked; nonzero if
the object was already marked, or if, for any other reason,
pointers in this data structure should not be traversed. */
extern int ggc_set_mark PARAMS ((const void *));
of a long enough stretch of hard regs none of which conflicts with ALLOCNO.
The registers marked in PREFREGS are tried first.
- LOSERS, if non-zero, is a HARD_REG_SET indicating registers that cannot
+ LOSERS, if nonzero, is a HARD_REG_SET indicating registers that cannot
be used for this allocation.
If ALT_REGS_P is zero, consider only the preferred class of ALLOCNO's reg.
#if __MINGW32_MAJOR_VERSION >= 1 || \
(__MINGW32_MAJOR_VERSION == 0 && __MINGW32_MINOR_VERSION > 2)
#define MINGW32_SUPPORTS_MT_EH 1
-/* Mingw runtime >= v0.3 provides a magic variable that is set to non-zero
+/* Mingw runtime >= v0.3 provides a magic variable that is set to nonzero
if -mthreads option was specified, or 0 otherwise. This is to get around
the lack of weak symbols in PE-COFF. */
extern int _CRT_MT;
Copying is done in two passes, first the insns and then their REG_NOTES.
- If static_chain_value is non-zero, it represents the context-pointer
+ If static_chain_value is nonzero, it represents the context-pointer
register for the function. */
static void
}
}
\f
-/* Return non-zero if CODE1 is more strict than CODE2, i.e., if the
+/* Return nonzero if CODE1 is more strict than CODE2, i.e., if the
truth of CODE1 implies the truth of CODE2. */
int
#ifdef HAVE_cc0
-/* Return non-zero if X is an RTX that only sets the condition codes
+/* Return nonzero if X is an RTX that only sets the condition codes
and has no side effects. */
int
completely handled within this function, it should set *SUBTREES to
0, so that generic handling isn't attempted. For language-specific
tree codes, generic handling would abort(), so make sure it is set
- properly. Both SUBTREES and *SUBTREES is guaranteed to be non-zero
+ properly. Both SUBTREES and *SUBTREES is guaranteed to be nonzero
when the function is called. */
tree
/* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
language-specific bookkeeping necessary for processing
- FN. start_inlining returns non-zero if inlining should proceed, zero if
+ FN. start_inlining returns nonzero if inlining should proceed, zero if
not.
For instance, the C++ version keeps track of template instantiations to
}
/* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree
- nodes. Returns non-zero if it does not want the usual dumping of the
+ nodes. Returns nonzero if it does not want the usual dumping of the
second argument. */
int
struct lang_hooks_for_tree_dump
{
- /* Dump language-specific parts of tree nodes. Returns non-zero if it
+ /* Dump language-specific parts of tree nodes. Returns nonzero if it
does not want the usual dumping of the second argument. */
int (*dump_tree) PARAMS ((void *, tree));
FUNCTIONBODY -- nonzero if this level is the body of a function. */
tree (*poplevel) PARAMS ((int, int, int));
- /* Returns non-zero if we are in the global binding level. Ada
+ /* Returns nonzero if we are in the global binding level. Ada
returns -1 for an undocumented reason used in stor-layout.c. */
int (*global_bindings_p) PARAMS ((void));
Should return zero unless the compiler back-end does not need to
be initialized, such as with the -E option.
- If errorcount is non-zero after this call the compiler exits
+ If errorcount is nonzero after this call the compiler exits
immediately and the finish hook is not called. */
bool (*post_options) PARAMS ((void));
/* Called at the end of compilation, as a finalizer. */
void (*finish) PARAMS ((void));
- /* Parses the entire file. The argument is non-zero to cause bison
+ /* Parses the entire file. The argument is nonzero to cause bison
parsers to dump debugging information during parsing. */
void (*parse_file) PARAMS ((int));
/* Returns the map a given map was included from. */
#define INCLUDED_FROM(SET, MAP) (&(SET)->maps[(MAP)->included_from])
-/* Non-zero if the map is at the bottom of the include stack. */
+/* Nonzero if the map is at the bottom of the include stack. */
#define MAIN_FILE_P(MAP) ((MAP)->included_from < 0)
/* The current line map. Saves a call to lookup_line if the caller is
return 0;
}
-/* Returns non-zero if X (used to initialize register REGNO) is movable.
+/* Returns nonzero if X (used to initialize register REGNO) is movable.
X is only movable if the registers it uses have equivalent initializations
which appear to be within the same loop (or in an inner loop) and movable
or if they are not candidates for local_alloc and don't vary. */
If we really combined them, we could lose if the pseudo lives
across an insn that clobbers the hard reg (eg, movstr).
- ALREADY_DEAD is non-zero if USEDREG is known to be dead even though
+ ALREADY_DEAD is nonzero if USEDREG is known to be dead even though
there is no REG_DEAD note on INSN. This occurs during the processing
of REG_NO_CONFLICT blocks.
- MAY_SAVE_COPYCOPY is non-zero if this insn is simply copying USEDREG to
+ MAY_SAVE_COPYCOPY is nonzero if this insn is simply copying USEDREG to
SETREG or if the input and output must share a register.
In that case, we record a hard reg suggestion in QTY_PHYS_COPY_SUGG.
}
}
-/* Record the death of REG in the current insn. If OUTPUT_P is non-zero,
+/* Record the death of REG in the current insn. If OUTPUT_P is nonzero,
REG is an output that is dying (i.e., it is never used), otherwise it
is an input (the normal case).
If OUTPUT_P is 1, then we extend the life past the end of this insn. */
If QTYNO crosses calls, insist on a register preserved by calls,
unless ACCEPT_CALL_CLOBBERED is nonzero.
- If JUST_TRY_SUGGESTED is non-zero, only try to see if the suggested
+ If JUST_TRY_SUGGESTED is nonzero, only try to see if the suggested
register is available. If not, return -1. */
static int
}
\f
/* Mark that REGNO with machine-mode MODE is live starting from the current
- insn (if LIFE is non-zero) or dead starting at the current insn (if LIFE
+ insn (if LIFE is nonzero) or dead starting at the current insn (if LIFE
is zero). */
static void
}
/* Mark register number REGNO (with machine-mode MODE) as live (if LIFE
- is non-zero) or dead (if LIFE is zero) from insn number BIRTH (inclusive)
+ is nonzero) or dead (if LIFE is zero) from insn number BIRTH (inclusive)
to insn number DEATH (exclusive). */
static void
is rounded towards 0.
5) count_leading_zeros(count, x) counts the number of zero-bits from the
- msb to the first non-zero bit in the UWtype X. This is the number of
+ msb to the first nonzero bit in the UWtype X. This is the number of
steps X needs to be shifted left to set the msb. Undefined for X == 0,
unless the symbol COUNT_LEADING_ZEROS_0 is defined to some value.
static rtx note_insn;
-/* Dummy register to have non-zero DEST_REG for DEST_ADDR type givs. */
+/* Dummy register to have nonzero DEST_REG for DEST_ADDR type givs. */
static rtx addr_placeholder;
}
-/* Return non-zero if it is possible to eliminate the biv BL provided
+/* Return nonzero if it is possible to eliminate the biv BL provided
all givs are reduced. This is possible if either the reg is not
used outside the loop, or we can compute what its final value will
be. */
expression that is neither invariant nor a biv or giv), this routine
returns 0.
- For a non-zero return, the result will have a code of CONST_INT, USE,
+ For a nonzero return, the result will have a code of CONST_INT, USE,
REG (for a BIV), PLUS, or MULT. No other codes will occur.
*BENEFIT will be incremented by the benefit of any sub-giv encountered. */
return simplify_giv_expr (loop, m->match->set_dest,
ext_val, benefit);
- /* If consec is non-zero, this is a member of a group of
+ /* If consec is nonzero, this is a member of a group of
instructions that were moved together. We handle this
case only to the point of seeking to the last insn and
looking for a REG_EQUAL. Fail if we don't find one. */
/* Verify whether the biv BL appears to be eliminable,
based on the insns in the loop that refer to it.
- If ELIMINATE_P is non-zero, actually do the elimination.
+ If ELIMINATE_P is nonzero, actually do the elimination.
THRESHOLD and INSN_COUNT are from loop_optimize and are used to
determine whether invariant insns should be placed inside or at the
}
\f
/* INSN and REFERENCE are instructions in the same insn chain.
- Return non-zero if INSN is first. */
+ Return nonzero if INSN is first. */
int
loop_insn_first_p (insn, reference)
}
}
-/* We are trying to eliminate BIV in INSN using GIV. Return non-zero if
+/* We are trying to eliminate BIV in INSN using GIV. Return nonzero if
the offset that we have to take into account due to auto-increment /
div derivation is zero. */
static int
If BIV does not appear in X, return 1.
- If ELIMINATE_P is non-zero, actually do the elimination.
+ If ELIMINATE_P is nonzero, actually do the elimination.
WHERE_INSN/WHERE_BB indicate where extra insns should be added.
Depending on how many items have been moved out of the loop, it
- will either be before INSN (when WHERE_INSN is non-zero) or at the
+ will either be before INSN (when WHERE_INSN is nonzero) or at the
start of the loop (when WHERE_INSN is zero). */
static int
If the condition cannot be understood, or is an inequality floating-point
comparison which needs to be reversed, 0 will be returned.
- If REVERSE is non-zero, then reverse the condition prior to canonizing it.
+ If REVERSE is nonzero, then reverse the condition prior to canonizing it.
- If EARLIEST is non-zero, it is a pointer to a place where the earliest
+ If EARLIEST is nonzero, it is a pointer to a place where the earliest
insn used in locating the condition was found. If a replacement test
of the condition is desired, it should be placed in front of that
insn and we will be sure that the inputs are still valid.
- If WANT_REG is non-zero, we wish the condition to be relative to that
+ If WANT_REG is nonzero, we wish the condition to be relative to that
register, if possible. Therefore, do not canonicalize the condition
further. */
&& op1 == CONST0_RTX (GET_MODE (op0))
&& op0 != want_reg)
{
- /* Set non-zero when we find something of interest. */
+ /* Set nonzero when we find something of interest. */
rtx x = 0;
#ifdef HAVE_cc0
inequality floating-point comparison which needs to be reversed, 0 will
be returned.
- If EARLIEST is non-zero, it is a pointer to a place where the earliest
+ If EARLIEST is nonzero, it is a pointer to a place where the earliest
insn used in locating the condition was found. If a replacement test
of the condition is desired, it should be placed in front of that
insn and we will be sure that the inputs are still valid. */
}
-/* If WHERE_INSN is non-zero emit insn for PATTERN before WHERE_INSN
+/* If WHERE_INSN is nonzero emit insn for PATTERN before WHERE_INSN
in basic block WHERE_BB (ignored in the interim) within the loop
otherwise hoist PATTERN into the loop pre-header. */
same biv register. */
struct induction *same; /* If this giv has been combined with another
giv, this points to the base giv. The base
- giv will have COMBINED_WITH non-zero. */
+ giv will have COMBINED_WITH nonzero. */
HOST_WIDE_INT const_adjust; /* Used by loop unrolling, when an address giv
is split, and a constant is eliminated from
the address, the -constant is stored here
struct loop_regs regs;
/* The induction variable information in loop. */
struct loop_ivs ivs;
- /* Non-zero if call is in pre_header extended basic block. */
+ /* Nonzero if call is in pre_header extended basic block. */
int pre_header_has_call;
};
projects / thirdparty / gcc.git / commitdiff
